1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *       Provides methods for phonebook contact view list control.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 #include <CPbkContactViewListControl.h>  // This class

    22 #include <barsread.h>    // TResourceReader

    23 #include <eikclbd.h>     // CColumnListBoxData

    24 #include <aknsfld.h>     // CAknSearchField

    25 #include <aknlists.h>    // AknListBoxUtils

    26 #include <AknsDrawUtils.h>

    27 #include <featmgr.h>

    28 #include <bldvariant.hrh>

    29 #include <PbkView.rsg>

    30 #include <AknDef.h>      // KEikDynamicLayoutVariantSwitch

    31 #include <AknUtils.h>

    32 

    33 

    34 // PbkView classes

    35 #include <PbkView.hrh>

    36 #include "CPbkViewState.h"

    37 #include "CPbkThumbnailPopup.h"

    38 #include <CPbkIconArray.h>

    39 #include <MPbkContactViewListControlObserver.h>

    40 #include "PbkFindPrimitivesFactory.h"

    41 #include "PbkContactViewListModelFactory.h"

    42 #include "MPbkFetchDlgSelection.h"

    43 

    44 // PbkEng classes

    45 #include <CPbkContactEngine.h>

    46 #include <CPbkConstants.h>

    47 #include <CPbkContactFindView.h>

    48 

    49 // PbkExt classes

    50 #include <CPbkExtGlobals.h>

    51 #include <MPbkViewExtension.h>

    52 #include <MPbkContactUiControlExtension.h>

    53 #include <MPbkExtensionFactory.h>

    54 

    55 // Phonebook common include files

    56 #include <PbkDebug.h>        // Phonebook debugging support

    57 

    58 

    59 // Unnamed namespace for local definitions

    60 namespace {

    61 

    62 // LOCAL CONSTANTS AND MACROS

    63 

    64 /// Listbox model's entry cache size

    65 const TInt KCacheSize = 32;

    66 

    67 const TUint16 KZwsChar = 0x200b;

    68 const TUint16 KZwnjChar = 0x200c;

    69 

    70 enum TPanicCode

    71     {

    72     EPanicPostCond_Constructor = 1,

    73     EPanicPreCond_ConstructFromResourceL,

    74     EPanicInvalidListBoxType_ConstructFromResourceL,

    75     EPanicPostCond_ConstructFromResource,

    76     EPanicPreCond_ConstructL,

    77     EPanicPostCond_ConstructL,

    78     EPanicListBoxNull,

    79     EPanicLogic_ComponentControl,

    80     EPanicPostCond_EnableFindBoxL,

    81     EPanicPostCond_DisableFindBoxL,

    82     EPanicLogic_FindTextL,

    83     EPanicPre_SetControlExtensionL

    84     };

    85 

    86 

    87 // MODULE DATA STRUCTURES

    88 

    89 NONSHARABLE_CLASS(TCleanupEnableListBoxViewRedraw)

    90     {

    91     public:  // Interface

    92         inline TCleanupEnableListBoxViewRedraw(CListBoxView& aListBoxView)

    93             : iCleanupItem(CleanupOp,&aListBoxView)

    94             {

    95             }

    96 

    97         inline operator TCleanupItem() const

    98             {

    99             return iCleanupItem;

   100             }

   101 

   102     private:  // Implementation

   103         static void CleanupOp(TAny* aPtr);

   104 

   105     private:  // Data

   106         TCleanupItem iCleanupItem;

   107     };

   108 

   109 // ==================== LOCAL FUNCTIONS ====================

   110 

   111 /**

   112  * Returns index of aValue in aArray or KErrNotFound.

   113  */

   114 template<class T>

   115 TInt Find(const CArrayFix<T>& aArray, const T& aValue)

   116     {

   117     const TInt count = aArray.Count();

   118     for (TInt i = 0; i < count; ++i)

   119         {

   120         if (aArray[i] == aValue)

   121             {

   122             return i;

   123             }

   124         }

   125     return KErrNotFound;

   126     }

   127 

   128 /**

   129  * Returns CPbkIconArray icon array from aListBox.

   130  */

   131 inline CPbkIconArray* IconArray(CEikColumnListBox& aListBox)

   132     {

   133     return static_cast<CPbkIconArray*>

   134         (aListBox.ItemDrawer()->ColumnData()->IconArray());

   135     }

   136 

   137 /**

   138  * Sets aIconArray as aListBox'es icon array.

   139  */

   140 inline void SetIconArray

   141         (CEikColumnListBox& aListBox, CPbkIconArray* aIconArray)

   142     {

   143     aListBox.ItemDrawer()->ColumnData()->SetIconArray(aIconArray);

   144     }

   145 

   146 void Panic(TPanicCode aReason)

   147     {

   148     _LIT(KPanicText, "CPbkContactViewListControl");

   149     User::Panic(KPanicText, aReason);

   150     }

   151 

   152 /**

   153  * Returns ETrue, if a character is to be included in the search string

   154  */

   155 inline TBool IsSearchableChar( const TChar aChar )

   156     {

   157     switch (aChar)

   158         {

   159         case KZwsChar:  // FALLTHROUGH

   160         case KZwnjChar:

   161             {

   162             return EFalse;

   163             }

   164         }

   165     return ETrue;

   166     }

   167 

   168 // MACROS

   169 

   170 /// Define this to print find performance data to debug output

   171 #ifdef PBK_BENCHMARK_FIND

   172   #pragma message("Warning: PBK_BENCHMARK_FIND is set")

   173 #endif

   174 

   175 // MODULE DATA STRUCTURES

   176 

   177 #ifdef PBK_BENCHMARK_FIND

   178 

   179 /// Benchmarking helper class.

   180 template<class NumT>

   181 NONSHARABLE_CLASS(TRunningTimes)

   182     {

   183     public:  // Interface

   184         /**

   185          * Constructor.

   186          */

   187         inline TRunningTimes()

   188             {

   189             Reset();

   190             }

   191         /**

   192          * () operator.

   193          */

   194         inline NumT operator()() const

   195             {

   196             return iTotal;

   197             }

   198 

   199         inline void Start()

   200             {

   201             iStart.UniversalTime();

   202             }

   203         inline void Stop()

   204             {

   205             iStop.UniversalTime();

   206             const TInt timeDiff =

   207                 I64LOW(iStop.MicroSecondsFrom(iStart).Int64()) / 1000;

   208             iTotal += timeDiff;

   209             iCount++;

   210             }

   211 

   212         inline TInt Count() const

   213             {

   214             return iCount;

   215             }

   216 

   217         /**

   218          * Returns total time

   219          */

   220         inline NumT Total() const

   221             {

   222             return iTotal;

   223             }

   224 

   225         /**

   226          * Reset.

   227          */

   228         inline void Reset()

   229             {

   230             iTotal=0; iCount=0;

   231             }

   232 

   233     private:  // Data

   234         TTime iStart;

   235         TTime iStop;

   236         /// Own: count

   237         TInt iCount;

   238         /// Own: total time

   239         NumT iTotal;

   240     };

   241 

   242 #endif  // PBK_BENCHMARK_FIND

   243 

   244 }  // namespace

   245 

   246 

   247 // ================= MEMBER FUNCTIONS =======================

   248 

   249 //

   250 // CPbkContactViewListControl

   251 //

   252 inline CEikColumnListBox& CPbkContactViewListControl::ListBox() const

   253     {

   254     __ASSERT_DEBUG(iListBox, Panic(EPanicListBoxNull));

   255     return(*iListBox);

   256     }

   257 

   258 inline MPbkContactViewListModel& CPbkContactViewListControl::Model() const

   259     {

   260     return(*static_cast<MPbkContactViewListModel*>

   261         (iListBox->Model()->ItemTextArray()));

   262     }

   263 

   264 inline TBool CPbkContactViewListControl::PostCond_Constructor()

   265     {

   266     return

   267         (!iListBox && !iFindBox && !iFindTextBuf && !iBaseView && !iView &&

   268         !iResourceData.iUnnamedText && !iResourceData.iFindEmptyText &&

   269         !iMarkedItemsArray && !iThumbnailPopup);

   270     }

   271 

   272 inline TBool CPbkContactViewListControl::PostCond_ConstructFromResource()

   273     {

   274     return

   275         (iListBox && !iFindBox && !iFindTextBuf &&

   276         iResourceData.iUnnamedText && !iMarkedItemsArray);

   277     }

   278 

   279 EXPORT_C CPbkContactViewListControl* CPbkContactViewListControl::NewL

   280         (CPbkContactEngine& aEngine,

   281         CContactViewBase& aView,

   282         TInt aResourceId,

   283         const CCoeControl* aParent)

   284     {

   285     PBK_DEBUG_PRINT(PBK_DEBUG_STRING("CPbkContactViewListControl::NewL()"));

   286     CPbkContactViewListControl* self = new(ELeave) CPbkContactViewListControl();

   287     CleanupStack::PushL(self);

   288     self->ConstructL(aEngine, aView, aResourceId, aParent);

   289     CleanupStack::Pop(self);

   290     return self;

   291     }

   292 

   293 EXPORT_C CPbkContactViewListControl::CPbkContactViewListControl() :

   294     iLastFocusId(KNullContactId),

   295     iChangedIndexes(1 /*allocation granularity*/)

   296     {

   297     // CBase::operator new(TLeave) resets other members

   298     PBK_DEBUG_PRINT(PBK_DEBUG_STRING

   299         ("CPbkContactViewListControl::CPbkContactViewListControl(0x%x)"),

   300             this);

   301     __ASSERT_DEBUG(PostCond_Constructor(), Panic(EPanicPostCond_Constructor));

   302     }

   303 

   304 void CPbkContactViewListControl::ConstructFromResourceL

   305         (TResourceReader& aReader)

   306     {

   307     __ASSERT_DEBUG(PostCond_Constructor(),

   308         Panic(EPanicPreCond_ConstructFromResourceL));

   309     PBK_DEBUG_PRINT(PBK_DEBUG_STRING

   310         ("CPbkContactViewListControl::ConstructFromResourceL(0x%x)"),this);

   311 

   312     // emptyText

   313     TPtrC emptyText = aReader.ReadTPtrC();

   314     // unnamedText

   315     iResourceData.iUnnamedText = aReader.ReadHBufCL();

   316     // flags

   317     iResourceData.iFlags = aReader.ReadUint32();

   318 

   319     // Empty text in find state

   320     TResourceReader rr;

   321     iEikonEnv->CreateResourceReaderLC(rr, R_AVKON_FIND_NO_MATCHES);

   322     iResourceData.iFindEmptyText = rr.ReadHBufCL();

   323     CleanupStack::PopAndDestroy(); // rr

   324 

   325     // listboxType

   326     TInt listBoxType = aReader.ReadInt16();

   327     iListBox = static_cast<CEikColumnListBox*>

   328         (EikControlFactory::CreateByTypeL(listBoxType).iControl);

   329     __ASSERT_ALWAYS(iListBox, Panic

   330         (EPanicInvalidListBoxType_ConstructFromResourceL));

   331     iListBox->SetContainerWindowL(*this);

   332     // listbox

   333     iListBox->ConstructFromResourceL(aReader);

   334     iListBox->View()->SetListEmptyTextL(emptyText);

   335     iListBox->CreateScrollBarFrameL(ETrue);

   336     iListBox->ScrollBarFrame()->SetScrollBarVisibilityL

   337         (CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

   338     iListBox->SetObserver(this);

   339     iListBox->MakeVisible(EFalse);

   340 

   341     // iconArray, use granularity of 4

   342 

   343     CPbkIconArray* iconArray = new(ELeave) CPbkIconArray(4);

   344     CleanupStack::PushL(iconArray);

   345     const TInt iconArrayRes = aReader.ReadInt32();

   346     iconArray->ConstructFromResourceL(iconArrayRes);

   347 

   348     // get extension factory for setting extension icons

   349     CPbkExtGlobals* extGlobal = CPbkExtGlobals::InstanceL();

   350     extGlobal->PushL();

   351     MPbkExtensionFactory& factory = extGlobal->FactoryL();

   352     factory.AddPbkFieldIconsL(NULL, iconArray);

   353     CleanupStack::PopAndDestroy(extGlobal);

   354 

   355     CleanupStack::Pop(iconArray);

   356 

   357     SetIconArray(*iListBox,iconArray);

   358 

   359     // emptyIconId

   360     iResourceData.iEmptyIconId =

   361         static_cast<TPbkIconId>(aReader.ReadInt16());

   362     // defaultIconId

   363     iResourceData.iDefaultIconId =

   364         static_cast<TPbkIconId>(aReader.ReadInt16());

   365 

   366     // Preallocate space for the one required integer

   367     iChangedIndexes.AppendL(-1);

   368 

   369     __ASSERT_DEBUG(PostCond_ConstructFromResource(),

   370         Panic(EPanicPostCond_ConstructFromResource));

   371     }

   372 

   373 EXPORT_C void CPbkContactViewListControl::ConstructL

   374         (CPbkContactEngine& aEngine,

   375         CContactViewBase& aView)

   376     {

   377     // Check that ConstructFromResourceL is executed

   378     __ASSERT_DEBUG(PostCond_ConstructFromResource() && !iBaseView && !iView,

   379         Panic(EPanicPreCond_ConstructL));

   380     PBK_DEBUG_PRINT(PBK_DEBUG_STRING

   381         ("CPbkContactViewListControl::ConstructL(0x%x)"),this);

   382 

   383     iFindPrimitives = PbkFindPrimitivesFactory::CreateL(

   384         aEngine.ContactNameFormat());

   385     iBaseView = &aView;

   386     iView = CPbkContactFindView::NewL(

   387         aEngine, *iBaseView, *this, *iFindPrimitives);

   388 

   389     // Set aParams for MPbkContactViewListModel

   390     PbkContactViewListModelFactory::TParams params;

   391     params.iEngine = &aEngine;

   392     params.iView = iView;

   393     params.iCacheSize = KCacheSize;

   394     params.iIconArray = IconArray(*iListBox);

   395     params.iEmptyId = iResourceData.iEmptyIconId;

   396     params.iDefaultId = iResourceData.iDefaultIconId;

   397 

   398     // Listbox model

   399     MPbkContactViewListModel* model = PbkContactViewListModelFactory::

   400                                             CreateL(params);

   401     model->SetUnnamedText(iResourceData.iUnnamedText);

   402     iListBox->Model()->SetItemTextArray(model);

   403     iListBox->Model()->SetOwnershipType(ELbmOwnsItemArray);

   404 

   405     // thumbnail handler

   406     if (iResourceData.iFlags & KPbkContactViewListControlUpdateContextPane)

   407         {

   408         iThumbnailPopup = CPbkThumbnailPopup::NewL(aEngine);

   409         }

   410 

   411     // Sets up TLS, must be done before FeatureManager is used.

   412     FeatureManager::InitializeLibL();

   413     // iEngine != NULL means that Featuremanager has been initialized

   414     iEngine = &aEngine;

   415 

   416     __ASSERT_DEBUG(PostCond_ConstructFromResource() && iBaseView && iView &&

   417         iThumbnailPopup || !(iResourceData.iFlags &

   418         KPbkContactViewListControlUpdateContextPane),

   419         Panic(EPanicPostCond_ConstructL));

   420     }

   421 

   422 CPbkContactViewListControl::~CPbkContactViewListControl()

   423     {

   424     PBK_DEBUG_PRINT(PBK_DEBUG_STRING

   425         ("CPbkContactViewListControl::~CPbkContactViewListControl(0x%x)"),

   426         this);

   427 

   428     // This should be done before listbox delete

   429     // (which deletes dummy control extension)

   430     Release(iControlExtension);

   431 

   432     // Fetch dialog pages might delay calling ConstructL and thus Feature

   433     // manager might not be initialized if destructing early.

   434     if (iEngine)

   435         {

   436         // iEngine != NULL means that Featuremanager has been initialized

   437         FeatureManager::UnInitializeLib();

   438         }

   439 

   440     delete iOriginalEmptyText;

   441     iObservers.Reset();

   442     delete iFindTextBuf;

   443     if (iView)

   444         {

   445         iView->Close(*this);

   446         }

   447     delete iFindPrimitives;

   448     delete iThumbnailPopup;

   449     delete iMarkedItemsArray;

   450     delete iFindBox;

   451     delete iListBox;

   452     delete iResourceData.iFindEmptyText;

   453     delete iResourceData.iUnnamedText;

   454     }

   455 

   456 EXPORT_C TContactItemId CPbkContactViewListControl::ContactIdAtL

   457         (TInt aIndex) const

   458     {

   459     return iView->AtL(aIndex);

   460     }

   461 

   462 EXPORT_C TInt CPbkContactViewListControl::FindContactIdL

   463         (TContactItemId aId) const

   464     {

   465     return iView->FindL(aId);

   466     }

   467 

   468 EXPORT_C TInt CPbkContactViewListControl::CurrentItemIndex() const

   469     {

   470     return ListBox().CurrentItemIndex();

   471     }

   472 

   473 EXPORT_C void CPbkContactViewListControl::SetCurrentItemIndex(TInt aIndex)

   474     {

   475     if (ListBox().CurrentItemIndex() != aIndex)

   476         {

   477         ListBox().SetCurrentItemIndex(aIndex);

   478         HandleFocusChange();

   479         }

   480     }

   481 

   482 EXPORT_C void CPbkContactViewListControl::SetCurrentItemIndexAndDraw

   483         (TInt aIndex)

   484     {

   485     if (ListBox().CurrentItemIndex() != aIndex)

   486         {

   487         ListBox().SetCurrentItemIndexAndDraw(aIndex);

   488         HandleFocusChange();

   489         }

   490     }

   491 

   492 EXPORT_C void CPbkContactViewListControl::HandleMarkableListProcessCommandL

   493         (TInt aCommandId)

   494     {

   495     AknSelectionService::HandleMarkableListProcessCommandL

   496         (aCommandId, &ListBox());

   497     }

   498 

   499 EXPORT_C void CPbkContactViewListControl::HandleMarkableListDynInitMenuPane

   500         (TInt aResourceId,

   501         CEikMenuPane *aMenu)

   502     {

   503     AknSelectionService::HandleMarkableListDynInitMenuPane

   504         (aResourceId, aMenu, &ListBox());

   505     }

   506 

   507 EXPORT_C void

   508     CPbkContactViewListControl::HandleMarkableListUpdateAfterCommandExecution()

   509     {

   510     AknSelectionService::HandleMarkableListUpdateAfterCommandExecution

   511         (&ListBox());

   512     }

   513 

   514 EXPORT_C const TDesC& CPbkContactViewListControl::FindTextL() const

   515     {

   516     // Initial minimum size for the find text buffer

   517     const TInt KInitialBufSize = 8;

   518 

   519     if (iFindBox)

   520         {

   521         const TInt findBoxTextLength = iFindBox->TextLength();

   522         if (findBoxTextLength > 0)

   523             {

   524             TInt bufCapacity = 0;

   525             if (iFindTextBuf)

   526                 {

   527                 bufCapacity = iFindTextBuf->Des().MaxLength();

   528                 }

   529             if (bufCapacity < findBoxTextLength)

   530                 {

   531                 // Allocate a new buffer of at least KInitialBufSize

   532                 // characters or twice as large as the previous one

   533                 const TInt newBufSize = Max(Max(KInitialBufSize,2*bufCapacity),

   534                     findBoxTextLength);

   535                 HBufC* newBuf = HBufC::NewL(newBufSize);

   536                 delete iFindTextBuf;

   537                 iFindTextBuf = newBuf;

   538                 }

   539             TPtr bufPtr = iFindTextBuf->Des();

   540             __ASSERT_DEBUG

   541                 (bufPtr.MaxLength()>=KInitialBufSize && bufPtr.MaxLength()>=findBoxTextLength,

   542                 Panic(EPanicLogic_FindTextL));

   543             iFindBox->GetSearchText(bufPtr);

   544             // Strip from search string all unwanted characters that e.g. Hindi input places there

   545             for( TInt i = bufPtr.Length()-1; i >= 0; --i )

   546                 {

   547                 if (!IsSearchableChar(bufPtr[i]))

   548                     {

   549                     bufPtr.Delete( i, 1 );

   550                     }

   551                 }

   552             return(*iFindTextBuf);

   553             }

   554         }

   555     return KNullDesC;

   556     }

   557 

   558 EXPORT_C void CPbkContactViewListControl::ResetFindL()

   559     {

   560     if (iFindBox && iFindBox->TextLength() > 0)

   561         {

   562         iFindBox->ResetL();

   563         UpdateFindResultL();

   564         iFindBox->DrawDeferred();

   565         }

   566     }

   567 

   568 EXPORT_C TBool CPbkContactViewListControl::ItemMarked(TInt aIndex) const

   569     {

   570     const CListBoxView::CSelectionIndexArray* selections =

   571         ListBox().View()->SelectionIndexes();

   572     return (selections ? Find(*selections,aIndex)!=KErrNotFound : EFalse);

   573     }

   574 

   575 EXPORT_C TInt CPbkContactViewListControl::NextUnmarkedIndexFromFocus() const

   576     {

   577     const TInt focus = ListBox().CurrentItemIndex();

   578     TInt index = focus;

   579     const CListBoxView::CSelectionIndexArray* selections =

   580         ListBox().SelectionIndexes();

   581     if (selections && selections->Count() > 0)

   582         {

   583         const TInt count = iListBox->Model()->NumberOfItems();

   584         for (index = focus; index < count; ++index)

   585             {

   586             if (Find(*selections,index) == KErrNotFound)

   587                 {

   588                 return index;

   589                 }

   590             }

   591         for (index = focus; index >= 0; --index)

   592             {

   593             if (Find(*selections,index) == KErrNotFound)

   594                 {

   595                 return index;

   596                 }

   597             }

   598         }

   599     return index;

   600     }

   601 

   602 EXPORT_C void CPbkContactViewListControl::MarkItemL

   603         (TContactItemId aContactId,

   604         TBool aMark)

   605     {

   606     const TInt index = FindContactIdL(aContactId);

   607     if (index >= 0)

   608         {

   609         if (aMark)

   610             {

   611             ListBox().View()->SelectItemL(index);

   612             }

   613         else

   614             {

   615             ListBox().View()->DeselectItem(index);

   616             }

   617         }

   618     }

   619 

   620 EXPORT_C void CPbkContactViewListControl::ClearMarks()

   621     {

   622     if (ItemsMarked())

   623         {

   624         CListBoxView& listBoxView = *ListBox().View();

   625         listBoxView.SetDisableRedraw(ETrue);

   626         ListBox().ClearSelection();

   627         listBoxView.SetDisableRedraw(EFalse);

   628         Redraw();

   629         }

   630     }

   631 

   632 EXPORT_C CPbkViewState* CPbkContactViewListControl::GetStateL

   633         (TBool aSaveMarks/*=ETrue*/) const

   634     {

   635     CPbkViewState* state = GetStateLC(aSaveMarks);

   636     CleanupStack::Pop();  // state

   637     return state;

   638     }

   639 

   640 EXPORT_C CPbkViewState* CPbkContactViewListControl::GetStateLC

   641         (TBool aSaveMarks/*=ETrue*/) const

   642     {

   643     // Create a state object

   644     CPbkViewState* state = CPbkViewState::NewLC();

   645 

   646     // Init the state object

   647     if (NumberOfItems() > 0)

   648         {

   649         TInt index;

   650         if ((index = ListBox().TopItemIndex()) >= 0)

   651             {

   652             state->SetTopContactId(ContactIdAtL(index));

   653             }

   654         if ((index = ListBox().CurrentItemIndex()) >= 0)

   655             {

   656             state->SetFocusedContactId(ContactIdAtL(index));

   657             }

   658         if (aSaveMarks && ItemsMarked())

   659             {

   660             state->SetMarkedContactIds(CContactIdArray::NewL(&MarkedItemsL()));

   661             }

   662         }

   663 

   664     // Return the state object

   665     return state;

   666     }

   667 

   668 EXPORT_C void CPbkContactViewListControl::RestoreStateL(const CPbkViewState* aState)

   669     {

   670     PBK_DEBUG_PRINT(

   671         PBK_DEBUG_STRING("CPbkContactViewListControl::RestoreStateL(0x%x,0x%x)"),

   672         this, aState);

   673 

   674     if (!aState || !iStateFlags.IsSet(EReady))

   675         {

   676         return;

   677         }

   678 

   679     CEikColumnListBox& listBox = ListBox();

   680     TBool redraw = EFalse;

   681     if (aState->Flags() & CPbkViewState::EInitialized)

   682         {

   683         // Find box is recreated because default input language needs to

   684         // be reset here if Always on feature is enabled for Phonebook

   685         delete iFindBox;

   686         iFindBox=NULL;

   687 

   688         // Do not enable the find box if there does not exist any contacts

   689         if (iBaseView->CountL() > 0)

   690             {

   691             EnableFindBoxL();

   692             }

   693 

   694         listBox.Reset();

   695         redraw = ETrue;

   696         }

   697     else

   698         {

   699         if (iBaseView->CountL() > 0)

   700             {

   701             if (aState->Flags() & CPbkViewState::EFocusFirst)

   702                 {

   703                 listBox.SetTopItemIndex(0);

   704                 }

   705             else if (aState->Flags() & CPbkViewState::EFocusLast)

   706                 {

   707                 listBox.SetCurrentItemIndex(listBox.Model()->NumberOfItems());

   708                 }

   709             else

   710                 {

   711                 // Restore top item

   712                 if (aState->TopContactId() != KNullContactId)

   713                     {

   714                     const TInt index = FindContactIdL(aState->TopContactId());

   715                     if (index >= 0)

   716                         {

   717                         const TInt prevIndex = listBox.TopItemIndex();

   718                         listBox.SetTopItemIndex(index);

   719                         FixTopItemIndex();

   720                         if (index != prevIndex)

   721                             {

   722                             redraw = ETrue;

   723                             }

   724                         }

   725                     }

   726 

   727                 // Restore focus

   728                 if (aState->FocusedContactId() != KNullContactId)

   729                     {

   730                     const TInt index = FindContactIdL(aState->FocusedContactId());

   731                     if (index >= 0)

   732                         {

   733                         const TInt prevIndex = listBox.CurrentItemIndex();

   734                         listBox.SetCurrentItemIndex(index);

   735                         if (index != prevIndex)

   736                             {

   737                             redraw = ETrue;

   738                             }

   739                         }

   740                     }

   741 

   742                 }

   743             // Restore selections

   744             const CContactIdArray* markedContactIds = aState->MarkedContactIds();

   745             if (RestoreMarkedItemsL(markedContactIds))

   746                 {

   747                 redraw = ETrue;

   748                 }

   749             }

   750         }

   751 

   752     if (redraw)

   753         {

   754         Redraw();

   755         iListBox->UpdateScrollBarsL();

   756         HandleFocusChange();

   757         }

   758     }

   759 

   760 void CPbkContactViewListControl::ShowThumbnail(TContactItemId aContactId)

   761     {

   762     if (!iThumbnailPopup && iEngine)

   763         {

   764         TRAP_IGNORE(iThumbnailPopup = CPbkThumbnailPopup::NewL( *iEngine ));

   765         }

   766 

   767     if (iThumbnailPopup && aContactId!=KNullContactId  && IsReadyToDraw() &&

   768         !iStateFlags.IsSet(EBlank))

   769         {

   770         iThumbnailPopup->Load(aContactId, iListBox);

   771         }

   772     else if (iThumbnailPopup)

   773         {

   774         iThumbnailPopup->CancelLoading();

   775         }

   776     }

   777 

   778 EXPORT_C void CPbkContactViewListControl::ShowThumbnailL()

   779     {

   780     if (!iThumbnailPopup && iEngine)

   781         {

   782         iThumbnailPopup = CPbkThumbnailPopup::NewL( *iEngine );

   783         }

   784 

   785     if (iLastFocusId!=KNullContactId  && IsReadyToDraw() &&

   786         !iStateFlags.IsSet(EBlank))

   787         {

   788         iThumbnailPopup->Load(iLastFocusId, iListBox);

   789         }

   790     else

   791         {

   792         iThumbnailPopup->CancelLoading();

   793         }

   794     }

   795 

   796 EXPORT_C void CPbkContactViewListControl::HideThumbnail()

   797     {

   798     if (iThumbnailPopup)

   799         {

   800         iThumbnailPopup->CancelLoading();

   801         }

   802     }

   803 

   804 EXPORT_C void CPbkContactViewListControl::AddObserverL

   805         (MPbkContactViewListControlObserver& aObserver)

   806     {

   807     User::LeaveIfError(iObservers.Append(&aObserver));

   808     }

   809 

   810 EXPORT_C void CPbkContactViewListControl::RemoveObserver

   811         (MPbkContactViewListControlObserver& aObserver)

   812     {

   813     const TInt index = iObservers.Find(&aObserver);

   814     if (index >= 0)

   815         {

   816         iObservers.Remove(index);

   817         }

   818     }

   819 

   820 EXPORT_C TBool CPbkContactViewListControl::IsReady() const

   821     {

   822     return (iStateFlags.IsSet(EReady));

   823     }

   824 

   825 void CPbkContactViewListControl::SetDisableRedraw(TBool aDisableRedraw)

   826     {

   827     ListBox().View()->SetDisableRedraw(aDisableRedraw);

   828     }

   829 

   830 void CPbkContactViewListControl::DisableRedrawEnablePushL()

   831     {

   832     CListBoxView& listBoxView = *ListBox().View();

   833     listBoxView.SetDisableRedraw(ETrue);

   834     CleanupStack::PushL(TCleanupEnableListBoxViewRedraw(listBoxView));

   835     }

   836 

   837 EXPORT_C void CPbkContactViewListControl::SetBlank(TBool aBlank)

   838     {

   839     PBK_DEBUG_PRINT(PBK_DEBUG_STRING

   840         ("CPbkContactViewListControl::SetBlank(0x%x,%d)"),this,aBlank);

   841 

   842     if ((iStateFlags.IsSet(EBlank) && aBlank) ||

   843         (!iStateFlags.IsSet(EBlank) && !aBlank))

   844         {

   845         // No change in state

   846         return;

   847         }

   848 

   849     // Set the EBlank flag

   850     iStateFlags.Assign(EBlank,aBlank);

   851 

   852     // Hide/unhide component controls

   853     MakeComponentsVisible(!aBlank);

   854     Redraw();

   855     }

   856 

   857 EXPORT_C void CPbkContactViewListControl::SetEntryLoader

   858         (MPbkContactEntryLoader& aContactEntryLoader)

   859     {

   860     Model().SetEntryLoader(aContactEntryLoader);

   861     }

   862 

   863 

   864 void CPbkContactViewListControl::SetSelectionAccepter(MPbkFetchDlgSelection* aAccepter)

   865     {

   866     iSelectionAccepter = aAccepter;

   867     }

   868 

   869 TInt CPbkContactViewListControl::NumberOfItems() const

   870     {

   871     return ListBox().Model()->NumberOfItems();

   872     }

   873 

   874 TBool CPbkContactViewListControl::ItemsMarked() const

   875     {

   876     const CListBoxView::CSelectionIndexArray* selections =

   877         ListBox().View()->SelectionIndexes();

   878     return (selections && selections->Count()>0);

   879     }

   880 

   881 const CContactIdArray& CPbkContactViewListControl::MarkedItemsL() const

   882     {

   883     if (!iMarkedItemsArray)

   884         {

   885         iMarkedItemsArray = CContactIdArray::NewL();

   886         }

   887 

   888     // Remove old contents of array (use Remove instead of Reset to keep the

   889     // array buffer)

   890     iMarkedItemsArray->Remove(0,iMarkedItemsArray->Count());

   891 

   892     // Get the list boxes marked items index array

   893     const CListBoxView::CSelectionIndexArray* selArray =

   894         ListBox().SelectionIndexes();

   895 

   896     if (selArray && selArray->Count() > 0)

   897         {

   898         // Initialize the marked contact id array using selArray

   899         CContactViewBase::TVirtualFunction1Params params

   900             (selArray, iMarkedItemsArray);

   901 

   902         iView->CContactViewBase_Reserved_1

   903             (CContactViewBase::ECContactViewBaseVirtualFunction1, &params);

   904         }

   905     else

   906         {

   907         // No items marked, add the focused contact to the array

   908         iMarkedItemsArray->AddL(FocusedContactIdL());

   909         }

   910 

   911     return *iMarkedItemsArray;

   912     }

   913 

   914 TContactItemId CPbkContactViewListControl::FocusedContactIdL() const

   915     {

   916     TContactItemId retId(KNullContactId);

   917 

   918     const TInt focusIndex = ListBox().CurrentItemIndex();

   919     if (focusIndex >= 0)

   920         {

   921         retId = iView->AtL(focusIndex);

   922         }

   923     return retId;

   924     }

   925 

   926 const TPbkContactItemField* CPbkContactViewListControl::FocusedField() const

   927     {

   928     // This control does not support field level focus

   929     return NULL;

   930     }

   931 

   932 MObjectProvider* CPbkContactViewListControl::ObjectProvider()

   933     {

   934     return this;

   935     }

   936 

   937 TKeyResponse CPbkContactViewListControl::OfferKeyEventL

   938         (const TKeyEvent& aKeyEvent,TEventCode aType)

   939     {

   940     if (!iStateFlags.IsSet(EReady) || iStateFlags.IsSet(EBlank))

   941         {

   942         // Don't handle any keys when not ready or blanked

   943         return EKeyWasNotConsumed;

   944         }

   945 

   946     TKeyResponse result = EKeyWasNotConsumed;

   947 

   948     if (iFindBox)

   949         {

   950         // Find box is active, offer key first to it

   951         result = iFindBox->OfferKeyEventL(aKeyEvent, aType);

   952         }

   953 

   954     if (result == EKeyWasNotConsumed && iListBox)

   955         {

   956         // Find box didn't consume the event -> offer it to the list box

   957         const TInt focusIndex = iListBox->CurrentItemIndex();

   958         const TBool markedBefore = ItemMarked(focusIndex);

   959 

   960         // If selection key was pressed and the focused contact was earlier

   961         // unselected, then first check from selection accepter if this item

   962         // can be selected

   963         // Also do the acception-check if there are no selected items and

   964         // OK-softkey was pressed (causing focused item to be selected and

   965         // closing the dialog

   966         TBool checkSelection = EFalse;

   967         const CListBoxView::CSelectionIndexArray* selArray =

   968                 ListBox().SelectionIndexes();

   969         

   970         

   971         const TInt selectionKeyPressed(aKeyEvent.iCode == EKeyDevice3);

   972         

   973         // AVKON may create EKeyApplicationF key event 

   974         // when list item is selected.

   975         const TInt avkonSelectionKeyNotification(

   976                         aKeyEvent.iCode == EKeyApplicationF);

   977                         

   978         const TBool noSelectionMade(!selArray||selArray->Count() == 0 );

   979         

   980         const TBool validNewFocusedItem(

   981                         !markedBefore && focusIndex >= KErrNone);

   982 

   983         if ((selectionKeyPressed || (avkonSelectionKeyNotification && noSelectionMade))

   984             && validNewFocusedItem)

   985             {

   986             checkSelection = ETrue;

   987             }

   988         

   989         const CListBoxView::CSelectionIndexArray* selections =

   990             ListBox().SelectionIndexes();

   991         TInt selCount = selections ? selections->Count() : 0;

   992         

   993         if (!checkSelection || !iSelectionAccepter ||

   994             focusIndex != KErrNotFound &&

   995             iSelectionAccepter->ContactSelectionAcceptedL(

   996                 ContactIdAtL(focusIndex), selCount))

   997             {

   998             result = iListBox->OfferKeyEventL(aKeyEvent, aType);

   999 

  1000             if (result == EKeyWasConsumed)

  1001                 {

  1002                 const TBool markedAfter = ItemMarked(focusIndex);

  1003                 if (markedAfter != markedBefore)

  1004                     {

  1005                     TPbkContactViewListControlEvent

  1006                         event(TPbkContactViewListControlEvent::EContactSelected);

  1007                     event.iInt = focusIndex;

  1008                     event.iContactId = ContactIdAtL(focusIndex);

  1009                     if (!markedAfter)

  1010                         {

  1011                         event.iEventType =

  1012                             TPbkContactViewListControlEvent::EContactUnselected;

  1013                         }

  1014                     SendEventToObserversL(event);

  1015                     }                

  1016                 }

  1017             }

  1018         else

  1019             {

  1020             result = EKeyWasConsumed;

  1021             }

  1022         }

  1023     return result;

  1024     }

  1025 

  1026 void CPbkContactViewListControl::HandlePointerEventL(

  1027         const TPointerEvent& aPointerEvent )

  1028     {

  1029     if ( AknLayoutUtils::PenEnabled() )

  1030         {

  1031         if ( iFindBox )

  1032             {

  1033             iFindBox->HandlePointerEventL( aPointerEvent );

  1034             }

  1035 

  1036         if ( iListBox )

  1037             {

  1038             switch ( aPointerEvent.iType )

  1039                 {

  1040                 case TPointerEvent::EButton1Down:

  1041                     {

  1042                     iPrevIndex = iListBox->CurrentItemIndex();

  1043                     iListBox->HandlePointerEventL( aPointerEvent );

  1044                     break;

  1045                     }

  1046                 case TPointerEvent::EButton1Up:

  1047                     {

  1048                     TInt focusIndex;

  1049                     TBool focusableContactPointed =

  1050                         iListBox->View()->XYPosToItemIndex(

  1051                             aPointerEvent.iPosition, focusIndex );

  1052                     if (!focusableContactPointed || focusIndex < 0)

  1053                         {

  1054                         // Nothing special to do when tapping empty space

  1055                         iListBox->HandlePointerEventL( aPointerEvent );

  1056                         }

  1057                     else

  1058                         {

  1059                         // Send contact tap events                        

  1060                         TPbkContactViewListControlEvent event(

  1061                             TPbkContactViewListControlEvent::EContactTapped );

  1062                         event.iInt = focusIndex;

  1063                         event.iContactId = ContactIdAtL( focusIndex );

  1064                         if ( iPrevIndex == iListBox->CurrentItemIndex() )

  1065                             {

  1066                             event.iEventType =

  1067                                 TPbkContactViewListControlEvent::EContactDoubleTapped;

  1068                             }

  1069                         SendEventToObserversL( event );

  1070 

  1071                         // Do markings

  1072                         const TBool markedBefore = ItemMarked(focusIndex);

  1073                         const CListBoxView::CSelectionIndexArray* selections =

  1074                             ListBox().SelectionIndexes();

  1075                         TInt selCount = selections ? selections->Count() : 0;

  1076 

  1077                         if ( markedBefore ||         // can unmark always

  1078                              !iSelectionAccepter ||  // no select restrictions

  1079                              iSelectionAccepter->ContactSelectionAcceptedL(

  1080                                 ContactIdAtL(focusIndex), selCount) )

  1081                             {

  1082                             // Handle the pointer event to list box to fix the problem that items in multiple

  1083                             // fetch dialog can't be select with touch screen.

  1084                             iListBox->HandlePointerEventL( aPointerEvent );

  1085                             

  1086                             const TBool markedAfter = ItemMarked( focusIndex );

  1087                             if ( markedAfter != markedBefore )

  1088                                 {

  1089                                 event.iEventType =

  1090                                     TPbkContactViewListControlEvent::EContactSelected;

  1091                                 event.iInt = focusIndex;

  1092                                 event.iContactId = ContactIdAtL(focusIndex);

  1093                                 if (!markedAfter)

  1094                                     {

  1095                                     event.iEventType =

  1096                                         TPbkContactViewListControlEvent::EContactUnselected;

  1097                                     }

  1098                                 SendEventToObserversL(event);

  1099                                 }

  1100                             }

  1101                         }

  1102                     break;

  1103                     }

  1104                 default:

  1105                     {

  1106                     iListBox->HandlePointerEventL( aPointerEvent );

  1107                     }

  1108                 }

  1109             }

  1110         }

  1111     }

  1112 

  1113 void CPbkContactViewListControl::MakeVisible(TBool aVisible)

  1114     {

  1115     PBK_DEBUG_PRINT(

  1116         PBK_DEBUG_STRING("CPbkContactViewListControl::MakeVisible(0x%x,%d)"),

  1117         this, aVisible);

  1118 

  1119     CCoeControl::MakeVisible(aVisible);

  1120     MakeComponentsVisible(aVisible);

  1121     }

  1122 

  1123 void CPbkContactViewListControl::UpdateContact(TContactItemId aContactId)

  1124     {

  1125     TInt listBoxRow = -1;

  1126     TRAPD(err, listBoxRow = FindContactIdL(aContactId) );

  1127     if (err)

  1128         {

  1129         iEikonEnv->NotifyIdleErrorWhileRedrawing(err);

  1130         }

  1131     if (listBoxRow >= 0)

  1132         {

  1133         // if visible

  1134         if (listBoxRow >= ListBox().TopItemIndex() &&