MCL/sf/app/contacts: comparison phonebookengines/VirtualPhonebook/VPbkEng/src/CVPbkCompositeContactView.cpp

equal deleted inserted replaced

-:81f8547efd4f
+:e8e3147d53eb
 #ifdef _DEBUG
 enum TPanic
 {
 EPanicLogic_CreateBookmarkLC = 3
 };
 void Panic(TPanic aPanic)
 {
 _LIT(KPanicCat, "CVPbkCompositeContactView");
 User::Panic(KPanicCat, aPanic);
 }
 // --------------------------------------------------------------------------
 // SendEventToObservers
 // --------------------------------------------------------------------------
 //
 template <class NotifyFunc>
 void SendEventToObservers( MVPbkContactViewBase& aView,
 RPointerArray<MVPbkContactViewObserver>& aObservers,
 NotifyFunc aNotifyFunc )
 {
 const TInt count = aObservers.Count();
 for (TInt i = count - 1; i >= 0; --i)
 // --------------------------------------------------------------------------
 // SendEventToObservers
 // --------------------------------------------------------------------------
 //
 template <class NotifyFunc, class ParamType1, class ParamType2>
 void SendEventToObservers( MVPbkContactViewBase& aView,
 RPointerArray<MVPbkContactViewObserver>& aObservers,
 NotifyFunc aNotifyFunc, ParamType1 aParam1, const ParamType2& aParam2 )
 {
 const TInt count = aObservers.Count();
 for (TInt i = count - 1; i >= 0; --i)
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::~CVPbkCompositeContactView
 // --------------------------------------------------------------------------
 //
 CVPbkCompositeContactView::~CVPbkCompositeContactView()
 {
 delete iCompositePolicy;
 delete iSortOrder;
 iSubViews.ResetAndDestroy();
 iObservers.Close();
 iContactMapping.Reset();
 {
 // Create sort order
 iSortOrder = CVPbkSortOrder::NewL(aSortOrder);
 // Always apply internal policy
 iCompositePolicy =
 CVPbkInternalCompositeViewPolicy::NewL( *this, iObservers );
 // External policy's view event buffering mechanism does not work when
 // native contact views reside in a separate process, therefore we
 // always apply internal policy.
 CleanupStack::Pop(subViewData);
 subViewData->iView = aSubView;
 subViewData->iViewId = aViewId;
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::ActualContactCountL
 // --------------------------------------------------------------------------
 //
 TInt CVPbkCompositeContactView::ActualContactCountL() const
 {
 const TInt subViewCount = iSubViews.Count();
 TInt contactCount = 0;
 for (TInt i = 0; i < subViewCount; ++i)
 {
 // The view can be safely casted because
 // CVPbkCompositeContactView is VPbkEng internal
 // and EVPbkCompositeView type view is always
 // derived from CVPbkCompositeContactView.
 contactCount += static_cast<CVPbkCompositeContactView*>(
 iSubViews[i]->iView )->ActualContactCountL();
 }
 else
 {
 contactCount += iSubViews[i]->iView->ContactCountL();
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::ApplyInternalCompositePolicyL
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::ApplyInternalCompositePolicyL()
 {
 if ( !iCompositePolicy || !iCompositePolicy->InternalPolicy() )
 {
 MVPbkCompositeContactViewPolicy* newPolicy =
 CVPbkInternalCompositeViewPolicy::NewL( *this, iObservers );
 delete iCompositePolicy;
 iCompositePolicy = newPolicy;
 }
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::Type
 // Returns view type.
 // --------------------------------------------------------------------------
 //
 {
 iSubViews[i]->iState = CSubViewData::ENotKnown;
 iSubViews[i]->iView->ChangeSortOrderL(aSortOrder);
 }
 }
 // Create new sort order and take it in use
 MVPbkFieldTypeList* sortOrder = CVPbkSortOrder::NewL(aSortOrder);
 delete iSortOrder;
 iSortOrder = sortOrder;
 }
 {
 // Check that the view is ready before using it.
 TInt index = KErrNotFound;
 if (iSubViews[i]->iState == CSubViewData::EReady)
 {
 index = iSubViews[i]->iView->IndexOfLinkL(aContactLink);
 }
 if (index != KErrNotFound)
 {
 // Establish contact mapping for view and contact index
 TContactMapping mapping;
 mapping.iViewIndex = i;
 if ( err != KErrNone && err != KErrAlreadyExists)
 {
 User::Leave( err );
 }
 TRAP(err,
 {
 VPbkEngUtils::MAsyncCallback* notifyObserver =
 VPbkEngUtils::CreateAsyncCallbackLC(
 *this,
 &CVPbkCompositeContactView::DoAddObserverL,
 &CVPbkCompositeContactView::AddObserverError,
 aObserver);
 iAsyncOperation.CallbackL(notifyObserver);
 CleanupStack::Pop(notifyObserver);
 });
 {
 result = iSubViews[i]->iView->MatchContactStore(aContactStoreUri);
 }
 return result;
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::MatchContactStoreDomain
 // Check does any of the subviews match given contact store domain.
 // --------------------------------------------------------------------------
 //
 // --------------------------------------------------------------------------
 //
 MVPbkContactBookmark* CVPbkCompositeContactView::CreateBookmarkLC
 (TInt aIndex) const
 {
 __ASSERT_ALWAYS( aIndex >= 0,
 VPbkError::Panic( VPbkError::EInvalidContactIndex ) );
 __ASSERT_DEBUG(ContactCountL() > aIndex,
 Panic(EPanicLogic_CreateBookmarkLC));
 const TContactMapping& mapping = iContactMapping[aIndex];
 MVPbkContactViewBase* view = iSubViews[mapping.iViewIndex]->iView;
 return view->CreateBookmarkLC( mapping.iContactIndex );
 (const MVPbkContactBookmark& aContactBookmark) const
 {
 TIdentityRelation<TContactMapping> comparisonOperator(
 &CVPbkCompositeContactView::CompareMappings);
 TInt result = KErrNotFound;
 // Search the bookmark from all the subviews
 const TInt subViewCount = iSubViews.Count();
 for (TInt i = 0; i < subViewCount; ++i)
 {
 // Check that the view is ready before using it.
 TInt index(KErrNotFound);
 if (iSubViews[i]->iState == CSubViewData::EReady)
 {
 index = iSubViews[i]->iView->IndexOfBookmarkL(aContactBookmark);
 }
 if (index != KErrNotFound)
 {
 // Establish contact mapping for view and contact index
 TContactMapping mapping;
 mapping.iViewIndex = i;
 (MVPbkContactViewBase& aView, TInt aIndex,
 const MVPbkContactLink& aContactLink)
 {
 TInt compositeIndex = HandleContactAddition(aView, aIndex);
 TRAPD( error, iCompositePolicy->HandleViewEventsL(
 CVPbkEventArrayItem::EAdded, aView, compositeIndex, aContactLink ) );
 if ( error != KErrNone )
 {
 // If error occurs reset policy
 iCompositePolicy->Reset();
 (MVPbkContactViewBase& aView, TInt aIndex,
 const MVPbkContactLink& aContactLink)
 {
 TInt compositeIndex( KErrNotFound );
 compositeIndex = HandleContactRemoval(aView, aIndex);
 TRAPD( error, iCompositePolicy->HandleViewEventsL(
 CVPbkEventArrayItem::ERemoved, aView, compositeIndex,
 aContactLink ) );
 if ( error != KErrNone )
 {
 // If error occurs reset policy
 iCompositePolicy->Reset();
 {
 SendViewErrorEvent( aError, aErrorNotified );
 }
 // --------------------------------------------------------------------------
+// CVPbkCompositeContactView::ContactViewObserverExtension
+// --------------------------------------------------------------------------
+//
+TAny* CVPbkCompositeContactView::ContactViewObserverExtension( TUid aExtensionUid )
+{
+if( aExtensionUid == KVPbkContactViewObserverExtension2Uid )
+{
+return static_cast<MVPbkContactViewObserverExtension*>( this );
+}
+return NULL;
+}
+// --------------------------------------------------------------------------
+// CVPbkCompositeContactView::FilteredContactRemovedFromView
+// --------------------------------------------------------------------------
+//
+void CVPbkCompositeContactView::FilteredContactRemovedFromView(
+		MVPbkContactViewBase& aView )
+{
+const TInt count = iObservers.Count();
+for( TInt i = 0; i < count; i++ )
+{
+MVPbkContactViewObserver* observer = iObservers[i];
+TAny* extension = observer->ContactViewObserverExtension(
+KVPbkContactViewObserverExtension2Uid );
+if( extension )
+{
+MVPbkContactViewObserverExtension* contactViewExtension =
+static_cast<MVPbkContactViewObserverExtension*>( extension );
+if( contactViewExtension )
+{
+contactViewExtension->FilteredContactRemovedFromView( aView );
+}
+}
+}
+}
+// --------------------------------------------------------------------------
 // CVPbkCompositeContactView::UpdateFilterL
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::UpdateFilterL(
 const MDesCArray& aFindWords,
 const MVPbkContactBookmarkCollection* aAlwaysIncludedContacts )
 {
 const TInt count = iSubViews.Count();
 for( TInt i = 0; i < count; ++i )
 {
 MVPbkContactViewFiltering* filtering =
 iSubViews[i]->iView->ViewFiltering();
 // Check if the subview supports filtering.
 if ( filtering )
 {
 // Filtering supported
 // time a subview notifies composite. This is not wanted because
 // client must get only one notification after update.
 // On the other hand a client can still use this view while it's
 // updating itself so in that point of view the composite is not
 // in unknown state but in update state.
 iSubViews[i]->iState = CSubViewData::ENotKnown;
 }
 }
 }
 TInt CVPbkCompositeContactView::ChildViewCount() const
 {
 MVPbkContactViewBase* view = NULL;
 const TInt count = iSubViews.Count();
 for (TInt i = 0; i < count; ++i)
 {
 view=iSubViews[i]->iView;
 if (iSubViews[i]->iViewId == aId)
 {
 return view;
 }
 }
 return iViewId;
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::SendViewReadyEvent
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::SendViewReadyEvent()
 {
 VPBK_DEBUG_PRINT( VPBK_DEBUG_STRING(
 "CVPbkCompositeContactView::SendViewReadyEvent(0x%x)"), this );
 // Cancel operation to avoid unnecessary event sending in DoAddObserverL
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::SendViewUnavailableEvent
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::SendViewUnavailableEvent()
 {
 VPBK_DEBUG_PRINT( VPBK_DEBUG_STRING(
 "CVPbkCompositeContactView::SendViewUnavailableEvent(0x%x)"), this );
 // Cancel operation to avoid unnecessary event sending in DoAddObserverL
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::SendViewErrorEvent
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::SendViewErrorEvent( TInt aError,
 TBool aErrorNotified )
 {
 SendEventToObservers(*this, iObservers,
 &MVPbkContactViewObserver::ContactViewError, aError, aErrorNotified);
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::CompareMappings
 // --------------------------------------------------------------------------
 //
 TBool CVPbkCompositeContactView::CompareMappings
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::CompositePolicy
 // --------------------------------------------------------------------------
 //
 MVPbkCompositeContactViewPolicy&
 CVPbkCompositeContactView::CompositePolicy() const
 {
 return *iCompositePolicy;
 }
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::ResetContactMapping
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::ResetContactMapping()
 {
 iContactMapping.Reset();
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::RemoveContactMappingsFromView
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::RemoveContactMappingsFromView(
 MVPbkContactViewBase& aView )
 {
 TInt subviewIndex = FindSubViewIndex( aView );
 if ( subviewIndex != KErrNotFound )
 {
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::HandleContactViewReadyL
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::HandleContactViewReadyL(
 MVPbkContactViewBase& aView )
 {
 VPBK_DEBUG_PRINT( VPBK_DEBUG_STRING(
 "CVPbkCompositeContactView::HandleContactViewReadyL(0x%x)"), this );
 // Find matching subview and set its state to ready
 TInt subViewIndex = FindSubViewIndex(aView);
 if (subViewIndex != KErrNotFound)
 {
 iSubViews[subViewIndex]->iState = CSubViewData::EReady;
 }
 // Check that composite's sort order up to date with subviews.
 UpdateSortOrderL();
 // If composite is ready, build view mapping and notify observers
 if ( IsCompositeReady() )
 {
 VPBK_PROFILE_START(VPbkProfile::ECompositeContactViewMapping);
 DoBuildContactMappingL();
 VPBK_PROFILE_END(VPbkProfile::ECompositeContactViewMapping);
 SendViewReadyEvent();
 }
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::HandleContactViewUnavailableL
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::HandleContactViewUnavailableL(
 MVPbkContactViewBase& aView )
 {
 VPBK_DEBUG_PRINT( VPBK_DEBUG_STRING(
 "CVPbkCompositeContactView::ContactViewUnavailable(0x%x)"), this );
 // Find matching subview and set its state
 TInt subViewIndex = FindSubViewIndex(aView);
 if (subViewIndex != KErrNotFound)
 {
 iSubViews[subViewIndex]->iState = CSubViewData::EUnavailable;
 SendViewUnavailableEvent();
 }
 else
 {
 // Composite is still under construction.
 // Dont't send event here because the state of the composite is
 // not yet known and sending event can cause problems for client
 // e.g unwanted changes in the UI state.
 RemoveContactMappingsFromView( aView );
 }
 }
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::CVPbkCompositeContactView
 // --------------------------------------------------------------------------
 //
 TInt CVPbkCompositeContactView::HandleContactRemoval
 ( MVPbkContactViewBase& aView, TInt aIndex )
 {
 TInt index = KErrNotFound;
 // Find correct subview
 TInt subViewIndex = FindSubViewIndex( aView );
 if ( subViewIndex != KErrNotFound )
 {
 TIdentityRelation<TContactMapping> comparisonOperator
 TContactMapping mapping;
 mapping.iViewIndex = subViewIndex;
 mapping.iContactIndex = aIndex;
 // Find the composite index by comparing the two mappings
 index = iContactMapping.Find( mapping, comparisonOperator );
 if ( index > KErrNotFound )
 {
 // Loop through the rest of the contacts of the subview
 // and modify their global contact mapping information
 for (TInt i = index; i < iContactMapping.Count(); ++i)
 {
 if (iContactMapping[i].iViewIndex == subViewIndex)
 DoBuildContactMappingL();
 }
 }
 return index;
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::HandleContactAddition
 // --------------------------------------------------------------------------
 //
 TInt CVPbkCompositeContactView::HandleContactAddition
 (MVPbkContactViewBase& aView, TInt aIndex)
 {
 TInt index = KErrNotFound;
 // Find correct subview
 TInt subViewIndex = FindSubViewIndex(aView);
 if (subViewIndex != KErrNotFound)
 {
 TRAPD( err, index = DoHandleContactAdditionL
 ( subViewIndex, aIndex ) );
 if (err != KErrNone)
 {
 index = err;
 }
 else
 	{
 	// We have to fix the indexes of all the succeeding
 // contacts in the view where the contact addition took place
 for ( TInt i = index + 1; i < iContactMapping.Count(); ++i )
 {
 }
 	}
 }
 return index;
 }
 // --------------------------------------------------------------------------
 // CVPbkCompositeContactView::DoAddObserverL
 // Notifies composite view readiness to observer.
 // --------------------------------------------------------------------------
 //
 // View is considered to be ready if all subviews are ready (iIsReady)
 // or if there are no subviews
 if ( iObservers.FindInAddressOrder( &aObserver ) != KErrNotFound )
 {
 if( IsCompositeReady() )
 {
 // If this view is ready and there was no error tell it to the observer
 aObserver.ContactViewReady(*this);
 }
 else if ( AllSubViewsKnown() )
 {
 // All subviews are known but the composite is not ready ->
 // view is unavailable.
 // --------------------------------------------------------------------------
 //
 void CVPbkCompositeContactView::UpdateSortOrderL()
 {
 const MVPbkFieldTypeList* sortOrder = NULL;
 // Inspect the sort order of subviews. If all ready subviews have
 // same sort order then update composite's sort order.
 // This is done because subviews can be shared views whose sort order
 // is not changed to client's sort order when a new handle is created.
 TBool subViewsHaveSameOrder = ETrue;
 const TInt count = iSubViews.Count();
 for ( TInt i = 0; i < count && subViewsHaveSameOrder; ++i )
 {
 if ( iSubViews[i]->iState == CSubViewData::EReady )
 {
 const MVPbkFieldTypeList& curViewsOrder =
 iSubViews[i]->iView->SortOrder();
 if ( sortOrder )
 {
 subViewsHaveSameOrder =
 VPbkFieldTypeList::IsSame( *sortOrder, curViewsOrder );
 }
 sortOrder = &curViewsOrder;
 }
 }
 if ( subViewsHaveSameOrder && sortOrder &&
 !VPbkFieldTypeList::IsSame( *sortOrder, *iSortOrder ) )
 {
 CVPbkSortOrder* newOrder = CVPbkSortOrder::NewL( *sortOrder );
 delete iSortOrder;
 iSortOrder = newOrder;
 }
 }
 void CVPbkCompositeContactView::SetViewId(TInt aViewId)
 {
 iViewId = aViewId;
 }
 // --------------------------------------------------------------------------
 // CVPbkExternalCompositeViewPolicy::CVPbkExternalCompositeViewPolicy
 // --------------------------------------------------------------------------
 //
 CVPbkExternalCompositeViewPolicy::CVPbkExternalCompositeViewPolicy(
 CVPbkCompositeContactView& aCompositeView,
 RPointerArray<MVPbkContactViewObserver>& aObservers )
 :   iCompositeView( aCompositeView ),
 iObservers( aObservers )
 {
 }
 // --------------------------------------------------------------------------
 // CVPbkExternalCompositeViewPolicy::NewL
 // --------------------------------------------------------------------------
 //
 CVPbkExternalCompositeViewPolicy* CVPbkExternalCompositeViewPolicy::NewL(
 CVPbkCompositeContactView& aCompositeView,
 RPointerArray<MVPbkContactViewObserver>& aObservers )
 {
 CVPbkExternalCompositeViewPolicy* self =
 new ( ELeave ) CVPbkExternalCompositeViewPolicy( aCompositeView,
 aObservers );
 return self;
 }
 // --------------------------------------------------------------------------
 // CVPbkExternalCompositeViewPolicy::~CVPbkExternalCompositeViewPolicy
 // --------------------------------------------------------------------------
 //
 CVPbkExternalCompositeViewPolicy::~CVPbkExternalCompositeViewPolicy()
 {
 iEventArray.ResetAndDestroy();
 }
 // --------------------------------------------------------------------------
 // CVPbkExternalCompositeViewPolicy::HandleViewEventsL
 // --------------------------------------------------------------------------
 //
 void CVPbkExternalCompositeViewPolicy::HandleViewEventsL(
 CVPbkEventArrayItem::TViewEventType aEvent,
 MVPbkContactViewBase& /*aSubview*/,
 TInt aIndex, const
 MVPbkContactLink& aContactLink )
 {
 // Append all view events to proper event array.
 CVPbkEventArrayItem* item =
 CVPbkEventArrayItem::NewLC( aIndex, aContactLink, aEvent );
 iEventArray.AppendL( item );
 CleanupStack::Pop(); // item
 // Check if the composite is up to date. Note that if the underlying
 // native store view resides in a separate process or thread,
 // this check may "accidentally" pass whilst the native view is still
 // updating itself. This means that the composite might fall out of sync
 // anytime after this check and it will then mean severe problems to the
 // be zero, as the sync check is implemented in
 // CVPbkExternalCompositeViewPolicy::ContactCountL too.
 // The count of zero might be in severe contradiction with the
 // view events the client just received.
 // If the native view resides in the  same process, there are no risks.
 if (iCompositeView.CompositeContactCountL() ==
 iCompositeView.ActualContactCountL() )
 {
 // Composite mapping is valid according to contact counts. Flush
 // the event cache.
 TInt eventCount( iEventArray.Count() );
 for( TInt i = 0; i < eventCount; ++i )
 {
 if ( iEventArray[ i ]->Event() == CVPbkEventArrayItem::ERemoved )
 {
 SendEventToObservers( iCompositeView, iObservers,
 &MVPbkContactViewObserver::ContactRemovedFromView,
 iEventArray[ i ]->Index(),
 *iEventArray[ i ]->Link() );
 }
 else
 {
 SendEventToObservers( iCompositeView, iObservers,
 &MVPbkContactViewObserver::ContactAddedToView,
 iEventArray[ i ]->Index(),
 *iEventArray[ i ]->Link() );
 }
 }
 iEventArray.ResetAndDestroy();
 }
 }
 // --------------------------------------------------------------------------
 // CVPbkExternalCompositeViewPolicy::Reset
 // --------------------------------------------------------------------------
 //
 void CVPbkExternalCompositeViewPolicy::Reset()
 {
 iEventArray.ResetAndDestroy();
 }
 // --------------------------------------------------------------------------
 // CVPbkExternalCompositeViewPolicy::ContactCountL
 // --------------------------------------------------------------------------
 //
 TInt CVPbkExternalCompositeViewPolicy::ContactCountL() const
 {
 TInt compositeCount = iCompositeView.CompositeContactCountL();
 if ( compositeCount != iCompositeView.ActualContactCountL() )
 {
 // If composite count is different as the contact count in subviews
 // it means that composite hasn't got all view events yet and its
 // contact mapping is not in valid state. It's too heavy to build
 }
 // --------------------------------------------------------------------------
 // CVPbkExternalCompositeViewPolicy::InternalPolicy
 // --------------------------------------------------------------------------
 //
 TBool CVPbkExternalCompositeViewPolicy::InternalPolicy() const
 {
 return EFalse;
 }
 // --------------------------------------------------------------------------
 // CVPbkInternalCompositeViewPolicy::CVPbkInternalCompositeViewPolicy
 // --------------------------------------------------------------------------
 //
 CVPbkInternalCompositeViewPolicy::CVPbkInternalCompositeViewPolicy(
 CVPbkCompositeContactView& aCompositeView,
 RPointerArray<MVPbkContactViewObserver>& aObservers )
 :   iCompositeView( aCompositeView ),
 iObservers( aObservers )
 {
 }
 // --------------------------------------------------------------------------
 // CVPbkInternalCompositeViewPolicy::NewL
 // --------------------------------------------------------------------------
 //
 CVPbkInternalCompositeViewPolicy* CVPbkInternalCompositeViewPolicy::NewL(
 CVPbkCompositeContactView& aCompositeView,
 RPointerArray<MVPbkContactViewObserver>& aObservers )
 {
 CVPbkInternalCompositeViewPolicy* self =
 new ( ELeave ) CVPbkInternalCompositeViewPolicy( aCompositeView,
 aObservers );
 return self;
 }
 // --------------------------------------------------------------------------
 // CVPbkInternalCompositeViewPolicy::HandleViewEventsL
 // --------------------------------------------------------------------------
 //
 void CVPbkInternalCompositeViewPolicy::HandleViewEventsL(
 CVPbkEventArrayItem::TViewEventType aEvent,
 MVPbkContactViewBase& /*aSubview*/,
 TInt aIndex, const
 MVPbkContactLink& aContactLink )
 {
 if ( aEvent == CVPbkEventArrayItem::ERemoved )
 {
 SendEventToObservers( iCompositeView, iObservers,
 &MVPbkContactViewObserver::ContactRemovedFromView,
 aIndex,
 aContactLink );
 }
 else
 {
 SendEventToObservers( iCompositeView, iObservers,
 &MVPbkContactViewObserver::ContactAddedToView,
 aIndex,
 aContactLink );
 }
 }
 // --------------------------------------------------------------------------
 // CVPbkInternalCompositeViewPolicy::Reset
 // --------------------------------------------------------------------------
 //
 void CVPbkInternalCompositeViewPolicy::Reset()
 {
 // No cached data to reset
 }
 // --------------------------------------------------------------------------
 // CVPbkInternalCompositeViewPolicy::ContactCountL
 // --------------------------------------------------------------------------
 //
 TInt CVPbkInternalCompositeViewPolicy::ContactCountL() const
 {
 return iCompositeView.CompositeContactCountL();
 }
 // --------------------------------------------------------------------------
 // CVPbkInternalCompositeViewPolicy::InternalPolicy
 // --------------------------------------------------------------------------
 //
 TBool CVPbkInternalCompositeViewPolicy::InternalPolicy() const
 {
 return ETrue;
 }
 // End of File

branch	RCL_3
changeset 6	e8e3147d53eb
parent 0	e686773b3f54
child 15	34879f5cfc63