calendarui/views/src/calennativeview.cpp
branchRCL_3
changeset 66 bd7edf625bdd
parent 65 12af337248b1
child 74 97232defd20e
--- a/calendarui/views/src/calennativeview.cpp	Tue Aug 31 15:13:43 2010 +0300
+++ b/calendarui/views/src/calennativeview.cpp	Wed Sep 01 12:32:31 2010 +0100
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2007-2008 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"
@@ -12,313 +12,1452 @@
 * Contributors:
 *
 * Description:  This class is the base class of all Calendar views.
- *
- */
+*
+*/
+
+
+// INCLUDES
+#include <calenconstants.h>
+#include <calenagendautils.h>
+#include <calendateutils.h>
+#include <calentoolbar.h>
+#include <Calendar.rsg>
+#include <CalenStatusPaneUtils.h>
+#include <calencontext.h>
+#include <caltime.h>
+#include <calinstance.h>
+#include <calinstanceview.h>
+#include <calentry.h>
+#include <aknlists.h>
+#include <aknnavide.h>
+#include <aknnotewrappers.h>
+#include <AknWaitDialog.h>
+#include <eikbtgpc.h>
+#include <centralrepository.h>
+#include <StringLoader.h>
+#include <sysutil.h>
+#include <hlplch.h>
+#include <akntoolbar.h>
+#include <calencommands.hrh>
+#include <calenservices.h>
+#include <calsession.h>
+#include <calenviewutils.h>
+#include <calcalendarinfo.h>
+#include <caleninstanceid.h>            // TCalenInstanceId
+
+
+#include "calendarui_debug.h"           // Debug.
+#include "CalendarVariant.hrh"
+#include "calennativeview.h"
+#include "calencontainer.h"
+#include "CalenInterimUtils2.h"
+#include "calensend.h"
+#include "calentitlepane.h"
+#include "CleanupResetAndDestroy.h"
+#include "CalenPaths.h"
+#include "calendar.hrh"
+#include "CalenUid.h"
+#include "CalendarPrivateCRKeys.h"
+#include "multicaluidialog.h"
+
+const TInt KAbbreviatedWeekNames[] =
+    {
+    R_QTN_WEEK_TWO_CHARS_MO,
+    R_QTN_WEEK_TWO_CHARS_TU,
+    R_QTN_WEEK_TWO_CHARS_WE,
+    R_QTN_WEEK_TWO_CHARS_TH,
+    R_QTN_WEEK_TWO_CHARS_FR,
+    R_QTN_WEEK_TWO_CHARS_SA,
+    R_QTN_WEEK_TWO_CHARS_SU
+    };
+
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+#include  <aiwservicehandler.h>
+
+// MIME types
+_LIT8(KContentTypeCalendar, "text/calendar");
+
+#endif //RD_CALEN_EXTERNAL_CAL
+
+
+#include <aknnavilabel.h>
+#include <calennavilabel.h>
+
+
+// ================= MEMBER FUNCTIONS =======================
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::~CCalenNativeView
+// Destructor
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+CCalenNativeView::~CCalenNativeView()
+    {
+    TRACE_ENTRY_POINT;
+
+    CCoeAppUi* appui = CEikonEnv::Static()->AppUi();
+    appui->RemoveFromStack( iContainer );
+
+    delete iContainer;
+
+    iServices.CancelNotifications( this );
+
+    delete iAbbreviatedDayArray;
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+    //delete AIW iServiceHandler;
+    ReleaseServiceHandler();
+#endif //RD_CALEN_EXTERNAL_CAL
+
+    delete iMenuName;
+    delete iSettingsName;
+    
+    delete iSPUtils;
+
+    if( iAsyncCallback )
+        {
+        iAsyncCallback->Cancel();
+        delete iAsyncCallback;
+        iAsyncCallback = NULL;
+        }
+    
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::SetStatusPaneFromActiveContextL(
+// This function sets the status pane based upon the context
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::SetStatusPaneFromActiveContextL()
+    {
+    TRACE_ENTRY_POINT;
+    iSPUtils->RefreshStatusPane();
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::Container
+// Return container control pointer.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+CCalenContainer* CCalenNativeView::Container()
+    {
+    TRACE_ENTRY_POINT;
+
+    TRACE_EXIT_POINT;
+    return iContainer;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::OnCmdGotoDateL
+// Handling command "Go to day"
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::OnCmdGotoDateL()
+    {
+    TRACE_ENTRY_POINT;
 
-// system includes
-#include <QtGui>
-#include <hbwidget.h>
-#include <hblabel.h>
-#include <hbaction.h>
-#include <hbdialog.h>
-#include <hbmainwindow.h>
-#include <hbdatetimepicker.h>
-#include <vwsdef.h>
-#include <hbactivitymanager.h> //Activity Manager
-#include <hbapplication.h> //hbapplication
+    TTime date = CalenDateUtils::Today();
+	
+    TInt buttonId = CalenViewUtils::DateQueryL( date, 0 );
+	
+		//test
+	TDateTime dateTime = date.DateTime();
+	
+    if (buttonId == EAknSoftkeyOk || buttonId == EEikBidOk)
+        {
+        MCalenContext& context = iServices.Context();
+        TCalTime dateCalTime;
+        dateCalTime.SetTimeLocalL( date );
+        context.SetFocusDateAndTimeL( dateCalTime, context.ViewId() );
+        iContainer->NotifyChangeDateL();
+        }
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::OnCmdGotoTodayL
+// Handling command "Today". # key is pressed.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::OnCmdGotoTodayL()
+    {
+    TRACE_ENTRY_POINT;
+
+    TTime today = CalenDateUtils::Today();
+
+    MCalenContext& context = iServices.Context();
+    TCalTime todayCalTime;
+    todayCalTime.SetTimeLocalL( today );
+    context.SetFocusDateAndTimeL( todayCalTime, context.ViewId() );
+
+    iContainer->NotifyChangeDateL();
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::NotifyFocusChanged
+// Notified that the focus of Container changes.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::NotifyFocusChanged()
+    {
+    TRACE_ENTRY_POINT;
+
+    // FIXME: iLocChangeReason doesn't seem to serve any purpose.
+    // Debug how it is used.
+    if (iContainer && iNeedsRefresh)
+        {
+        if (IsForeground() && IsContainerFocused())
+            {
+            //The database was changed while calendar was running as a
+            //background task or the editor was open.  We need to refresh.
+            TRAP_IGNORE(BeginRepopulationL());
+            iNeedsRefresh = EFalse;
+            }
+        }
+    if (iLocChangeReason && IsContainerFocused())
+        {
+        PIM_TRAPD_HANDLE( OnLocaleChangedL( iLocChangeReason ) );
+        }
+    iLocChangeReason = 0;
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::IsContainerFocused
+// Is container focused?
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TBool CCalenNativeView::IsContainerFocused()
+    {
+    TRACE_ENTRY_POINT;
 
-//user includes
-#include <CalenUid.h>
-#include "calennativeview.h"
-#include "calenservices.h"
-#include "calencontext.h"
-#include "calensettingsview.h"
-#include "calendateutils.h"
-#include "calenconstants.h"
-#include "OstTraceDefinitions.h"
-#ifdef OST_TRACE_COMPILER_IN_USE
-#include "calennativeviewTraces.h"
-#endif
+    TRACE_EXIT_POINT;
+    return (iContainer && iContainer->IsVisible());
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::ShowValidScrollButtons
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::ShowValidScrollButtons(CAknNavigationDecorator& aNaviLabel,
+                                        const TTime& aBeforeRange,
+                                        const TTime& aAfterRange)
+    {
+    TRACE_ENTRY_POINT;
+
+    aNaviLabel.MakeScrollButtonVisible(ETrue);
+
+    // FIXME can be written more simply.
+    TBool mirrored(AknLayoutUtils::LayoutMirrored());
+    if (mirrored)
+        {
+        TBool validDay(CalenDateUtils::IsValidDay(aBeforeRange));
+        aNaviLabel.SetScrollButtonDimmed(
+            CAknNavigationDecorator::ERightButton, !validDay);
+        validDay = CalenDateUtils::IsValidDay(TTime(aAfterRange));
+        aNaviLabel.SetScrollButtonDimmed(
+            CAknNavigationDecorator::ELeftButton, !validDay);
+        }
+    else
+        {
+        TBool validDay(CalenDateUtils::IsValidDay(aBeforeRange));
+        aNaviLabel.SetScrollButtonDimmed(
+            CAknNavigationDecorator::ELeftButton, !validDay);
+        validDay = CalenDateUtils::IsValidDay(aAfterRange);
+        aNaviLabel.SetScrollButtonDimmed(
+            CAknNavigationDecorator::ERightButton, !validDay);
+        }
+
+
+    if(iContainer && AknLayoutUtils::PenEnabled())
+        {
+        aNaviLabel.SetNaviDecoratorObserver(static_cast<MAknNaviDecoratorObserver*>(iContainer));
+        CCoeControl* coeRes = aNaviLabel.DecoratedControl();
+        CCalenNaviLabel *actualLabel = static_cast<CCalenNaviLabel*>(coeRes);
+        actualLabel->SetLabelObserver(static_cast<MCCalenNaviLabelObserver*>(iContainer));
+        }
+
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::DynInitMenuPaneL
+// Initialization of Options menu
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)
+    {
+    TRACE_ENTRY_POINT;
+
+    switch (aResourceId)
+        {
+        case R_CALENDAR_NOTETYPE_MENUPANE:
+            {
+            if( !iServices.InterimUtilsL().MRViewersEnabledL( ETrue ) )
+                {
+                aMenuPane->DeleteMenuItem( ECalenNewMeetingRequest );
+                }
+            break;
+            }
+        case R_CALENDAR_CHANGE_VIEW_MENUPANE:
+            {
+            // If we get the cascading view switch menu pane, 
+            // need to offer it to the services, to remove
+            // the current view.
+            iServices.OfferMenuPaneL( aResourceId, aMenuPane );
+            }
+            break;
+        default:
+            {
+#ifdef RD_CALEN_EXTERNAL_CAL
+            // do we have a service handler, if not create one
+            if (!iServiceHandler)
+                {
+                CreateServiceHandlerL(ETrue);
+                }
 
 
-/*!
- \class CalenNativeView
- Base class for all calendar views
- */
+            if (iServiceHandler->HandleSubmenuL(*aMenuPane))
+                {
+                return;
+                }
 
-/*!
- Default constructor.
- */
-CalenNativeView::CalenNativeView(MCalenServices &services) :
-	mServices(services),
-	mEntriesInDataBase(false),
-	mIsCapturedScreenShotValid(false)
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_CALENNATIVEVIEW_ENTRY );
-    
-	setTitle(hbTrId("txt_calendar_title_calendar"));
-
-	// Create services API and register for notifications
-	RArray<TCalenNotification> notificationArray;
-	CleanupClosePushL(notificationArray);
-
-	notificationArray.Append(ECalenNotifySystemTimeChanged);
-	notificationArray.Append(ECalenNotifySystemLocaleChanged);
-	notificationArray.Append(ECalenNotifyContextChanged);
-
-	mServices.RegisterForNotificationsL(this, notificationArray);
+            // is the menu item AIW menu item if so, we will initialize our menu item
+            if (iServiceHandler->IsAiwMenu(aResourceId))
+                {
+                CAiwGenericParamList& inParamList = iServiceHandler->InParamListL();
+                TInt extrainfo=0;
+                TAiwVariant variant(extrainfo);
+                // No generic param for integer, therefore use EGenericParamError.
+                TAiwGenericParam param(EGenericParamError, variant);
+                inParamList.AppendL(param);
 
-	CleanupStack::PopAndDestroy(&notificationArray);
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_CALENNATIVEVIEW_EXIT );
-}
+                iServiceHandler->InitializeMenuPaneL(
+                    *aMenuPane,
+                    aResourceId,
+                    ECalenExtAiwCommandId,
+                    inParamList);
+                }
+#endif
+            break;
+            }
+        }
+    TRACE_EXIT_POINT;
+    }
 
-/*!
- Destructor
- */
-CalenNativeView::~CalenNativeView()
-{
-    OstTraceFunctionEntry0( DUP1_CALENNATIVEVIEW_CALENNATIVEVIEW_ENTRY );
-    
-    OstTraceFunctionExit0( DUP1_CALENNATIVEVIEW_CALENNATIVEVIEW_EXIT );
-}
-
-/*!
- Issues populcaiton complete to the framework
- */
-void CalenNativeView::populationComplete()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_POPULATIONCOMPLETE_ENTRY );
-    
-	// Population is complete, issue the notification
-	mServices.IssueNotificationL(ECalenNotifyViewPopulationComplete);
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_POPULATIONCOMPLETE_EXIT );
-}
+// ----------------------------------------------------------------------------
+// CCalenNativeView::HandleCommandL
+// Command handling for each view
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::HandleCommandL(TInt aCommand)
+    {
+    TRACE_ENTRY_POINT;
 
-/*!
- Slot for delete before date
- */
-void CalenNativeView::deleteBeforeDate()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_DELETEBEFOREDATE_ENTRY );
-    
-	mServices.IssueCommandL(ECalenDeleteEntriesBeforeDate);
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_DELETEBEFOREDATE_EXIT );
-}
-
-/*!
- Slot for delete all entries
- */
-void CalenNativeView::deleteAllEntries()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_DELETEALLENTRIES_ENTRY );
-    
-	mServices.IssueCommandL(ECalenDeleteAllEntries);
-	mEntriesInDataBase = false;
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_DELETEALLENTRIES_EXIT );
-}
+     switch (aCommand)
+        {
+        case EAknCmdHelp:
+            HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), iAvkonAppUi->AppHelpContextL() );
+            break;
 
