diff -r 000000000000 -r 2f259fa3e83a uifw/AknGlobalUI/OldStyleNotif/Src/AknGroupedNotifierNote.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/AknGlobalUI/OldStyleNotif/Src/AknGroupedNotifierNote.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,466 @@ +/* +* Copyright (c) 2002-2007 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: +* +*/ + +#include "AknGroupedNotifierNote.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // KCoreAppUIsAutolockStatus + +#include "AknCapServerEntry.h" + +/// Maximum allocated space for custom softkeys. +const TInt KAknMaxCustomSoftkeyLength = 30; + +void CAknGroupedNotifierNote::ConstructL(MAknGroupedNotifierNoteObserver* aObserver) + { + iNoteObserver = aObserver; + iOrder = new(ELeave) CArrayFixFlat(4); + + iAutoLockStatus = EAutolockOff; + RProperty autolockProperty; + autolockProperty.Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, iAutoLockStatus); + } + +void CAknGroupedNotifierNote::ActivateL() + { + CEikDialog::ActivateL(); + } + +void CAknGroupedNotifierNote::PreLayoutDynInitL() + { + CAknListQueryDialog::PreLayoutDynInitL(); + iTexts = iCoeEnv->ReadDesCArrayResourceL(R_GROUPED_NOTIFIER_TEXTS); + if (iNoteObserver) + { + // Allow observer to add new texts + iNoteObserver->AddItemsL( *iTexts, *iOrder ); + } + + iTextsPlural = iCoeEnv->ReadDesCArrayResourceL(R_GROUPED_NOTIFIER_TEXTS_PLURAL); + SetItemTextArray(this); + SetOwnershipType(ELbmDoesNotOwnItemArray); + + CEikListBox* listbox = ListBox(); + if (listbox) + { + listbox->SetObserver(this); + } + +#ifdef RD_SCALABLE_UI_V2 + if ( AknLayoutUtils::PenEnabled() ) + { + SetGloballyCapturing(ETrue); + SetPointerCapture(ETrue); + } +#endif + } + +void CAknGroupedNotifierNote::PostLayoutDynInitL() + { + // A focused custom note might require different softkeys than the default ones. + UpdateSoftkeysL(); + } + +void CAknGroupedNotifierNote::ProcessCommandL(TInt aCommandId) + { + // Note about to complete, so signal the notifier + if (iNoteObserver) + { + // This should also inform the selected item to the observer! + iNoteObserver->GroupedNoteCompletedL(aCommandId); + } + TryExitL(aCommandId); + } + +CAknGroupedNotifierNote::CAknGroupedNotifierNote() + : CAknListQueryDialog(&iSelectedItem) + { + } + +CAknGroupedNotifierNote::~CAknGroupedNotifierNote() + { + delete iTexts; + delete iTextsPlural; + delete iOrder; + } + +void CAknGroupedNotifierNote::HandlePointerEventL( + const TPointerEvent& aPointerEvent + ) + { + if (!Rect().Contains(aPointerEvent.iPosition) && + aPointerEvent.iType == TPointerEvent::EButton1Down) + { + return; + } + + CAknListQueryDialog::HandlePointerEventL(aPointerEvent); + } + +TKeyResponse CAknGroupedNotifierNote::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + if (aType == EEventKey) + { + // Send number keys to phone app, and bring it for foreground + if ((aKeyEvent.iCode >= '0' && aKeyEvent.iCode <= '9') + || aKeyEvent.iCode == '#' + || aKeyEvent.iCode == '*') + { + if (aKeyEvent.iRepeats == 0) + { + MAknPhoneKeyForwarder* keyf = STATIC_CAST( + CAknCapAppServerAppUi*, CEikonEnv::Static()->AppUi())->AsKeyForwarder(); + + keyf->ForwardKeyToPhoneAppL(aKeyEvent); + iNoteObserver->GroupedNoteCompletedL(KErrCancel); + delete this; + } + return EKeyWasConsumed; + } + } + + if (aKeyEvent.iCode == EKeyEscape) + { + // Workaround the current problem where the SecUI sends an EKeyEscape + // to the control stack when it wants to remove it's own dialog + return EKeyWasNotConsumed; + } + + return CAknListQueryDialog::OfferKeyEventL(aKeyEvent, aType); + } + +TBool CAknGroupedNotifierNote::OkToExitL(TInt aButtonId) + { + // Generic method used to find out whether the command belongs to "cancel" commands. + TInt mappedCommandId = MappedCommandId(aButtonId); + + TNoteAction noteAction = EDoNothing; + + if (mappedCommandId == EEikBidCancel || + mappedCommandId == EAknSoftkeyExit || + mappedCommandId == EAknSoftkeyCancel || + mappedCommandId == EAknSoftkeyBack || + mappedCommandId == EAknSoftkeyNo || + mappedCommandId == EAknSoftkeyClose || + mappedCommandId == EAknSoftkeyQuit || + mappedCommandId == EAknSoftkeyDone) + { + // The command is a cancelling command. + noteAction = EExitNote; + } + else if (iCustomNoteAcceptKeyId) + { + // The grouped note item is a custom item. Check whether the command + // is the accept key defined for that custom item. + if (mappedCommandId == iCustomNoteAcceptKeyId || mappedCommandId == EAknSoftkeyOk) + { + noteAction = ELaunchItemHandler; + } + } + else + { + // The grouped note item is not a custom item. Only "Show" or "Ok" commands + // are used to launch the note. + if (mappedCommandId == EAknSoftkeyShow || mappedCommandId == EAknSoftkeyOk) + { + noteAction = ELaunchItemHandler; + } + } + + // Now make the action... + + if (noteAction == ELaunchItemHandler) + { + TInt itemindex = ListBox()->CurrentItemIndex(); + __ASSERT_DEBUG(itemindex != -1, Panic(EAknPanicOutOfRange)); + +#ifdef RD_SCALABLE_UI_V2 + if (AknLayoutUtils::PenEnabled()) + { + SetGloballyCapturing(EFalse); + SetPointerCapture(EFalse); + } +#endif + + if (itemindex == -1) + { + iNoteObserver->GroupedNoteCompletedL(EAknSoftkeyExit, EMaxItem); + return ETrue; + } + + // Use always Ok command. + iNoteObserver->GroupedNoteCompletedL( + EAknSoftkeyOk, + TAknGroupedNotifierItem(iOrder->At(itemindex))); + + return ETrue; + } + else if (noteAction == EExitNote) + { +#ifdef RD_SCALABLE_UI_V2 + if (AknLayoutUtils::PenEnabled()) + { + SetGloballyCapturing(EFalse); + SetPointerCapture(EFalse); + } +#endif + // Use always Exit command. + iNoteObserver->GroupedNoteCompletedL(EAknSoftkeyExit, EMaxItem); + return ETrue; + } + + else + { + // Unknown command, do nothing. + return EFalse; + } + } + +void CAknGroupedNotifierNote::SetItemAmountL(TAknGroupedNotifierItem aItem, TInt aAmount, + TBool aHighlight) + { + TInt arrayIndex = aItem - EMissedCalls; + TBool isDynamicText(EFalse); + + if (arrayIndex >= 0 && arrayIndex < EMaxItem) // traditional types + { + iCount[arrayIndex] = aAmount; + } + else + { + arrayIndex = aItem; + isDynamicText = ETrue; + } + + TKeyArrayFix key(0,ECmpTInt); + TInt item; + if (iOrder->Find(arrayIndex, key, item) == 0) + { + iOrder->Delete(item); + if (isDynamicText) + { // if it is in iOrder, it is also in iTexts + iTexts->Delete(item); + return; // only deletion of item is allowed in this method. + } + } + + if (aAmount > 0) + { + iOrder->AppendL(arrayIndex); + } + + if (aHighlight) + { + if (aAmount) + { + iHighlightedItem = iOrder->Count() - 1; + } + else + { + iHighlightedItem = 0; + } + } + } + + +TInt CAknGroupedNotifierNote::MdcaCount() const + { + return iOrder->Count(); + } + +TPtrC CAknGroupedNotifierNote::MdcaPoint(TInt aIndex) const + { + // can I play with constness ;) + TDes &des = MUTABLE_CAST(TBuf&, iBuffer); + des.Zero(); + TPtrC listItemText; + TInt numOfItems = 0; + + TInt itemType = iOrder->At(aIndex); + + if (itemType >= 0 && itemType < EMaxItem) // traditional types + { + numOfItems = iCount[itemType]; + + __ASSERT_DEBUG(numOfItems > 0, Panic(EAknPanicOutOfRange)); + // choose the item to show + if (numOfItems == 1) + { + listItemText.Set(iTexts->MdcaPoint(itemType)); + } + else + { + listItemText.Set(iTextsPlural->MdcaPoint(itemType)); + } + } + else // "Dynamic" texts + { + // count text index + for (TInt i = 0; i < EMaxItem; i++) + { + if (iCount[i] > 0) // static text in iOrder + { + aIndex--; + } + } + + aIndex += EMaxItem; // jump over static texts + + __ASSERT_ALWAYS(aIndex >= 0, User::Invariant()); + listItemText.Set(iTexts->MdcaPoint(aIndex)); + } + + // replace %N with the number + _LIT(KNumber,"%N"); + TInt pos = listItemText.Find(KNumber); + + if (pos != KErrNotFound) + { + StringLoader::Format(des, listItemText, -1, numOfItems); + } + else + { + des.Append(listItemText.Left(KAknMaxGroupedNoteItemTextLength)); + } + + // return result + return iBuffer; + } + +TBool CAknGroupedNotifierNote::AutoLockEnabled() + { + return EFalse; + } + +void CAknGroupedNotifierNote::CEikDialog_Reserved_1() + { + } + +void CAknGroupedNotifierNote::CEikDialog_Reserved_2() + { + } + +void CAknGroupedNotifierNote::CAknDialog_Reserved() + { + } + +void CAknGroupedNotifierNote::CAknQueryDialog_Reserved() + { + } + +void CAknGroupedNotifierNote::HandleControlEventL(CCoeControl* aControl, TCoeEvent aEventType) + { + if (aEventType == EEventStateChanged) + { + // Focused item has changed, softkeys might require updating. + UpdateSoftkeysL(); + } + + CAknListQueryDialog::HandleControlEventL(aControl, aEventType); + } + +void CAknGroupedNotifierNote::UpdateSoftkeysL() + { + CEikListBox* listbox = ListBox(); + if (listbox) + { + // Get the focused item and check that it is in valid range. + TInt itemindex = listbox->CurrentItemIndex(); + __ASSERT_DEBUG(itemindex >= 0 && itemindex < MdcaCount(), Panic(EAknPanicOutOfRange)); + + if (itemindex >= 0 && itemindex < MdcaCount()) + { + // If the focused item is a custom note, this method returns its resource id. + TAknGroupedNotifierItem item = TAknGroupedNotifierItem(iOrder->At(itemindex)); + + HBufC* leftSK = HBufC::NewLC( KAknMaxCustomSoftkeyLength ); + HBufC* rightSK = HBufC::NewLC( KAknMaxCustomSoftkeyLength ); + + TInt newSoftkeys = 0; + if (item > EMaxItem || item < 0) + { + // Note is out of "static" range, i.e. a custom note. + TPtr left( leftSK->Des() ); + TPtr right( rightSK->Des() ); + iNoteObserver->SoftkeysForCustomItem(item, newSoftkeys, + iCustomNoteAcceptKeyId, left, right ); + } + + if (!newSoftkeys) + { + newSoftkeys = R_AVKON_SOFTKEYS_SHOW_EXIT__SHOW; + iCustomNoteAcceptKeyId = 0; + } + + // Update softkeys only if necessary. + if( newSoftkeys != iCustomNoteSoftkeys || + iCustomNoteSoftkeysAssigned || // custom text was used (force update) + leftSK->Length() > 0 || + rightSK->Length() > 0 ) + { + CEikButtonGroupContainer& buttonGroup = ButtonGroupContainer(); + buttonGroup.SetCommandSetL(newSoftkeys); + buttonGroup.DrawDeferred(); + iCustomNoteSoftkeys = newSoftkeys; + + iCustomNoteSoftkeysAssigned = EFalse; + MEikButtonGroup* buttonGrp = buttonGroup.ButtonGroup(); + if( buttonGrp ) + { + if( leftSK->Length() > 0 ) + { + buttonGroup.SetCommandL( buttonGrp->CommandId( + CEikButtonGroupContainer::ELeftSoftkeyPosition ), + *leftSK ); + iCustomNoteSoftkeysAssigned = ETrue; + } + if( rightSK->Length() > 0 ) + { + buttonGroup.SetCommandL( buttonGrp->CommandId( + CEikButtonGroupContainer::ERightSoftkeyPosition ), + *rightSK ); + iCustomNoteSoftkeysAssigned = ETrue; + } + } + } + CleanupStack::PopAndDestroy( 2, leftSK ); // rightSK + } + } + + // If we are going to display the grouped list notification on the top of Autolock App, + // So we need to invisible the softkey buttons. + if (AknLayoutUtils::PenEnabled() && iAutoLockStatus > EAutolockOff) + { + CEikButtonGroupContainer& bgc = ButtonGroupContainer(); + MEikButtonGroup* buttonGrp = bgc.ButtonGroup(); + if (buttonGrp) + { + bgc.SetCommandL(buttonGrp->CommandId(CEikButtonGroupContainer::ELeftSoftkeyPosition), KNullDesC); + bgc.SetCommandL(buttonGrp->CommandId(CEikButtonGroupContainer::ERightSoftkeyPosition), KNullDesC); + } + } + } + +// End of file