19 

    39 #include <cmrmailboxutils.h>        // CMRMailboxUtils

    40 #include <calencommands.hrh>            // Calendar commands

    41 #include <aknlists.h>

    42 #include <aknPopup.h>

    43 #include <AknUtils.h>

    44 #include <AknQueryDialog.h>

    45 #include <calencontext.h>

    46 #include <calcalendarinfo.h>

    47 #include <calcalendariterator.h>

    48 #include <CalendarInternalCRKeys.h>

    49 #include <calenmulticalutil.h>

    91 

   189 

   419     }

   420 

   421 // -----------------------------------------------------------------------------

   422 // CCalenGlobalData::CalSessionL

   423 // Based on the calendar name return already cached session from iFileMappingArray

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

   425 // -----------------------------------------------------------------------------

   426 EXPORT_C CCalSession& CCalenGlobalData::CalSessionL(const TDesC& aCalendar)

   427     {

   428     TRACE_ENTRY_POINT;

   429     CCalSession* session = NULL;

   430     HBufC* calendarFileName = aCalendar.AllocLC();

   431     TInt index = iFileMappingArray.Find(

   432             *calendarFileName,CCalenGlobalData::CalenInfoIdentifierL);

   433     CleanupStack::PopAndDestroy(calendarFileName);

   434     if(KErrNotFound != index)

   435         {

   436         session = iFileMappingArray[index]->GetSessionPtr();

   437         }

   438     else

   439         {

   440         User::LeaveIfError(KErrNotFound);

   441         }

   442     

   443     TRACE_EXIT_POINT;

   444     return *session;

   475     }

   476 

   477 // -----------------------------------------------------------------------------

   478 // CCalenGlobalData::InstanceViewL

   479 // Based on collection id array Create an instance view if necessary and returns a reference.

   480 // Creating an instance view is an asynchronous operation, but this call returns

   481 // synchronously.  When the view is created, Completed() is called, which stops

   482 // iAs allowing this function to complete.

   483 // Leaves with KErrInUse if this class is in the process of creating the

   484 // instance view

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

   486 // -----------------------------------------------------------------------------

   487 EXPORT_C CCalInstanceView* CCalenGlobalData::InstanceViewL(

   488                                         const RArray<TInt>& aCollectionIds)

   489     {

   490     TRACE_ENTRY_POINT;

   491     

   492     if(!iNewInstanceView && !iNewInstanceViewCreation)

   493         {

   494         CreateInstanceViewL(aCollectionIds);

   495         }

   496     

   497     TRACE_EXIT_POINT;

   498     return iNewInstanceView;

   531 

   532 // -----------------------------------------------------------------------------

   533 // CCalenGlobalData::EntryViewL

   534 // Based on collection id array Create an entry view if necessary and returns a reference.  

   535 // Creating an entry view is an asynchronous operation, but this call returns

   536 // synchronously.  When the view is created, Completed() is called, which stops

   537 // iAs allowing this function to complete.

   538 // Leaves with KErrInUse if this class is in the process of creating the

   539 // entry view

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

   541 // -----------------------------------------------------------------------------

   542 EXPORT_C CCalEntryView* CCalenGlobalData::EntryViewL(

   543                                                 const TCalCollectionId aCollectionId)

   544     {

   545     TRACE_ENTRY_POINT;

   546     __ASSERT_ALWAYS(aCollectionId > 0 ,User::Panic(_L("CCalenGlobalData"),-1));

   547     

   548     CCalEntryView* entryView = NULL;

   549     

   550     TInt index = iHashDbidIndexMap.FindL(aCollectionId);

   551     if(index != KErrNotFound)

   552         {

   553         entryView = iFileMappingArray[index]->GetEntryView();

   554         }    

   555     

   556     if(!entryView)

   557         {

   558         User::LeaveIfNull(entryView);

   559         }

   560     

   561     TRACE_EXIT_POINT;

   562     return entryView;

   563     }

   564 

   565 // -----------------------------------------------------------------------------

   566 // CCalenGlobalData::RegisterEntryViewObserver

   567 // Add observer into view observers entry observer list.

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

   569 // -----------------------------------------------------------------------------

   570 EXPORT_C TBool CCalenGlobalData::EntryViewExists()

   571     {

   572     TRACE_ENTRY_POINT;

   573     TRACE_EXIT_POINT;

   574     return ( iEntryView != NULL );

   575     }

   576 

   577 // -----------------------------------------------------------------------------

   578 // CCalenGlobalData::MeetingRequestUtilsL

   579 // Create MR Utils if necessary and returns a reference

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

   581 // -----------------------------------------------------------------------------

   582 EXPORT_C CMRUtils& CCalenGlobalData::MeetingRequestUtilsL()

   583     {

   584     TRACE_ENTRY_POINT;

   585 

   586     iCreateError = KErrNone;

   587     if (!iUtilsAs)

   588         {

   589         iUtilsAs = new (ELeave) CActiveSchedulerWait;

   590         }

   591     if (!iMRUtils)

   592         {

   593         if (InterimUtilsL().MRViewersEnabledL())

   594             {

   595             if (iUtilsAs->IsStarted())

   596                 {

   597                 User::Leave(KErrInUse);

   598                 }

   599             else

   600                 {

   601                 //Get the currently selected mailbox

   602                 CMRMailboxUtils::TMailboxInfo defaultMailbox;

   603                 MRMailboxUtilsL().GetDefaultMRMailBoxL(defaultMailbox);

   604                 //CMRUtils resolves meeting request utilities based on mtm uid

   605                 TBuf8<KMaxUidName> mrMtm;

   606                 CnvUtfConverter::ConvertFromUnicodeToUtf8(mrMtm, defaultMailbox.iMtmUid.Name());

   607                 iMRUtils = CMRUtils::NewL(mrMtm, *this, CalSessionL(), NULL);

   608                 iUtilsAs->Start();

   609                 User::LeaveIfError(iCreateError);

   610                 }

   611             }

   612         else

   613             {

   614             User::Leave(KErrNotSupported);

   615             }

   616         }

   617 

   618     TRACE_EXIT_POINT;

   619     return *iMRUtils;

   620     }

   621 

   622 // -----------------------------------------------------------------------------

   623 // CCalenGlobalData::InterimUtilsL

   624 // Create a CCalenInterimUtils object if neccessary and return a reference

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

   626 // -----------------------------------------------------------------------------

   627 EXPORT_C CCalenInterimUtils2& CCalenGlobalData::InterimUtilsL()

   628     {

   629     TRACE_ENTRY_POINT;

   630 

   631     if(!iInterimUtils)

   632         {

   633         iInterimUtils = CCalenInterimUtils2::NewL();

   634         }

   635 

   636     TRACE_EXIT_POINT;

   637     return *iInterimUtils;

   638     }

   639 

   640 // -----------------------------------------------------------------------------

   641 // CCalenGlobalData::CalenSendL

   642 // Create a CCalenSend object if neccessary and return a reference

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

   644 // -----------------------------------------------------------------------------

   645 EXPORT_C CCalenSend& CCalenGlobalData::CalenSendL()

   646     {

   647     TRACE_ENTRY_POINT;

   648 

   649     if( !iSend )

   650         {

   651         iSend = CCalenSend::NewL( ECalenSend, CalSessionL() );

   652         }

   653 

   654     TRACE_EXIT_POINT;

   655     return *iSend;

   656     }

   657 

   658 // -----------------------------------------------------------------------------

   659 // CCalenGlobalData::Context

   660 // Return a reference to the CCalenContext object

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

   662 // -----------------------------------------------------------------------------

   663 EXPORT_C MCalenContext& CCalenGlobalData::Context()

   664     {

   665     TRACE_ENTRY_POINT;

   666     TRACE_EXIT_POINT;

   667     return *iContext;

   668     }

   669 

   670 // -----------------------------------------------------------------------------

   671 // CCalenEditUi::AttemptToRetrieveDefaultMailboxL

   672 // Check to see if we have any mailboxes defined, and if we have a default

   673 // mailbox. If we don't, inform the user and return EFalse. This function

   674 // returns ETrue if aDefaultMailbox was initialised, and it is OK to create

   675 // a new MR.

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

   677 // -----------------------------------------------------------------------------

   678 EXPORT_C TBool CCalenGlobalData::AttemptToRetrieveDefaultMailboxL( CMRMailboxUtils::TMailboxInfo& aDefaultMailbox)

   679     {

   680     TRACE_ENTRY_POINT;

   681 

   682     CMRMailboxUtils& mbUtils = MRMailboxUtilsL();

   683     // Get the currently defined mailboxes.

   684     RArray<CMRMailboxUtils::TMailboxInfo> mailboxes;

   685     CleanupClosePushL(mailboxes);

   686     mbUtils.ListMailBoxesL(mailboxes);

   687 

   688     TBool canCreateMeetingRequest=EFalse;

   689     TInt mbCount = mailboxes.Count();

   690 

   691     // The following 'if-else' block should always initialise

   692     // defaultMailBox if canCreateMeetingRequest comes out as ETrue.

   693     if(mbCount > 0)

   694         {

   695         TInt res = KErrNone;

   696         TRAPD(err, res = mbUtils.GetDefaultMRMailBoxL(aDefaultMailbox));

   697         if( res == KErrNone && err == KErrNone)

   698             {

   699             canCreateMeetingRequest = ETrue;

   700             }

   701         else

   702             {

   703             // We have one or more mailboxes defined, but failed to get a default.

   704             // Ask user to answer "Select default mailbox" query.  The available mailboxes must

   705             // first be reduced to only show mailboxes with an associated meetnig request solution

   706             RImplInfoPtrArrayOwn implArray;

   707              CleanupClosePushL( implArray );

   708             //Get all MRViewers Implementation

   709              const TUid mrViewersIface = {KMRViewersInterfaceUID};

   710              REComSession::ListImplementationsL(mrViewersIface, implArray );

   711 

   712             for (TInt i = mailboxes.Count() - 1; i >= 0; --i)

   713                 {

   714                 //See if any meeting request implementation matches this mailbox

   715                 for (TInt j=0; j<implArray.Count(); ++j)

   716                      {

   717                      TBuf16<KMaxUidName> mbName;

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

   719                      if(mailboxes[i].iMtmUid.Name().CompareF(mbName) == 0)

   720                          {

   721                          //Found a match

   722                         break;

   723                         }

   724                     //Mailbox has no matching meeting request solution

   725                     //remove from list

   726                     mailboxes.Remove(i);

   727                     }

   728                 }

   729             CleanupStack::PopAndDestroy();    //implArray

   730             

   731             TInt selected = PromptToSelectDefaultMailboxL(mailboxes);

   732 

   733             if(selected >= KErrNone)

   734                 {

   735                 mbUtils.SetDefaultMRMailBoxL( mailboxes[selected].iEntryId );

   736                 canCreateMeetingRequest = ETrue;

   737                 __ASSERT_ALWAYS((mbUtils.GetDefaultMRMailBoxL( aDefaultMailbox ) == KErrNone), User::Invariant()); // so we don't return ref to local variable.

   738                 }

   739             }

   740         }

   741     else

   742         {

   743         // Force the check of MR Impl existing

   744         InterimUtilsL().MRViewersEnabledL(ETrue); //ignore result

   745         }

   746    

   747     CleanupStack::PopAndDestroy(); // mailboxes

   748 

   749     TRACE_EXIT_POINT;

   750     return canCreateMeetingRequest;

   751     }

   752 

   753 // -----------------------------------------------------------------------------

   754 // CCalenGlobalData::ResetKeyEventQueue

   755 // Reset Keyevents queue

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

   757 // -----------------------------------------------------------------------------

   758 EXPORT_C void CCalenGlobalData::ResetKeyEventQueue()

   759     {

   760     TRACE_ENTRY_POINT;

   761     iKeyQueue.Reset();

   762     TRACE_EXIT_POINT;

   763     }

   764 

   765 // -----------------------------------------------------------------------------

   766 // CCalenGlobalData::QueueKeyEvent

   767 // Queue key press event in a queue

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

   769 // -----------------------------------------------------------------------------

   770 EXPORT_C TBool CCalenGlobalData::QueueKeyEvent(const TKeyEvent& aEvent,

   771                                                TEventCode aType)

   772     {

   773     TRACE_ENTRY_POINT;

   774     TBool result(EFalse);

   775     TQueuedKeyEvent item;

   776     item.iType = aType;

   777     item.iEvent = aEvent;

   778     if( iKeyQueue.Insert(item, iKeyQueue.Count()) == KErrNone) // add to last

   779         {

   780         result = ETrue;

   781         }

   782     TRACE_EXIT_POINT;

   783     return result;

   784     }

   785 

   786 // -----------------------------------------------------------------------------

   787 // CCalenGlobalData::GetQueueKeyEvent

   788 // Get 1 queued event from the queue

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

   790 // -----------------------------------------------------------------------------

   791 EXPORT_C TBool CCalenGlobalData::GetQueuedKeyEvent(TKeyEvent& aEvent, TEventCode& aType)

   792     {

   793     TRACE_ENTRY_POINT;

   794     TBool result(EFalse);

   795     if(iKeyQueue.Count() > 0)

   796         {

   797         TQueuedKeyEvent item;

   798         item = iKeyQueue[0];// get first

   799         aEvent = item.iEvent;

   800         aType = item.iType;

   801         iKeyQueue.Remove(0); // remove first

   802         result = ETrue;

   803         iKeyQueue.Compress();

   804         }

   805     TRACE_EXIT_POINT;

   806     return result;

   807     }

   808 

   809 // -----------------------------------------------------------------------------

   810 // CCalenGlobalData::ConstructFileMappingL

   811 // Constructs mapping between symbian calendar file and metabd info

   812 // -----------------------------------------------------------------------------

   813 EXPORT_C TBool CCalenGlobalData::ConstructFileMappingL()

   814     {

   815     TRACE_ENTRY_POINT;

   816     iCalendarsSession = CCalSession::NewL();

   817     

   818     ConstructCalendarsListL();

   819     

   820     iFileMappingArray.Reset();

   821         

   822     for(TInt index = 0; index < iCalendarInfoList.Count(); index++)

   823         {

   824         TPtrC calendarFileName = iCalendarInfoList[index]->FileNameL();

   825         CCalenFileMapping* filemap = CCalenFileMapping::NewL(); 

   826         CleanupStack::PushL(filemap);

   827         filemap->SetCalendarFileNameL(calendarFileName);

   828         

   829         iNewEntryView  = NULL;

   830         iNewEntryViewCreation  = NULL;  

   831         if(iCalSession)

   832             {

   833             iNewCalSession = NULL;

   834             CCalCalendarInfo* calendarInfo = iCalendarInfoList[index];

   835             

   836             CCalSession& tempSession = CreateNewSessionL( calendarFileName,

   837                                     *calendarInfo );

   838             filemap->SetSessionPtr(&tempSession);

   839             filemap->SetCollectionId(tempSession.CollectionIdL());

   840             CreateEntryViewL(tempSession);

   841             filemap->SetEntryView( iNewEntryView );

   842             }            

   843          else

   844             {

   845             CCalSession& tempSession = CalSessionL();

   846             filemap->SetSessionPtr(&tempSession);

   847             filemap->SetCollectionId(tempSession.CollectionIdL());

   848             CreateEntryViewL(tempSession);

   849             filemap->SetEntryView( iNewEntryView );

   850             iGlobalDataOwnsEntryView = EFalse;

   851             iGlobalDataOwnsCalSession = EFalse;

   852             }

   853         iFileMappingArray.Append(filemap);        

   854         CleanupStack::Pop(filemap);

   855         }   

   856     

   857     for(TInt index = 0; index < iFileMappingArray.Count(); index++)

   858         {

   859         iHashDbidIndexMap.InsertL( iFileMappingArray[index]->GetCollectionId(),

   860                                     index);

   861         }

   862     

   863     TRACE_EXIT_POINT

   864     return ETrue;

   865     }

   866 

   867 // -----------------------------------------------------------------------------

   868 // CCalenGlobalData::InitializeGlobalDataL

   869 // Initializes multiple db related objects

   870 // -----------------------------------------------------------------------------

   871 EXPORT_C void CCalenGlobalData::InitializeGlobalDataL()

   872     {

   873     TRACE_ENTRY_POINT

   874     

   875     ConstructFileMappingL();

   876     

   877     TRACE_EXIT_POINT

   878     }

   879 

   880 // -----------------------------------------------------------------------------

   881 // CCalenGlobalData::PromptToSelectDefaultMailboxL

   882 // Prompts the user to select the default mailbox. If the user cancels, the

   883 // function returns KErrCancel, otherwise it returns the index of the selected

   884 // mailbox. This function does not set the default mailbox, but rather returns

   885 // the index of the given array to which the default should be set.

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

   887 // -----------------------------------------------------------------------------

   888 TInt CCalenGlobalData::PromptToSelectDefaultMailboxL( RArray<CMRMailboxUtils::TMailboxInfo>& aMailboxes )

   889     {

   890     TRACE_ENTRY_POINT;

   891 

   892     TInt mbCount = aMailboxes.Count();

   893 

   894     TInt selected;

   895     if (mbCount > 0)

   896         {

   897         CAknSinglePopupMenuStyleListBox* list =

   898             new (ELeave) CAknSinglePopupMenuStyleListBox;

   899         CleanupStack::PushL(list);

   900 

   901         CAknPopupList* popupList = CAknPopupList::NewL(list, R_AVKON_SOFTKEYS_OK_CANCEL);

   902         CleanupStack::PushL(popupList);

   903 

   904         list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);

   905         list->CreateScrollBarFrameL(ETrue);

   906         list->ScrollBarFrame()->SetScrollBarVisibilityL(

   907             CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

   908 

   909         CEikonEnv* eikEnv = CEikonEnv::Static();

   910 

   911         CDesCArrayFlat* items = new (ELeave)CDesCArrayFlat(mbCount);

   912         CleanupStack::PushL(items);

   913         for(TInt i=0; i<mbCount; ++i)

   914             {

   915             items->AppendL( aMailboxes[i].iName );

   916             }

   917         CleanupStack::Pop(items);

   918         CTextListBoxModel* model = list->Model();

   919 

   920         //Pass ownersip of items to model

   921         model->SetItemTextArray(items);

   922 

   923         HBufC* title = StringLoader::LoadLC(R_CALEN_SELECT_MAILBOX, eikEnv);

   924         popupList->SetTitleL(*title);

   925         CleanupStack::PopAndDestroy(title);

   926 

   927         TBool accepted = popupList->ExecuteLD();

   928         CleanupStack::Pop(); // popupList

   929 

   930         if(accepted)

   931             {

   932             selected = list->CurrentItemIndex();

   933             }

   934         else

   935             {

   936             selected = KErrCancel;

   937             }

   938 

   939         CleanupStack::PopAndDestroy();  // list

   940         }

   941     else

   942         {

   943         //No mailboxes defined.  Could prompt user to define one here?

   944         selected = KErrCancel;

   945         }

   946 

   947     TRACE_EXIT_POINT;

   948     return selected;

   949     }

   950 

   951 // -----------------------------------------------------------------------------

   952 // CCalenGlobalData::HandleCalEngStatus

   953 // Called when Meeting Request utils are creation is complete.

   954 // Stops the CActiveSchedulerWait, allowing MeetingRequestUtilsL() to complete

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

   956 // -----------------------------------------------------------------------------

   957 void CCalenGlobalData::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )

   958     {

   959     TRACE_ENTRY_POINT;

   960 

   961     ASSERT(iUtilsAs);

   962 

   963     switch (aStatus)

   964         {

   965         case ENotReady:

   966             {

   967             //Keep waiting

   968             }

   969         break;

   970         case EAvailableWithoutTombs:

   971         case EAvailable:

   972             {

   973             //Ready for use.  Stop the CActiveSchedulerWait and return

   974             iUtilsAs->AsyncStop();

   975             iCreateError = KErrNone;

   976             }

   977         break;

   978         case ENotAvailable:

   979             {

   980             //Somethings gone wrong.  Stop the CActiveSchedulerWait but force

   981             //MeetingRequestUtilsL to leave.

   982             //We'll use KErrNotFound for now but we don't know what the problem is.

   983             iUtilsAs->AsyncStop();

   984             iCreateError = KErrNotFound;

   985             }

   986         break;

   987         default:

   988             {

   989             //Shouldn't ever get called.

   990             iUtilsAs->AsyncStop();

   991             iCreateError = KErrArgument;

   992             }

   993         break;

   994         }

   995 

   996     TRACE_EXIT_POINT;

   997     }

   998 

   999 // -----------------------------------------------------------------------------

  1000 // CCalenGlobalData::HandleNotification

  1001 // Handle any notification if registered for

  1002 // -----------------------------------------------------------------------------

  1003 void CCalenGlobalData::HandleNotification(const TCalenNotification aNotification )

  1004 	{

  1005 	TRACE_ENTRY_POINT;

  1006 

  1007 	switch(aNotification)

  1008 		{

  1009 		case ECalenNotifyEntryInstanceViewCreated:

  1010 			{

  1011 			ViewCreationCompleted( ETrue );

  1012 			}

  1013 			break;

  1014 		case ECalenNotifyEntryInstanceViewCreationFailed:

  1015 			{

  1016 			ViewCreationCompleted( EFalse );

  1017 			}

  1018 			break;

  1019 		case ECalenNotifyDeleteInstanceView:

  1020 			{

  1021 			//InstanceView has to be deleted since deleting any session(Calendar) 

  1022 			//entryView and instanceView has to be deleted before deleting session.

  1023 			if(iNewInstanceView)

  1024 				{

  1025 				delete iNewInstanceView;

  1026 				iNewInstanceViewCreation = iNewInstanceView =  NULL;

  1027 				}

  1028 			

  1029 			//If InstanceView is called by any component single instanceView 

  1030 			// without the knowledge of multi session (calendar).

  1031 			//This instance also should be deleted for deleting the session.  

  1032 			if(iInstanceView)

  1033 				{

  1034 				delete iInstanceView;

  1035 				iInstanceView = iInstanceViewCreation = NULL;

  1036 				}

  1037 			}

  1038 			break;

  1039 		case ECalenNotifyRealExit:

  1040 			{

  1041 			iCalendarForcedExit = ETrue;

  1042 			}

  1043 			break;

  1044 		case ECalenNotifyCalendarInfoCreated:

  1045 			{

  1046 			HandleCalendarInfoCreatedL();

  1047 			}

  1048 			break;

  1049 		case ECalenNotifyCalendarInfoUpdated:

  1050 			{

  1051 			HandleCalendarInfoUpdatedL();

  1052 			}

  1053 			break;

  1054 		case ECalenNotifyCalendarFileDeleted:

  1055 			{

  1056 			HandleCalendarFileDeletedL();

  1057 			}

  1058 			break;

  1059 		default:

  1060 			break;

  1061 		}

  1062 

  1063     TRACE_EXIT_POINT;

  1064     }

  1065 

  1066 // -----------------------------------------------------------------------------

  1067 // CCalenGlobalData::CreateEntryViewL

  1068 // -----------------------------------------------------------------------------

  1113      if(iInstanceViewCreation)

  1114         {

  1115         iInstanceView = iInstanceViewCreation;

  1116         }

  1117     TRACE_EXIT_POINT;

  1118     }

  1119 

  1120 // -----------------------------------------------------------------------------

  1121 // CCalenGlobalData::CreateEntryViewL

  1122 // -----------------------------------------------------------------------------

  1123 void CCalenGlobalData::CreateInstanceViewL(const RArray<TInt>& aCollectionIds)

  1124     {

  1125     TRACE_ENTRY_POINT;

  1126     

  1127     RPointerArray<CCalSession> sessionArray;

  1128     

  1129     for(TInt i = 0; i < aCollectionIds.Count() ; i++)

  1130         {

  1131         TInt index = iHashDbidIndexMap.FindL(aCollectionIds[i]);

  1132         if(index != KErrNotFound)

  1133            {

  1134            CCalSession* sessionPtr = iFileMappingArray[index]->GetSessionPtr();

  1135            sessionArray.AppendL(sessionPtr);

  1136            }

  1137         }

  1138     

  1139     if(sessionArray.Count())

  1140         {

  1141         iNewInstanceViewCreation = CCalInstanceView::NewL( sessionArray, iCalCallBack );

  1142         if(iNewInstanceViewCreation)

  1143            {

  1144            iNewInstanceView = iNewInstanceViewCreation;        

  1145            }

  1146         }

  1147     

  1148     sessionArray.Reset();

  1167         delete iNewEntryViewCreation;

  1168         delete iNewInstanceViewCreation;

  1179             }

  1180         

  1181         if ( iNewEntryViewCreation )

  1182             {

  1183             iNewEntryView = iEntryViewCreation;

  1184             }

  1185         else if ( iNewInstanceViewCreation )

  1186             {

  1187             iNewInstanceView = iNewInstanceViewCreation;