-/*!
- Slot to handle gotodate
- */
-void CalenNativeView::goToDate()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_GOTODATE_ENTRY );
-    
-	// Create a popup with datepicker for the user to select date.
-	HbDialog *popUp = new HbDialog();
-	popUp->setDismissPolicy(HbDialog::NoDismiss);
-	popUp->setTimeout(HbDialog::NoTimeout);
-	popUp->setAttribute( Qt::WA_DeleteOnClose, true );
-	popUp->setHeadingWidget(new HbLabel(hbTrId("txt_calendar_opt_go_to_date")));
-	
-	if(mDatePicker) {
-		mDatePicker = NULL;
-	}
-	mDatePicker = new HbDateTimePicker(QDate::currentDate(), popUp);
-	// Set the date range.
-	mDatePicker->setMinimumDate(CalenDateUtils::minTime().date());
-	mDatePicker->setMaximumDate(CalenDateUtils::maxTime().date());
-	mDatePicker->setDate(QDate::currentDate());
-	
-	popUp->setContentWidget(mDatePicker);
-	HbAction *okAction = new HbAction(hbTrId("txt_common_button_ok"));
-	popUp->addAction(okAction);
-	connect(okAction, SIGNAL(triggered()), this, SLOT(goToSelectedDate()));
-	popUp->addAction(new HbAction(hbTrId("txt_common_button_cancel"), popUp));
-	popUp->open();
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_GOTODATE_EXIT );
-}
+        // Context should be 8am on current focused day for these actions.
+        case ECalenNewMeeting:
+        case ECalenNewMeetingRequest:
+        case ECalenNewAnniv:
+        case ECalenNewDayNote:
+        case ECalenNewTodo:
+            {
+            iIsEditorActive = ETrue;
+            MCalenContext& context = iServices.Context();
+            // Set the date on the context. It will set it to be the
+            // default of view (8am) on that day as we don't set the time.
+            TCalTime time;
+            time.SetTimeLocalL( CCalenContainer::DateFromContextL( context ) );
+            context.SetFocusDateL( time,
+                                   TVwsViewId( KUidCalendar, Id() ) );
+            iServices.IssueCommandL( aCommand );
+            }
+            break;
+        case ECalenShowSettings:
+            {
+            iIsEditorActive = ETrue;
+            iServices.IssueCommandL( aCommand );
+            }
+            break;
+        case ECalenMonthView:
+        case ECalenWeekView:
+        case ECalenDayView:
+        case ECalenTodoView:
+            {
+            MCalenContext& context = iServices.Context();
+            // Set the date on the context. It will set it to be the
+            // default of view (8am) on that day as we don't set the time.
+            TCalTime time;
+            time.SetTimeLocalL( CCalenContainer::DateFromContextL( context ) );
+            context.SetFocusDateL( time,
+                                   TVwsViewId( KUidCalendar, Id() ) );
+            iServices.IssueCommandL( aCommand );
+            }
+            break;
 
