19 

   200 

   283 

   284     delete iSend;

   285     delete iInterimUtils;

   286     delete iUtilsAs;

   287     delete iMailboxUtils;

   288     delete iMRUtils;

   289 

   290     if (iInstanceView)

   291         {

   292         delete iInstanceView;

   293         iInstanceView = NULL;

   294         }

   295 

   296     if (iInstanceViewCreation)

   297         {

   298         delete iInstanceViewCreation;

   299         iInstanceViewCreation = NULL;

   300         }

   301 

   302     if (iEntryViewCreation)

   303         {

   304         delete iEntryViewCreation;

   305         iEntryViewCreation = NULL;

   306         }

   434     }

   435 

   436 // -----------------------------------------------------------------------------

   437 // CCalenGlobalData::CalSessionL

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

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

   440 // -----------------------------------------------------------------------------

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

   442     {

   443     TRACE_ENTRY_POINT;

   444     CCalSession* session = NULL;

   445     HBufC* calendarFileName = aCalendar.AllocLC();

   446     TInt index = iFileMappingArray.Find(

   447             *calendarFileName,CCalenGlobalData::CalenInfoIdentifierL);

   448     CleanupStack::PopAndDestroy(calendarFileName);

   449     if(KErrNotFound != index)

   450         {

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

   452         }

   453     else

   454         {

   455         User::LeaveIfError(KErrNotFound);

   456         }

   457     

   458     TRACE_EXIT_POINT;

   459     return *session;

   490     }

   491 

   492 // -----------------------------------------------------------------------------

   493 // CCalenGlobalData::InstanceViewL

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

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

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

   497 // iAs allowing this function to complete.

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

   499 // instance view

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

   501 // -----------------------------------------------------------------------------

   502 EXPORT_C CCalInstanceView* CCalenGlobalData::InstanceViewL(

   503                                         const RArray<TInt>& aCollectionIds)

   504     {

   505     TRACE_ENTRY_POINT;

   506     

   507     if(!iNewInstanceView && !iNewInstanceViewCreation)

   508         {

   509         CreateInstanceViewL(aCollectionIds);

   510         }

   511     

   512     TRACE_EXIT_POINT;

   513     return iNewInstanceView;

   546 

   547 // -----------------------------------------------------------------------------

   548 // CCalenGlobalData::EntryViewL

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

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

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

   552 // iAs allowing this function to complete.

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

   554 // entry view

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

   556 // -----------------------------------------------------------------------------

   557 EXPORT_C CCalEntryView* CCalenGlobalData::EntryViewL(

   558                                                 const TCalCollectionId aCollectionId)

   559     {

   560     TRACE_ENTRY_POINT;

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

   562     

   563     CCalEntryView* entryView = NULL;

   564     

   565     TInt index = iHashDbidIndexMap.FindL(aCollectionId);

   566     if(index != KErrNotFound)

   567         {

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

   569         }    

   570     

   571     if(!entryView)

   572         {

   573         User::LeaveIfNull(entryView);

   574         }

   575     

   576     TRACE_EXIT_POINT;

   577     return entryView;

   578     }

   579 

   580 // -----------------------------------------------------------------------------

   581 // CCalenGlobalData::RegisterEntryViewObserver

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

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

   584 // -----------------------------------------------------------------------------

   585 EXPORT_C TBool CCalenGlobalData::EntryViewExists()

   586     {

   587     TRACE_ENTRY_POINT;

   588     TRACE_EXIT_POINT;

   589     return ( iEntryView != NULL );

   590     }

   591 

   592 // -----------------------------------------------------------------------------

   593 // CCalenGlobalData::MeetingRequestUtilsL

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

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

   596 // -----------------------------------------------------------------------------

   597 EXPORT_C CMRUtils& CCalenGlobalData::MeetingRequestUtilsL()

   598     {

   599     TRACE_ENTRY_POINT;

   600 

   601     iCreateError = KErrNone;

   602     if (!iUtilsAs)

   603         {

   604         iUtilsAs = new (ELeave) CActiveSchedulerWait;

   605         }

   606     if (!iMRUtils)

   607         {

   608         if (InterimUtilsL().MRViewersEnabledL())

   609             {

   610             if (iUtilsAs->IsStarted())

   611                 {

   612                 User::Leave(KErrInUse);

   613                 }

   614             else

   615                 {

   616                 //Get the currently selected mailbox

   617                 CMRMailboxUtils::TMailboxInfo defaultMailbox;

   618                 MRMailboxUtilsL().GetDefaultMRMailBoxL(defaultMailbox);

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

   620                 TBuf8<KMaxUidName> mrMtm;

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

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

   623                 iUtilsAs->Start();

   624                 User::LeaveIfError(iCreateError);

   625                 }

   626             }

   627         else

   628             {

   629             User::Leave(KErrNotSupported);

   630             }

   631         }

   632 

   633     TRACE_EXIT_POINT;

   634     return *iMRUtils;

   635     }

   636 

   637 // -----------------------------------------------------------------------------

   638 // CCalenGlobalData::InterimUtilsL

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

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

   641 // -----------------------------------------------------------------------------

   642 EXPORT_C CCalenInterimUtils2& CCalenGlobalData::InterimUtilsL()

   643     {

   644     TRACE_ENTRY_POINT;

   645 

   646     if(!iInterimUtils)

   647         {

   648         iInterimUtils = CCalenInterimUtils2::NewL();

   649         }

   650 

   651     TRACE_EXIT_POINT;

   652     return *iInterimUtils;

   653     }

   654 

   655 // -----------------------------------------------------------------------------

   656 // CCalenGlobalData::CalenSendL

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

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

   659 // -----------------------------------------------------------------------------

   660 EXPORT_C CCalenSend& CCalenGlobalData::CalenSendL()

   661     {

   662     TRACE_ENTRY_POINT;

   663 

   664     if( !iSend )

   665         {

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

   667         }

   668 

   669     TRACE_EXIT_POINT;

   670     return *iSend;

   671     }

   672 

   673 // -----------------------------------------------------------------------------

   674 // CCalenGlobalData::Context

   675 // Return a reference to the CCalenContext object

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

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

   678 EXPORT_C MCalenContext& CCalenGlobalData::Context()

   679     {

   680     TRACE_ENTRY_POINT;

   681     TRACE_EXIT_POINT;

   682     return *iContext;

   683     }

   684 

   685 // -----------------------------------------------------------------------------

   686 // CCalenEditUi::AttemptToRetrieveDefaultMailboxL

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

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

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

   690 // a new MR.

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

   692 // -----------------------------------------------------------------------------

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

   694     {

   695     TRACE_ENTRY_POINT;

   696 

   697     CMRMailboxUtils& mbUtils = MRMailboxUtilsL();

   698     // Get the currently defined mailboxes.

   699     RArray<CMRMailboxUtils::TMailboxInfo> mailboxes;

   700     CleanupClosePushL(mailboxes);

   701     mbUtils.ListMailBoxesL(mailboxes);

   702 

   703     TBool canCreateMeetingRequest=EFalse;

   704     TInt mbCount = mailboxes.Count();

   705 

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

   707     // defaultMailBox if canCreateMeetingRequest comes out as ETrue.

   708     if(mbCount > 0)

   709         {

   710         TInt res = KErrNone;

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

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

   713             {

   714             canCreateMeetingRequest = ETrue;

   715             }

   716         else

   717             {

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

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

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

   721             RImplInfoPtrArrayOwn implArray;

   722              CleanupClosePushL( implArray );

   723             //Get all MRViewers Implementation

   724              const TUid mrViewersIface = {KMRViewersInterfaceUID};

   725              REComSession::ListImplementationsL(mrViewersIface, implArray );

   726 

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

   728                 {

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

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

   731                      {

   732                      TBuf16<KMaxUidName> mbName;

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

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

   735                          {

   736                          //Found a match

   737                         break;

   738                         }

   739                     //Mailbox has no matching meeting request solution

   740                     //remove from list

   741                     mailboxes.Remove(i);

   742                     }

   743                 }

   744             CleanupStack::PopAndDestroy();    //implArray

   745             

   746             TInt selected = PromptToSelectDefaultMailboxL(mailboxes);

   747 

   748             if(selected >= KErrNone)

   749                 {

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

   751                 canCreateMeetingRequest = ETrue;

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

   753                 }

   754             }

   755         }

   756     else

   757         {

   758         // Force the check of MR Impl existing

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

   760         }

   761    

   762     CleanupStack::PopAndDestroy(); // mailboxes

   763 

   764     TRACE_EXIT_POINT;

   765     return canCreateMeetingRequest;

   766     }

   767 

   768 // -----------------------------------------------------------------------------

   769 // CCalenGlobalData::ResetKeyEventQueue

   770 // Reset Keyevents queue

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

   772 // -----------------------------------------------------------------------------

   773 EXPORT_C void CCalenGlobalData::ResetKeyEventQueue()

   774     {

   775     TRACE_ENTRY_POINT;

   776     iKeyQueue.Reset();

   777     TRACE_EXIT_POINT;

   778     }

   779 

   780 // -----------------------------------------------------------------------------

   781 // CCalenGlobalData::QueueKeyEvent

   782 // Queue key press event in a queue

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

   784 // -----------------------------------------------------------------------------

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

   786                                                TEventCode aType)

   787     {

   788     TRACE_ENTRY_POINT;

   789     TBool result(EFalse);

   790     TQueuedKeyEvent item;

   791     item.iType = aType;

   792     item.iEvent = aEvent;

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

   794         {

   795         result = ETrue;

   796         }

   797     TRACE_EXIT_POINT;

   798     return result;

   799     }

   800 

   801 // -----------------------------------------------------------------------------

   802 // CCalenGlobalData::GetQueueKeyEvent

   803 // Get 1 queued event from the queue

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

   805 // -----------------------------------------------------------------------------

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

   807     {

   808     TRACE_ENTRY_POINT;

   809     TBool result(EFalse);

   810     if(iKeyQueue.Count() > 0)

   811         {

   812         TQueuedKeyEvent item;

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

   814         aEvent = item.iEvent;

   815         aType = item.iType;

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

   817         result = ETrue;

   818         iKeyQueue.Compress();

   819         }

   820     TRACE_EXIT_POINT;

   821     return result;

   822     }

   823 

   824 // -----------------------------------------------------------------------------

   825 // CCalenGlobalData::ConstructFileMappingL

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

   827 // -----------------------------------------------------------------------------

   828 EXPORT_C TBool CCalenGlobalData::ConstructFileMappingL()

   829     {

   830     TRACE_ENTRY_POINT;

   831     iCalendarsSession = CCalSession::NewL();

   832     

   833     ConstructCalendarsListL();

   834     

   835     iFileMappingArray.Reset();

   836         

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

   838         {

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

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

   841         CleanupStack::PushL(filemap);

   842         filemap->SetCalendarFileNameL(calendarFileName);

   843         

   844         iNewEntryView  = NULL;

   845         iNewEntryViewCreation  = NULL;

   846         CCalenDbChangeNotifier* dbChangeNotifier = NULL;

   847         if(iCalSession)

   848             {

   849             iNewCalSession = NULL;

   850             CCalCalendarInfo* calendarInfo = iCalendarInfoList[index];

   851             

   852             CCalSession& tempSession = CreateNewSessionL( calendarFileName,

   853                                     *calendarInfo );

   854             filemap->SetSessionPtr(&tempSession);

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

   856             CreateEntryViewL(tempSession);

   857             filemap->SetEntryView( iNewEntryView );

   858             dbChangeNotifier = CCalenDbChangeNotifier::NewL( tempSession );

   859             dbChangeNotifier->RegisterObserverL(*iDBChangeNotifier);

   860             filemap->SetDBChangeNotifier(dbChangeNotifier);

   861             }            

   862          else

   863             {

   864             CCalSession& tempSession = CalSessionL();

   865             filemap->SetSessionPtr(&tempSession);

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

   867             CreateEntryViewL(tempSession);

   868             filemap->SetEntryView( iNewEntryView );

   869             iGlobalDataOwnsEntryView = EFalse;

   870             iGlobalDataOwnsCalSession = EFalse;

   871             dbChangeNotifier = CCalenDbChangeNotifier::NewL( tempSession );

   872             dbChangeNotifier->RegisterObserverL(*iDBChangeNotifier);

   873             filemap->SetDBChangeNotifier(dbChangeNotifier);

   874             }

   875         iFileMappingArray.Append(filemap);        

   876         CleanupStack::Pop(filemap);

   877         }   

   878     

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

   880         {

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

   882                                     index);

   883         }

   884     

   885     TRACE_EXIT_POINT

   886     return ETrue;

   887     }

   888 

   889 // -----------------------------------------------------------------------------

   890 // CCalenGlobalData::InitializeGlobalDataL

   891 // Initializes multiple db related objects

   892 // -----------------------------------------------------------------------------

   893 EXPORT_C void CCalenGlobalData::InitializeGlobalDataL()

   894     {

   895     TRACE_ENTRY_POINT

   896     

   897     ConstructFileMappingL();

   898     

   899     TRACE_EXIT_POINT

   900     }

   901 

   902 // -----------------------------------------------------------------------------

   903 // CCalenGlobalData::PromptToSelectDefaultMailboxL

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

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

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

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

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

   909 // -----------------------------------------------------------------------------

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

   911     {

   912     TRACE_ENTRY_POINT;

   913 

   914     TInt mbCount = aMailboxes.Count();

   915 

   916     TInt selected;

   917     if (mbCount > 0)

   918         {

   919         CAknSinglePopupMenuStyleListBox* list =

   920             new (ELeave) CAknSinglePopupMenuStyleListBox;

   921         CleanupStack::PushL(list);

   922 

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

   924         CleanupStack::PushL(popupList);

   925 

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

   927         list->CreateScrollBarFrameL(ETrue);

   928         list->ScrollBarFrame()->SetScrollBarVisibilityL(

   929             CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

   930 

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

   932 

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

   934         CleanupStack::PushL(items);

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

   936             {

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

   938             }

   939         CleanupStack::Pop(items);

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

   941 

   942         //Pass ownersip of items to model

   943         model->SetItemTextArray(items);

   944 

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

   946         popupList->SetTitleL(*title);

   947         CleanupStack::PopAndDestroy(title);

   948 

   949         TBool accepted = popupList->ExecuteLD();

   950         CleanupStack::Pop(); // popupList

   951 

   952         if(accepted)

   953             {

   954             selected = list->CurrentItemIndex();

   955             }

   956         else

   957             {

   958             selected = KErrCancel;

   959             }

   960 

   961         CleanupStack::PopAndDestroy();  // list

   962         }

   963     else

   964         {

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

   966         selected = KErrCancel;

   967         }

   968 

   969     TRACE_EXIT_POINT;

   970     return selected;

   971     }

   972 

   973 // -----------------------------------------------------------------------------

   974 // CCalenGlobalData::HandleCalEngStatus

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

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

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

   978 // -----------------------------------------------------------------------------

   979 void CCalenGlobalData::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )

   980     {

   981     TRACE_ENTRY_POINT;

   982 

   983     ASSERT(iUtilsAs);

   984 

   985     switch (aStatus)

   986         {

   987         case ENotReady:

   988             {

   989             //Keep waiting

   990             }

   991         break;

   992         case EAvailableWithoutTombs:

   993         case EAvailable:

   994             {

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

   996             iUtilsAs->AsyncStop();

   997             iCreateError = KErrNone;

   998             }

   999         break;

  1000         case ENotAvailable:

  1001             {

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

  1003             //MeetingRequestUtilsL to leave.

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

  1005             iUtilsAs->AsyncStop();

  1006             iCreateError = KErrNotFound;

  1007             }

  1008         break;

  1009         default:

  1010             {

  1011             //Shouldn't ever get called.

  1012             iUtilsAs->AsyncStop();

  1013             iCreateError = KErrArgument;

  1014             }

  1015         break;

  1016         }

  1017 

  1018     TRACE_EXIT_POINT;

  1019     }

  1020 

  1021 // -----------------------------------------------------------------------------

  1022 // CCalenGlobalData::HandleNotification

  1023 // Handle any notification if registered for

  1024 // -----------------------------------------------------------------------------

  1025 void CCalenGlobalData::HandleNotification(const TCalenNotification aNotification )

  1026 	{

  1027 	TRACE_ENTRY_POINT;

  1028 

  1029 	switch(aNotification)

  1030 		{

  1031 		case ECalenNotifyEntryInstanceViewCreated:

  1032 			{

  1033 			ViewCreationCompleted( ETrue );

  1034 			}

  1035 			break;

  1036 		case ECalenNotifyEntryInstanceViewCreationFailed:

  1037 			{

  1038 			ViewCreationCompleted( EFalse );

  1039 			}

  1040 			break;

  1041 		case ECalenNotifyDeleteInstanceView:

  1042 			{

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

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

  1045 			if(iNewInstanceView)

  1046 				{

  1047 				delete iNewInstanceView;

  1048 				iNewInstanceViewCreation = iNewInstanceView =  NULL;

  1049 				}

  1050 			

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

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

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

  1054 			if(iInstanceView)

  1055 				{

  1056 				delete iInstanceView;

  1057 				iInstanceView = iInstanceViewCreation = NULL;

  1058 				}

  1059 			}

  1060 			break;

  1061 		case ECalenNotifyRealExit:

  1062 			{

  1063 			iCalendarForcedExit = ETrue;

  1064 			}

  1065 			break;

  1066 		case ECalenNotifyCalendarInfoCreated:

  1067 			{

  1068 			TRAP_IGNORE(HandleCalendarInfoCreatedL());

  1069 			}

  1070 			break;

  1071 		case ECalenNotifyCalendarInfoUpdated:

  1072 			{

  1073 			TRAP_IGNORE(HandleCalendarInfoUpdatedL());

  1074 			}

  1075 			break;

  1076 		case ECalenNotifyCalendarFileDeleted:

  1077 			{

  1078 			TRAP_IGNORE(HandleCalendarFileDeletedL());

  1079 			}

  1080 			break;

  1081 		default:

  1082 			break;

  1083 		}

  1084 

  1085     TRACE_EXIT_POINT;

  1086     }

  1087 

  1088 // -----------------------------------------------------------------------------

  1089 // CCalenGlobalData::CreateEntryViewL

  1090 // -----------------------------------------------------------------------------

  1135      if(iInstanceViewCreation)

  1136         {

  1137         iInstanceView = iInstanceViewCreation;

  1138         }

  1139     TRACE_EXIT_POINT;

  1140     }

  1141 

  1142 // -----------------------------------------------------------------------------

  1143 // CCalenGlobalData::CreateEntryViewL

  1144 // -----------------------------------------------------------------------------

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

  1146     {

  1147     TRACE_ENTRY_POINT;

  1148     

  1149     RPointerArray<CCalSession> sessionArray;

  1150     

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

  1152         {

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

  1154         if(index != KErrNotFound)

  1155            {

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

  1157            sessionArray.AppendL(sessionPtr);

  1158            }

  1159         }

  1160     

  1161     if(sessionArray.Count())

  1162         {

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

  1164         if(iNewInstanceViewCreation)

  1165            {

  1166            iNewInstanceView = iNewInstanceViewCreation;        

  1167            }

  1168         }

  1169     

  1170     sessionArray.Reset();

  1230             }

  1231         

  1232         if ( iNewEntryViewCreation )

  1233             {

  1234             iNewEntryView = iNewEntryViewCreation;

  1235             }

  1236         else if ( iNewInstanceViewCreation )

  1237             {

  1238             iNewInstanceView = iNewInstanceViewCreation;