diff -r 000000000000 -r e686773b3f54 phonebookui/Phonebook/View/src/CPbkSingleItemFetchDlg.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phonebookui/Phonebook/View/src/CPbkSingleItemFetchDlg.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,326 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Provides methods for Phonebook Single Item Fetch API. +* +*/ + + +// INCLUDE FILES +#include "CPbkSingleItemFetchDlg.h" // This class + +#include +#include + +#include +#include "CPbkFetchDlg.h" +#include "MPbkFetchCallbacks.h" +#include "CPbkSelectFieldDlg.h" + +#include +#include +#include + +// Unnamed namespace for local definitions +namespace { + +// LOCAL CONSTANTS AND MACROS +#ifdef _DEBUG +enum TPanicCode + { + EPanicPostCond_Constructor = 1, + EPanicPreCond_ConstructL, + EPanicPreCond_ExecuteLD + }; + +void Panic(TPanicCode aReason) + { + _LIT(KPanicText, "CPbkSingleItemFetchDlg"); + User::Panic(KPanicText, aReason); + } +#endif // _DEBUG + +CPbkFieldArray* CreateFieldArrayLC + (const CPbkContactItem& aItem, const CPbkFieldIdArray* aFieldIds) + { + CPbkFieldArray* fieldArray = new(ELeave) CPbkFieldArray; + CleanupStack::PushL(fieldArray); + const TInt count = aItem.CardFields().Count(); + for (TInt i=0; i < count; ++i) + { + const TPbkContactItemField& field = aItem.CardFields()[i]; + // Add only nonempty fields + if (!field.IsEmptyOrAllSpaces()) + { + if (!aFieldIds) + { + // add all nonempty fields if no field type filter is given + fieldArray->AppendL(field); + } + else + { + // Check that field's type matches with selectable types + if (aFieldIds->Contains(field.FieldInfo().FieldId())) + { + fieldArray->AppendL(field); + } + } + } + } + return fieldArray; + } + +} // namespace + + +// MODULE DATA STRUCTURES + +/** + * MPbkFetchDlgAccept implementation for CPbkSingleItemFetchDlg. + */ +NONSHARABLE_CLASS(CPbkSingleItemFetchDlg::TFetchCallback) : + public MPbkFetchDlgAccept + { + public: // constructor + inline TFetchCallback(CPbkSingleItemFetchDlg& aFetchDlg) + : iFetchDlg(aFetchDlg) + { + }; + + public: // from MPbkFetchEntryDlgAccept + /** + * called by CPbkFetchEntryDlg when selection is made. + * @param aId The focused contact entry + * @param aMarkedEntries The marked contact entries + * @return ETrue to close CPbkFetchEntryDlg, + * EFalse to keep open. + */ + TPbkFetchAccepted PbkFetchAcceptedL + (TContactItemId aId, CContactIdArray* aMarkedEntries); + + private: + /// Ref: to parent + CPbkSingleItemFetchDlg& iFetchDlg; + }; + + +// ================= MEMBER FUNCTIONS ======================= + +// CPbkSingleItemFetchDlg::TFetchCallback +MPbkFetchDlgAccept::TPbkFetchAccepted CPbkSingleItemFetchDlg::TFetchCallback::PbkFetchAcceptedL + (TContactItemId aId, CContactIdArray* /*aMarkedEntries*/) + { + if (iFetchDlg.EntryFetchAcceptedL(aId)) + { + return KFetchYes; + } + return KFetchNo; + } + +// CPbkSingleItemFetchDlg::TParams +EXPORT_C CPbkSingleItemFetchDlg::TParams::TParams() : + iContactView(NULL), + iFieldIdArray(NULL), + iContactItem(NULL), + iContactItemField(NULL), + iCbaId(0) + { + } + +EXPORT_C CPbkSingleItemFetchDlg::TParams::operator TCleanupItem() + { + return TCleanupItem(Cleanup,this); + } + +void CPbkSingleItemFetchDlg::TParams::Cleanup(TAny* aSelf) + { + TParams* self = static_cast(aSelf); + delete self->iContactItem; + self->iContactItem = NULL; + self->iContactItemField = NULL; + } + +// CPbkSingleItemFetchDlg +inline CPbkSingleItemFetchDlg::CPbkSingleItemFetchDlg + (TParams& aParams, + CPbkContactEngine& aEngine) : + iParams(aParams), + iContactView(aParams.iContactView), + iPbkEngine(aEngine) + { + // PostCond + __ASSERT_DEBUG(!iFetchDlg && !iDestroyedPtr, Panic(EPanicPostCond_Constructor)); + } + +inline void CPbkSingleItemFetchDlg::ConstructL() + { + // PreCond + __ASSERT_DEBUG(!iFetchDlg && !iDestroyedPtr, Panic(EPanicPreCond_ConstructL)); + + // Set up contact array if needed + if (!iContactView) + { + iContactView = &iPbkEngine.AllContactsView(); + } + } + +EXPORT_C CPbkSingleItemFetchDlg* CPbkSingleItemFetchDlg::NewL + (TParams& aParams, CPbkContactEngine& aEngine) + { + CPbkSingleItemFetchDlg* self = new(ELeave) CPbkSingleItemFetchDlg(aParams, aEngine); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); // self + return self; + } + +EXPORT_C void CPbkSingleItemFetchDlg::SetMopParent(MObjectProvider* aParent) + { + iObjectProvider = aParent; + } + +EXPORT_C TInt CPbkSingleItemFetchDlg::ExecuteLD() + { + // PreCond + __ASSERT_DEBUG(iContactView, Panic(EPanicPreCond_ExecuteLD)); + + // "D" function semantics + CleanupStack::PushL(this); + TBool thisDestroyed = EFalse; + // Destructor sets thisDestroyed to ETrue + iDestroyedPtr = &thisDestroyed; + + // Convert aParams for CPbkFetchDlg + CPbkFetchDlg::TParams params; + params.iResId = R_PBK_SINGLE_ENTRY_FETCH_DLG; + params.iFlags = CPbkFetchDlg::FETCH_FOCUSED; + params.iContactView = iContactView; + params.iMarkedEntries = NULL; + TFetchCallback callback(*this); + params.iAcceptCallback = &callback; + params.iCbaId = iParams.iCbaId; + + iFetchDlg = CPbkFetchDlg::NewL(params, iPbkEngine); + iFetchDlg->ResetWhenDestroyed(&iFetchDlg); + iFetchDlg->SetMopParent(iObjectProvider); + TInt result = iFetchDlg->ExecuteLD(); + + if (thisDestroyed) + { + // this object was destroyed + result = 0; + CleanupStack::Pop(this); + } + else + { + if (result) + { + // Switch ownership of result objects to iParams + iParams.iContactItem = iContactItem; + iContactItem = NULL; + iParams.iContactItemField = iContactItemField; + iContactItemField = NULL; + } + CleanupStack::PopAndDestroy(this); + } + + return result; + } + +TBool CPbkSingleItemFetchDlg::EntryFetchAcceptedL + (TContactItemId aCid) + { + TBool thisDestroyed = EFalse; + TBool* prevDestroyedPtr = iDestroyedPtr; + iDestroyedPtr = &thisDestroyed; + + CPbkContactItem* item = iPbkEngine.ReadContactLC(aCid); + + // create array of fields + CPbkFieldArray* fieldArray = + CreateFieldArrayLC(*item, iParams.iFieldIdArray); + + TPbkContactItemField* field = NULL; + + if ( fieldArray->Count() != 1 ) + { + HBufC* heading = StringLoader::LoadLC(R_QTN_PHOB_QTL_SELECT_ONE_ITEM); + + iFieldDlg = new(ELeave) CPbkSelectFieldDlg; + iFieldDlg->ResetWhenDestroyed(&iFieldDlg); + TInt cbaResourceId( R_AVKON_SOFTKEYS_SELECT_CANCEL__SELECT ); + if ( fieldArray->Count() == 0 ) + { + // If field selection is empty, only back soft button + // is available + cbaResourceId = R_AVKON_SOFTKEYS_BACK; + } + field = iFieldDlg->ExecuteLD(*fieldArray, + cbaResourceId, *heading); + CleanupStack::PopAndDestroy(heading); + } + else + { + // Only one field in the array, grab it! + field = &fieldArray->At(0); + } + + if (thisDestroyed) + { + // This must be enough to ensure that rest of the code in this + // function doesn't access member variables, this object has been + // destroyed, remember! + if (prevDestroyedPtr) *prevDestroyedPtr = ETrue; + field = NULL; + } + else + { + iDestroyedPtr = prevDestroyedPtr; + } + + if (field) + { + const TInt index = item->FindFieldIndex(*field); + TPbkContactItemField& itemField = item->CardFields()[index]; + CleanupStack::PopAndDestroy(fieldArray); + CleanupStack::Pop(item); + // Take ownership of item + iContactItem = item; + iContactItemField = &itemField; + } + else + { + CleanupStack::PopAndDestroy(2,item); + } + + return (field!=NULL); + } + +CPbkSingleItemFetchDlg::~CPbkSingleItemFetchDlg() + { + if (iDestroyedPtr) + { + *iDestroyedPtr = ETrue; + } + + // Close the dialogs + delete iFieldDlg; + delete iFetchDlg; + + // delete return values in case of cancel + delete iContactItem; + } + + +// End of File