-/*
- Slot to handle date selected on gotodate popup
- */
-void CalenNativeView::goToSelectedDate()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_GOTOSELECTEDDATE_ENTRY );
-    
-	QDate selectedDate = mDatePicker->date();
+        // The context should remain the same for these actions.
+        case ECalenForwardsToDayView:
+        case ECalenNextView:
+        case ECalenPrevView:
+        case ECalenViewCurrentEntry:
+        case ECalenEditCurrentEntry: 
+        case ECalenCompleteTodo:
+        case ECalenRestoreTodo:
+        case ECalenDeleteAllEntries:
+        case ECalenDeleteCurrentEntry:
+        case ECalenDeleteEntriesBeforeDate:
+        //case ECalenGlobalSendAsCmdId:
+        
+            
+                SetCommandHandlingInProgress( ETrue );
+                iServices.IssueCommandL( aCommand );
+            break;
+            
+        case ECalenEventView:
+        case ECalenSwitchView:  
+		case ECalenSend:
+            iServices.IssueCommandL( aCommand );
+            break;
 
-	// Check if the selected date is within the range.
-	if (selectedDate.isValid() &&
-	        selectedDate >= CalenDateUtils::minTime().date() &&
-	        selectedDate <= CalenDateUtils::maxTime().date()) {
-		MCalenContext& context = mServices.Context();
-		QDateTime contextDate = context.focusDateAndTime();
+        case ECalenGotoDate:
+            OnCmdGotoDateL();
+            break;
+
+        case ECalenGotoToday:
+            OnCmdGotoTodayL();
+            break;
 
-		//Set the selected date to contextDate.
-		contextDate.setDate(selectedDate);
-		context.setFocusDateAndTime(contextDate);
-	}
-	refreshViewOnGoToDate();
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_GOTOSELECTEDDATE_EXIT );
-}
+        default:
+            {
+#ifdef RD_CALEN_EXTERNAL_CAL
+            // by default we will check also AIW commands
+            if (!iServiceHandler)
+                {
+                CreateServiceHandlerL(ETrue);
+                }
+
+
+            TInt aiwCmd = iServiceHandler->ServiceCmdByMenuCmd(aCommand);
 
-/*!
- Virtual function to refresh the current view upon selecting a date
- from GoToDate popup
- */
-void CalenNativeView::refreshViewOnGoToDate()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_REFRESHVIEWONGOTODATE_ENTRY );
-    
-	mServices.IssueCommandL(ECalenStartActiveStep);
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_REFRESHVIEWONGOTODATE_EXIT );
-}
+            // if we have right one, handle it
+            if(aiwCmd)
+                {
+                // add current focused date to param list
+                MCalenContext& context = iServices.Context();
+                TTime time = context.FocusTime().TimeLocalL();
+
+                CAiwGenericParamList& inparams=iServiceHandler->InParamListL();
+                TAiwGenericParam date(EGenericParamDateTime);
+                date.Value().Set(time);
+                inparams.AppendL(date);
+
+                // Execute AIW menu service command.
+                PIM_TRAPD_HANDLE(
+                iServiceHandler->ExecuteMenuCmdL(
+                    aCommand,                           // The service command
+                    inparams,    // pass our date
+                    iServiceHandler->OutParamListL(),   // No output parameters needed
+                    KAiwOptASyncronous,                  // we are using async version
+                    this ));                             // and we want to call us back
+                }
+            // if not then let ui framwork handle it
 
-/*!
- Slot to handle setting item in options menu
- */
-void CalenNativeView::launchSettingsView()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_LAUNCHSETTINGSVIEW_ENTRY );
-    
-	mServices.IssueCommandL(ECalenShowSettings);
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_LAUNCHSETTINGSVIEW_EXIT );
-}
+            else
+                {
+#endif
+                iServices.IssueCommandL( aCommand );
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+                }
+#endif // RD_CALEN_EXTERNAL_CAL
+
+            break;
+
+            }
 
-/*!
- Slot to handle to orientation change
- */
-void CalenNativeView::changeOrientation(Qt::Orientation orientation)
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_CHANGEORIENTATION_ENTRY );
+        }
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::DynInitMenuBarL
+// other details are commented in the header
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::DynInitMenuBarL( TInt /*aResourceId*/, CEikMenuBar* aMenuBar )
+    {
+    TRACE_ENTRY_POINT;
     
-    Q_UNUSED(orientation);
-    // Nothing, derived classes will implement it
-    OstTraceFunctionExit0( CALENNATIVEVIEW_CHANGEORIENTATION_EXIT );
-}
-
-/*!
- Handles the interested notifications from the calendar framework
- */
-void CalenNativeView::HandleNotification(const TCalenNotification notification)
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_HANDLENOTIFICATION_ENTRY );
+    if( aMenuBar && IsCommandHandlingInProgress() )
+        {
+        aMenuBar->StopDisplayingMenuBar();
+        }
     
-	switch (notification) {
-		case ECalenNotifySystemLocaleChanged: {
-			onLocaleChanged(EChangesLocale);
-		}
-		break;
-		case ECalenNotifySystemTimeChanged: {
-			onLocaleChanged(EChangesSystemTime);
-		}
-		break;
-		case ECalenNotifyContextChanged: {
-			onContextChanged();
-		}
-		break;
-		default:
-			break;
-	}
-	
-	OstTraceFunctionExit0( CALENNATIVEVIEW_HANDLENOTIFICATION_EXIT );
-}
-
-/*!
- Returns true if plugin is loaded
- */
-TBool CalenNativeView::pluginEnabled()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_PLUGINENABLED_ENTRY );
-    
-	QString *pluginInfo = mServices.InfobarTextL();
-	if (!pluginInfo) {
-		OstTraceFunctionExit0( CALENNATIVEVIEW_PLUGINENABLED_EXIT );
-		return false;
-	} else {
-		OstTraceFunctionExit0( DUP1_CALENNATIVEVIEW_PLUGINENABLED_EXIT );
-		return true;
-	}
-}
-
-QString *CalenNativeView::pluginText()
-{
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_PLUGINTEXT_ENTRY );
-    
-    OstTraceFunctionExit0( CALENNATIVEVIEW_PLUGINTEXT_EXIT );
-	return mServices.InfobarTextL();
-	
-}
+    TRACE_EXIT_POINT;
+    }
 
 // ----------------------------------------------------------------------------
-// captureScreenshot caltures screen shot for the given viewId
-// @param viewId view for which screenshot needs to be captured
+// CCalenNativeView::CopytoCalendarsL
+// From CAknView
+// Return the UID of the day view
+// (other items were commented in a header)
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::CopyToCalendarsL()
+    {
+    TRACE_ENTRY_POINT;
+    
+    iAsyncCallback->CallBack();
+    
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::AsyncCopyToCalendarsL
+// From CAknView
+// Return the UID of the day view
+// (other items were commented in a header)
 // ----------------------------------------------------------------------------
-// 
-void CalenNativeView::captureScreenshot(bool captureScreenShot)
+//
+TInt CCalenNativeView::AsyncCopyToCalendarsL( TAny* aThisPtr )
     {
-    OstTraceFunctionEntry0( CALENNATIVEVIEW_CAPTURESCREENSHOT_ENTRY );
+    TRACE_ENTRY_POINT;
+    
+    static_cast<CCalenNativeView*>(aThisPtr)->CopyEntryToCalendarsL();
+    
+    TRACE_EXIT_POINT;
+    return 0;
+
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::CopyEntryToCalendarsL
+// From CAknView
+// Return the UID of the day view
+// (other items were commented in a header)
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::CopyEntryToCalendarsL()
+    {
+    TRACE_ENTRY_POINT;
     
-    // get a screenshot for saving to the activity manager. It's done for once
-    // to optimize the performance
-    if (captureScreenShot) {
-        mScreenShotMetadata.clear(); // remove any screenshot captured earlier
-        mScreenShotMetadata.insert("screenshot", QPixmap::grabWidget(mainWindow(), mainWindow()->rect()));
+    // Create settings own titlepane and navipane, and swap with existing ones
+    CEikStatusPane* sp = CEikonEnv::Static()->AppUiFactory()->StatusPane();
+
+    // Hide the toolbar before we display settings menu
+    MCalenToolbar* toolbar = iServices.ToolbarOrNull();
+    if(toolbar)
+        {
+        toolbar->SetToolbarVisibilityL(EFalse);  
+        }
+    iSPUtils->UnderLineTitleText( EFalse );
+
+    // Titlepane
+    CAknTitlePane* newtp = new( ELeave ) CAknTitlePane();
+    CleanupStack::PushL( newtp );
+    CCoeControl* oldtp = sp->SwapControlL( TUid::Uid(EEikStatusPaneUidTitle), newtp );
+    CleanupStack::Pop( newtp ); // ownership is passed to statuspane
+    TRect oldRect( 0, 0, 0, 0 );
+    if( oldtp )
+        {
+        CleanupStack::PushL( oldtp );
+        oldRect = oldtp->Rect();
+        CCoeControl* ctrl = sp->ContainerControlL( TUid::Uid( EEikStatusPaneUidTitle ));
+        newtp->SetContainerWindowL( *ctrl );
+        newtp->ConstructL();
+        newtp->SetRect(oldRect);
+        newtp->ActivateL();
+        }        
+
+    // NaviPane
+    CAknNavigationControlContainer* newnp = new( ELeave )CAknNavigationControlContainer();
+    CleanupStack::PushL( newnp );
+    CCoeControl* oldnp = sp->SwapControlL( TUid::Uid( EEikStatusPaneUidNavi ), newnp );
+    CleanupStack::Pop( newnp ); // ownership is passed to statuspane
+    if( oldnp )
+        {
+        CleanupStack::PushL( oldnp );
+        oldRect = oldnp->Rect();
+        CCoeControl* ctrl = sp->ContainerControlL( TUid::Uid( EEikStatusPaneUidNavi ) );
+        newnp->SetContainerWindowL( *ctrl );
+        newnp->ConstructL();
+        newnp->SetRect( oldRect );
+        newnp->PushDefaultL();
+        newnp->ActivateL();
+        }
+
+    MCalenContext& context = iServices.Context();
+    TCalLocalUid instanceId = context.InstanceId().iEntryLocalUid;
+
+    CCalEntry* entry = iServices.EntryViewL(context.InstanceId().iColId)->FetchL(instanceId);
+    CleanupStack::PushL(entry);
+
+    RPointerArray<CCalEntry> calentryArray;
+    calentryArray.Append( entry );
+
+    // Launch the Calendar List Dialiog.
+    CMultiCalUiDialog* calenDbListDialog = CMultiCalUiDialog::NewLC(calentryArray, EFalse);
+    TInt err = KErrNone;
+    // Execute.
+    TRAP( err,calenDbListDialog->LaunchL() );
+    CleanupStack::PopAndDestroy( calenDbListDialog );
+
+    iSPUtils->UnderLineTitleText( EFalse );
+    // Unhide the toolbar when settings is closed
+    if(toolbar)
+        {
+        toolbar->SetToolbarVisibilityL(ETrue); 
+        }
+    
+    CleanupStack::Pop(entry);
+    calentryArray.ResetAndDestroy(); 
+    
+    // When setting is closed, swap back old titlepane and navipane
+    if( oldnp && sp->SwapControlL( TUid::Uid(EEikStatusPaneUidNavi), oldnp ) )
+        {
+        CleanupStack::Pop( oldnp );
+        delete newnp;
+        oldnp->ActivateL();
         }
-    mIsCapturedScreenShotValid = captureScreenShot; // set the validity of the screenshot captured
+
+    if( oldtp && sp->SwapControlL( TUid::Uid(EEikStatusPaneUidTitle), oldtp ) )
+        {
+        CleanupStack::Pop( oldtp );
+        delete newtp;
+        oldtp->ActivateL();
+        }
+    
+    BeginRepopulationL();
+    
+    TRACE_EXIT_POINT;
+    
+    }
+
+// ----------------------------------------------------------------------------
+// C++ constructor can NOT contain any code, that
+// might leave.
+// ----------------------------------------------------------------------------
+//
+CCalenNativeView::CCalenNativeView( MCalenServices& aServices )
+    : iServices( aServices )
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::ConstructL
+// Symbian OS default constructor
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::CommonConstructL( TInt aViewResource )
+    {
+    TRACE_ENTRY_POINT;
+
+    BaseConstructL( aViewResource );
     
-    OstTraceFunctionExit0( CALENNATIVEVIEW_CAPTURESCREENSHOT_EXIT );
+    // Initialize CCalenStatusPaneUtils
+    CEikStatusPane* sp = StatusPane();
+    iSPUtils = CCalenStatusPaneUtils::NewL( sp );
+
+    ClearViewSpecificDataL(); // Reset vsd.
+
+    // Create services API and register for notifications
+    RArray<TCalenNotification> notificationArray;
+    notificationArray.Append(ECalenNotifySystemTimeChanged);
+    notificationArray.Append(ECalenNotifyMarkedEntryDeleted);
+    notificationArray.Append(ECalenNotifyContextChanged);
+    notificationArray.Append(ECalenNotifyDialogClosed);
+    notificationArray.Append(ECalenNotifyEntrySent);    
+    notificationArray.Append(ECalenNotifyEntryClosed);
+    notificationArray.Append(ECalenNotifySystemLocaleChanged);
+    notificationArray.Append(ECalenNotifyAppForegrounded);
+    notificationArray.Append(ECalenNotifyAppBackgrounded);
+    notificationArray.Append(ECalenNotifyEntrySaved);
+    notificationArray.Append(ECalenNotifyInstanceSaved);
+    notificationArray.Append(ECalenNotifySettingsClosed);
+    notificationArray.Append(ECalenNotifySettingsChanged);
+    notificationArray.Append(ECalenNotifyMarkedEntryCompleted);
+    notificationArray.Append(ECalenNotifyDeleteInstanceView);
+    notificationArray.Append(ECalenNotifyStopAlarm);
+	notificationArray.Append(ECalenNotifyDeleteFailed);
+	notificationArray.Append(ECalenNotifyEntryDeleted);
+	notificationArray.Append(ECalenNotifyResourceChanged);
+	notificationArray.Append(ECalenNotifyEventViewLaunchedFromAlarm);
+	
+    iServices.RegisterForNotificationsL( this,notificationArray);
+    
+    notificationArray.Reset();
+    
+    iIgnoreTap = EFalse;
+    
+    iCommandProcessing = EFalse;
+    TCallBack callback(CCalenNativeView::AsyncCopyToCalendarsL,this);
+    iAsyncCallback = new(ELeave) CAsyncCallBack(callback,CActive::EPriorityStandard);
+
+    TRACE_EXIT_POINT;
     }
 
 // ----------------------------------------------------------------------------
-// saveActivity saves the activity for current view
+// CCalenNativeView::CreateContainerL
+// A container control is created.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::CreateContainerL()
+    {
+    TRACE_ENTRY_POINT;
+
+    if (!iContainer)
+        {
+        CCalenContainer* container = CreateContainerImplL();
+        CleanupStack::PushL(container);
+        container->SetMopParent(this);
+        container->ConstructL();
+        CleanupStack::Pop(); // container
+
+        iContainer = container;
+        iContainer->SetRect( ClientRect() );
+        iContainer->ActivateL();
+        }
+    else
+        {
+        iContainer->MakeVisible(ETrue);
+        }
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::AbbreviatedDayArrayL
+// Returns an array of descriptors of abbreviated days (e.g. MO, TU). This
+// will only get called by the month and week views.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+const CDesCArrayFlat& CCalenNativeView::AbbreviatedDayArrayL()
+    {
+    TRACE_ENTRY_POINT;
+
+    if( !iAbbreviatedDayArray )
+        {
+        iAbbreviatedDayArray = new( ELeave )CDesCArrayFlat( 7 );
+        HBufC* dayAbb;
+
+        for ( TInt i(0); i<7; ++i )
+            {
+            dayAbb = StringLoader::LoadLC( KAbbreviatedWeekNames[i] );
+            iAbbreviatedDayArray->AppendL( *dayAbb );
+            CleanupStack::PopAndDestroy( dayAbb );
+            }
+        }
+
+    TRACE_EXIT_POINT;
+    return *iAbbreviatedDayArray;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::DoActivateL
+// View activation handler
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::DoActivateL( const TVwsViewId& aPrevViewId,
+                                    TUid aCustomMessageId,
+                                    const TDesC8& aCustomMessage)
+    {
+    TRACE_ENTRY_POINT;
+
+    iLocChangeReason = 0;
+
+    if( KCalenHideInBackGround.iUid == aCustomMessageId.iUid )
+	    {
+	    SetFasterAppActive(ETrue);
+	    DoDeactivate();	
+	    }
+
+     if( AknLayoutUtils::PenEnabled() )
+        {
+        MCalenToolbar* toolbarImpl = iServices.ToolbarOrNull();
+        if(toolbarImpl)
+            {
+            CAknToolbar& toolbar = toolbarImpl->Toolbar();
+            toolbar.SetToolbarVisibility(ETrue);
+            }
+        }
+
+    if ( Toolbar() )
+        {
+        ShowToolbarOnViewActivation( ETrue );
+        }
+
+    CreateContainerL();
+
+    DoActivateImplL( aPrevViewId, aCustomMessageId, aCustomMessage );
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::DoDeactivate
+// View deactivation handler
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::DoDeactivate()
+    {
+    TRACE_ENTRY_POINT;
+#ifdef RD_CALEN_EXTERNAL_CAL
+    //delete AIW iServiceHandler;
+    ReleaseServiceHandler();
+#endif //RD_CALEN_EXTERNAL_CAL
+
+    if (iContainer)
+        {
+        iContainer->RemoveFromStackAndMakeInvisible();
+        DoDeactivateImpl();
+        delete iContainer;
+        iContainer = NULL;
+        }
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::HandleDBChangeL
+// Called from CCalenGlobalData when the agenda database
+// is modified from an external session.
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::HandleDBChangeL()
+    {
+    TRACE_ENTRY_POINT;
+
+    // If iContainer is NULL then this is not the active view, so do nothing.
+    // The view will be refreshed when the container is constructed.
+    if ( iContainer )
+        {
+        if (IsForeground() && Container()->ComponentControl(0)->IsFocused())
+            {
+            // Application is in the foreground and the container is visible
+            // on screen.  We know that the editor is not open as the
+            // containers first component control currently has keyboard focus.
+            // The first component control will either be a listbox or grid
+            // depending on the viewtype.  Refresh the container.
+            BeginRepopulationL();
+            iNeedsRefresh = EFalse;
+            }
+        else
+            {
+            // This is the active view, but we are in one of two states:
+            // 1: The application is in the background
+            // 2: The editor is open and currently has keyboard focus.
+            // When we recieve a focus change notification we will need to
+            // refresh the view.  This happens in CCalenNativeView::NotifyFocusChanged
+            iNeedsRefresh = ETrue;
+            }
+        }
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::SetCbaL()
+// Set CBA and change button from Back to Exit if necessary
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::SetCbaL(TInt aCbaResourceId)
+    {
+	TRACE_ENTRY_POINT;
+
+    CEikButtonGroupContainer*  cba = Cba();
+    cba->SetCommandSetL(aCbaResourceId);
+    cba->DrawNow();
+
+    TRACE_EXIT_POINT;
+    }
+
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::CreateServiceHandlerL()
+// Create new AIW service handler and attach to menu services if needed
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::CreateServiceHandlerL(TBool aAttachMenu)
+    {
+    TRACE_ENTRY_POINT;
+
+
+    if ((iServiceHandler!=NULL) && (aAttachMenu==EFalse))
+        {
+        TRACE_EXIT_POINT;
+        return;
+        }
+
+        // Create service handler instance.
+    if (!iServiceHandler)
+        {
+        iServiceHandler = CAiwServiceHandler::NewL();
+        }
+    if (aAttachMenu)
+        {
+    // Attach menu service interest to AIW framework. We will add
+    // menus to all the views
+    PIM_TRAPD_HANDLE( iServiceHandler->AttachMenuL(R_CALENDAR_DAY_MENUPANE,
+        R_EXTERNAL_CALENDAR_AIW_INTEREST) );
+
+        PIM_TRAPD_HANDLE( iServiceHandler->AttachMenuL(R_CALENDAR_MONTH_MENUPANE,
+        R_EXTERNAL_CALENDAR_AIW_INTEREST) );
+
+
+        PIM_TRAPD_HANDLE( iServiceHandler->AttachMenuL(R_CALENDAR_WEEK_MENUPANE,
+        R_EXTERNAL_CALENDAR_AIW_INTEREST) );
+
+        PIM_TRAPD_HANDLE( iServiceHandler->AttachMenuL(R_TODO_LIST_MENUPANE,
+        R_EXTERNAL_CALENDAR_AIW_INTEREST) );
+        }
+
+
+    TRACE_EXIT_POINT;
+    }
+
+#endif //RD_CALEN_EXTERNAL_CAL
+
+
+
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+// ----------------------------------------------------------------------------
+// CCalenNativeView::ReleaseServiceHandler()
+// Release service handler and unload provider
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::ReleaseServiceHandler()
+    {
+    TRACE_ENTRY_POINT;
+    if (iServiceHandler)
+        {
+        iServiceHandler->Reset();
+        delete iServiceHandler;
+        iServiceHandler=NULL;
+        }
+    TRACE_EXIT_POINT;
+    }
+#endif //RD_CALEN_EXTERNAL_CAL
+
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+// ----------------------------------------------------------------------------
+// CCalenNativeView::ServiceHandler()
+// Return pointer to service handler
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+CAiwServiceHandler* CCalenNativeView::ServiceHandler()
+    {
+    TRACE_ENTRY_POINT;
+    return iServiceHandler;
+    TRACE_EXIT_POINT;
+    }
+#endif //RD_CALEN_EXTERNAL_CAL
+
+
+
+
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+
+// ----------------------------------------------------------------------------
+//* Handles notifications caused by an asynchronous Execute*CmdL call
+//* or an event.
+//*
+//* @param aCmdId The service command associated to the event.
+//* @param aEventId Occured event, see AiwCommon.hrh.
+//* @param aEventParamList Event parameters, if any, as defined per
+//*        each event.
+//* @param aInParamList Input parameters, if any, given in the
+//*        related HandleCommmandL.
+//* @return Error code for the callback.
+// ----------------------------------------------------------------------------
+//
+TInt CCalenNativeView::HandleNotifyL(TInt /*aCmdId*/,TInt /*aEventId*/,CAiwGenericParamList& aEventParamList,const CAiwGenericParamList& /*aInParamList*/)
+    {
+    TRACE_ENTRY_POINT;
+    TInt count=aEventParamList.Count();
+    TInt index=0;
+    TTime date(0);
+
+    // find first TTime parameter
+    const TAiwGenericParam* param = aEventParamList.FindFirst(index, EGenericParamDateTime);
+    if (index >= 0)
+        {
+        // get date value from it
+        const TAiwVariant& val = param->Value();
+        val.Get(date);
+        }
+    else
+        {
+        TRACE_EXIT_POINT;
+        return KErrNone;
+        }
+
+    // use date got from provider and set it to calendar
+    MCalenContext& context = iServices.Context();
+    TCalTime focusTime;
+    focusTime.SetTimeLocalL( date + TCalenContext::DefaultTimeForViews() );
+    context.SetFocusTime( focusTime , context.ViewId() );
+    iContainer->NotifyChangeDateL();
+    TRACE_EXIT_POINT;
+    return KErrNone;
+    }
+
+#endif //RD_CALEN_EXTERNAL_CAL
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::HandleNotification
+// From MCalenNotificationHandler
+// Handles a notification of a calendar event that this
+// MCalenNotificationHandler has registered for
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::HandleNotification(const TCalenNotification aNotification )
+    {
+    TRACE_ENTRY_POINT;
+
+    switch ( aNotification )
+        {
+        case ECalenNotifyContextChanged:
+            {
+            // If we're not on screen, clear VSD.
+            if ( !iContainer )
+                {
+                PIM_TRAPD_HANDLE( ClearViewSpecificDataL() );
+                }
+            }
+            break;
+        case ECalenNotifyMarkedEntryDeleted: // Todo view specific notification
+            {
+            PIM_TRAPD_HANDLE( NotifyMarkedEntryDeletedL() );
+            }
+            break; 
+        case ECalenNotifyMarkedEntryCompleted: // Todo view specific notification
+            {
+            PIM_TRAPD_HANDLE( NotifyMarkedEntryCompletedL() );
+            }
+            break;    
+        case ECalenNotifySystemTimeChanged:
+            {
+            PIM_TRAPD_HANDLE( OnLocaleChangedL( EChangesSystemTime ) );
+            }
+            break;
+        case ECalenNotifyEventViewLaunchedFromAlarm:
+            {
+            SetTapIgnore(ETrue);
+            }
+            break;
+        case ECalenNotifyEntryClosed:
+            {
+            // The editor/ viewer is changed
+            PIM_TRAPD_HANDLE( OnEditorClosedL() );
+            }
+            break;
+        case ECalenNotifyDialogClosed:
+        case ECalenNotifySettingsClosed:
+        case ECalenNotifySettingsChanged:
+        case ECalenNotifyEntrySent:    
+            {
+            iIsEditorActive = EFalse;
+            iCommandProcessing = EFalse;
+            }
+            break;
+        case ECalenNotifyEntrySaved:
+        case ECalenNotifyInstanceSaved:         
+            {
+            iIsEditorActive = EFalse;
+            if( Container() )
+	            {
+	            PIM_TRAPD_HANDLE(UpdateDateFromContextL());	
+	            }
+            }
+            break;        
+        case ECalenNotifySystemLocaleChanged:
+            {
+        	PIM_TRAPD_HANDLE( OnLocaleChangedL( EChangesLocale ) );
+            }
+        	break;
+        case ECalenNotifyAppForegrounded:
+            {
+            iIsBackgrounded = EFalse;
+            // Updates the previewpane/preview popup in month view/week view
+            if(iFasterAppActive)
+                {
+                iFasterAppActive = EFalse;
+                if(iIsEditorActive)
+                    {
+                    iIsEditorActive = EFalse;
+                    }
+                }
+            PIM_TRAPD_HANDLE(UpdatePreviewPaneL());
+            }
+            break;
+        case ECalenNotifyAppBackgrounded:
+            {
+            iIsBackgrounded = ETrue;
+            // Hides previewpane/preview popup in month view/week view when
+            // application goes to background or whenever fake exit is done
+            PIM_TRAPD_HANDLE(HidePreviewPane());
+            }
+            break;
+        case ECalenNotifyEntryDeleted:
+        case ECalenNotifyMultipleEntriesDeleted:
+        case ECalenNotifyInstanceDeleted:
+        case ECalenNotifyCancelDelete:
+		case ECalenNotifyDeleteInstanceView:
+            {
+			// Called when user does not delete an entry.
+            if( IsCommandHandlingInProgress() )
+                {
+                SetCommandHandlingInProgress( EFalse );
+                }
+				
+            if(iContainer)
+                {
+                iContainer->CleanupInstances();
+                }
+			}	
+            break;
+		case ECalenNotifyDeleteFailed:
+		    {
+		    // Called when user does not delete an entry.
+            if( IsCommandHandlingInProgress() )
+                {
+                SetCommandHandlingInProgress( EFalse );
+                }
+		    
+		    }
+		break;    
+		case ECalenNotifyStopAlarm:
+            {
+            if(iContainer)
+                {
+                PIM_TRAPD_HANDLE(iContainer->HandleStopCommandL());
+                }
+            }
+            break;
+		case ECalenNotifyResourceChanged:
+		    {
+		    if(iContainer )
+		        {
+                CAknAppUi* Appui = (CAknAppUi*)CEikonEnv::Static()->EikAppUi();
+                //handle this event when the app is in background
+                if(!Appui->IsForeground())
+                    {
+                    iContainer->HandleResourceChange(KEikDynamicLayoutVariantSwitch);
+                    }
+		        }
+		    }
+		    break;
+        default:
+            ASSERT( 0 ); // should never get here
+            break;
+        }
+
+    TRACE_EXIT_POINT;
+    }
+
+#ifdef RD_CALEN_EXTERNAL_CAL
+// ----------------------------------------------------------------------------
+// ?classname::?member_function
+// ?implementation_description
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TBool CCalenNativeView::ExtCalendarAvailableL()
+    {
+    TRACE_ENTRY_POINT;
+
+
+    TBool res=EFalse;
+
+
+    TInt enabled( 0 );
+    CRepository* repository = NULL;
+
+    // first we check central repository if it has our external calendar enabled.
+    PIM_TRAPD_HANDLE( (repository = CRepository::NewL( KCRUidCalenUIExtensions )) );
+    if( repository )
+        {
+        TInt err = repository->Get( KCalenExternalCalendarEnabled, enabled );
+        delete repository;
+        }
+    // if setting says it is not enabled there is no point of loading provider at all, improves performance.
+    if (!enabled)
+        {
+        TRACE_EXIT_POINT;
+        return EFalse;
+        }
+
+    // if setting was enabled we should also find out if there is a service provider.
+    CreateServiceHandlerL(EFalse);
+    CAiwCriteriaItem* crit = CAiwCriteriaItem::NewLC(ECalenExtAiwCommandId, KAiwCmdView, KContentTypeCalendar);
+    // we will connect to base service which is currently just empty. This is needed just for finding out if
+    // there are any providers available. This will change in the future in AIW framework as it is a bug.
+    crit->SetServiceClass(TUid::Uid(KAiwClassBase));
+    crit->SetMaxProviders(1);
+    RCriteriaArray array;
+    array.Append(crit);
+
+    // attach to base service.
+    // ownership of array is not transferred.
+    iServiceHandler->AttachL(array);
+
+    // get number of matching providers.
+    TInt num=iServiceHandler->NbrOfProviders(crit);
+
+
+    array.ResetAndDestroy();
+    CleanupStack::Pop(crit);
+
+    // ok if we have provider and setting was also enabled then we should show menu items.
+    if ((num>0)&&(enabled))
+        {
+        res=ETrue;
+        }
+    TRACE_EXIT_POINT;
+    return res;
+    }
+#endif //RD_CALEN_EXTERNAL_CAL
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::BeginRepopulationL
+// Starts population again.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::BeginRepopulationL()
+    {
+    TRACE_ENTRY_POINT;
+
+    CancelPopulation();
+    iServices.IssueCommandL( ECalenStartActiveStep );
+
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::RemoveViewsFromCycle
+// From CCalenView. Does nothing.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::RemoveViewsFromCycle( RArray<TInt>& /*aViews*/ )
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::GetHelpContext
+// From CCalenView. Does nothing.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::GetHelpContext( TCoeHelpContext& /*aHelpContext*/ )
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::CalenViewExtensionL
+// From CCalenView. Does nothing.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TAny* CCalenNativeView::CalenViewExtensionL( TUid /*aExtensionId*/ )
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    return NULL;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::OnEditorClosedL
+// Called when editor/viewer is closed
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::OnEditorClosedL()
+    {
+    TRACE_ENTRY_POINT;
+    
+    SetTapIgnore(EFalse);
+    // If the view is active, then update status pane
+    if( Container() )
+        {
+        RedrawStatusPaneL();
+        iIsEditorActive = EFalse;
+        }
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::SetEditorActive
+// Set the flag iIsEditorActive whenever new event editor is launched from any
+// native view.This is to prevent the preview popup display
+// (other items were commented in a header).
 // ----------------------------------------------------------------------------
 // 
-void CalenNativeView::saveActivity()
- {
-   OstTraceFunctionEntry0( CALENNATIVEVIEW_SAVEACTIVITY_ENTRY );
+void CCalenNativeView::SetEditorActive(TBool aEditorActive)
+    {
+    TRACE_ENTRY_POINT;
+    
+    iIsEditorActive = aEditorActive;
+    
+    TRACE_EXIT_POINT;
+    }
+	
+// ----------------------------------------------------------------------------
+// CCalenNativeView::IsCommandHandlingInProgress
+// other details are commented in the header
+// ----------------------------------------------------------------------------
+// 
+TBool CCalenNativeView::IsCommandHandlingInProgress()
+    {
+    TRACE_ENTRY_POINT;
+    
+    return iCommandProcessing;
+    
+    TRACE_EXIT_POINT;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::IsEventViewLaunchedFromAlarm
+// other details are commented in the header
+// ----------------------------------------------------------------------------
+// 
+TBool CCalenNativeView::IsEventViewLaunchedFromAlarm()
+    {
+    TRACE_ENTRY_POINT;
+    return iIgnoreTap;
+    TRACE_EXIT_POINT;
+    }
+// ----------------------------------------------------------------------------
+// CCalenNativeView::SetCommandHandlingProgress
+// other details are commented in the header
+// ----------------------------------------------------------------------------
+// 
+void CCalenNativeView::SetCommandHandlingInProgress( TBool aInProgress )
+    {
+    TRACE_ENTRY_POINT;
+    
+    iCommandProcessing = aInProgress;
     
-   // Get a pointer to activity manager 
-   HbActivityManager* activityManager = qobject_cast<HbApplication*>(qApp)->activityManager();
- 
-   // check if alerady a valid screen shot is captured
-   if (!mIsCapturedScreenShotValid) {
-       mScreenShotMetadata.clear(); // remove any screenshot captured earlier
-       mScreenShotMetadata.insert("screenshot", QPixmap::grabWidget(mainWindow(), mainWindow()->rect()));
-       }
-   
-   // Save any data necessary to save the state
-   QByteArray serializedActivity;
-   QDataStream stream(&serializedActivity, QIODevice::WriteOnly | QIODevice::Append);
-   stream << mActivityId;
- 
-   bool ok(false);
-   // Save activity
-   ok = activityManager->addActivity(activityName, serializedActivity, mScreenShotMetadata);
+    TRACE_EXIT_POINT;
+    }
+	
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::SetEditorActive
+// Returns an array of active collection ids.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+// 
+void CCalenNativeView::GetActiveCollectionidsL( 
+        MCalenServices& aServices, 
+        RArray< TInt >& aCollectionIds )
+    {
+    TRACE_ENTRY_POINT;
+    RPointerArray<CCalCalendarInfo> calendarInfoList;
+    CleanupClosePushL(calendarInfoList);
+    aServices.GetAllCalendarInfoL(calendarInfoList);
+    
+    for(TInt index=0;index<calendarInfoList.Count();index++)
+        {
+        if(calendarInfoList[index]->Enabled())
+            {
+            aCollectionIds.Append( aServices.SessionL( 
+                        calendarInfoList[index]->FileNameL() ).CollectionIdL() );
+            }
+        }
+    
+    CleanupStack::PopAndDestroy(&calendarInfoList);
+    TRACE_EXIT_POINT;
+    }
 
-   // Check is activity saved sucessfully
-   if ( !ok )  {
-       qFatal("Add failed" ); // Panic is activity is not saved successfully
-       }
-   OstTraceFunctionExit0( CALENNATIVEVIEW_SAVEACTIVITY_EXIT );
- }
-//End Of File
+// ----------------------------------------------------------------------------
+// CCalenNativeView::SetFasterAppActive
+// Set the flag 'iFasterApp' to ETrue if application is fake exited
+// and to EFalse once the application comes to foreground.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+void CCalenNativeView::SetFasterAppActive( TBool aFlag )
+    {
+    TRACE_ENTRY_POINT;
+    TRACE_EXIT_POINT;
+    iFasterAppActive = aFlag;
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::IsEditorActiveOrFasterAppExit
+// Returns ETrue whenever editor is active or whenever fake exit is active
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TBool CCalenNativeView::IsEditorActiveOrFasterAppExit()
+    {
+    TRACE_ENTRY_POINT;
+    
+    if( iIsEditorActive || iFasterAppActive || iIsBackgrounded )
+        {
+        TRACE_EXIT_POINT;
+        return ETrue;
+        }
+    else
+        {
+        TRACE_EXIT_POINT;
+        return EFalse;
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CCalenNativeView::SetTapIgnore
+// Sets flag to ignore tap on any of the views 
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+void CCalenNativeView::SetTapIgnore(TBool aIgnore)
+    {
+    iIgnoreTap = aIgnore;
+    }
+
+// End of File