diff -r 000000000000 -r eb1f2e154e89 fep/aknfep/UiPlugins/AknFepUiInterface/AvkonImpl/src/AknFepUiAvkonCtrlCandidatePane.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fep/aknfep/UiPlugins/AknFepUiInterface/AvkonImpl/src/AknFepUiAvkonCtrlCandidatePane.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,1172 @@ +/* +* Copyright (c) 2002-2004 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 the CAknFepUICtrlCandidatePane methods. +* +*/ + + + + + + + + + + + + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif +#include +#include +#include +#include +#include + +#include +#include "AknFepUiInterfacePanic.h" +#include "AknFepUIAvkonCtrlCandidatePane.h" +#include "AknFepUIAvkonCtrlCandidateSelected.h" +#include "aknfepchineseuidataconv.h" +#include "aknfepuilayoutdatamgr.h" + + +#include "data_caging_path_literals.hrh" + +const TInt CandidateCountLeft = 10; + +_LIT(KFepUiControlsBitmapFile, "aknfepuictrls.mbm"); + +CAknFepUICtrlCandidatePane* CAknFepUICtrlCandidatePane::NewL(RWindow& aParent, CAknFepUiLayoutDataMgr* aLafDataMgr) + { + CAknFepUICtrlCandidatePane* self = new(ELeave) CAknFepUICtrlCandidatePane( aLafDataMgr ); + CleanupStack::PushL(self); + self->ConstructL(aParent); + CleanupStack::Pop(); + return self; + } + +CAknFepUICtrlCandidatePane::~CAknFepUICtrlCandidatePane() + { + delete iCandidateSelected; + delete iNaviArrowBitmapLeft; + delete iNaviArrowBitmapLeftMask; + delete iNaviArrowBitmapRight; + delete iNaviArrowBitmapRightMask; + delete iNaviArrowBitmapUp; + delete iNaviArrowBitmapUpMask; + delete iNaviArrowBitmapDown; + delete iNaviArrowBitmapDownMask; + if(iCandidateArray) + { + iCandidateArray->Reset(); + delete iCandidateArray; + } + iCandidateLabelArray.ResetAndDestroy(); + iOrdinalLabelArray.ResetAndDestroy(); + iCandidateModeArray.Reset(); + iPages.Reset(); + } + +const TDesC& CAknFepUICtrlCandidatePane::TextBuffer() const + { + return iBuffer; + } + +void CAknFepUICtrlCandidatePane::SetCandidateBuffer(const TDesC& aBuffer) + { + TInt newLength = aBuffer.Length(); + TInt oldLength = iBuffer.Length(); + if(newLength > EMaxCandidates) + { + newLength = EMaxCandidates; + } + if(newLength - 1 < iSelected) + { + // as far as the client is concerned, they have removed the character that was selected + // therefore we must now hide the selected candidate, although the highlighting + // state remains unchanged + iCandidateSelected->MakeVisible(EFalse); + } + else + { + if(iHighlighted) + { + // make sure that the candidate is visible, as the selection is now + // within a visible range (it might have been hidden last time + // the buffer was set) + iCandidateSelected->MakeVisible(ETrue); + } + } + + TPtrC newText = aBuffer.Left(newLength); + TPtr ptr = iBuffer.Des(); + if(ptr != newText) + { + for(TInt i = 0; i < newLength; i++) + { + TBool valueChanged = ETrue; + TPtrC newChar = aBuffer.Mid(i, EOneCandidate); + if(i < oldLength) + { + TPtrC oldChar = iBuffer.Mid(i, EOneCandidate); + if(newChar == oldChar) + { + valueChanged = EFalse; + } + } + // only update and redraw label background if the value has changed + if(valueChanged) + { + // we have already allocated enough memory for this + CEikLabel* candidateLabel = iCandidateLabelArray[i]; + TRAP_IGNORE(candidateLabel->SetTextL(newChar)); + + // need to update the character if it is in the current selected candidate + if(i == iSelected) + { + iCandidateSelected->SetText(newChar); + iCandidateSelected->SetOrdinal(i + 1); + DrawDeferred(); + } + if(i < iVisibleCount) + { + // only redraw characters that are visible + TRect rect = candidateLabel->Rect(); + Window().Invalidate(rect); + } + } + } + ptr.Copy(newText); + LayoutLabels(); + LayoutCandidateSelected(); + iVisibleCount = newLength; + UpdateLabelVisibility(); + } + } + +CDesCArrayFlat* CAknFepUICtrlCandidatePane::CandidateArray(void) + { + return iCandidateArray; + } + +void CAknFepUICtrlCandidatePane::SetCandidateBuffer(void) + { + if(iPages.Count() == 0) + { + return; + } + TPage curPage = iPages[iCurDisplayPage]; + iVisibleCount = curPage.iEndIndex - curPage.iStartIndex + 1; + + if(iVisibleCount - 1 < iSelected) + { + iCandidateSelected->MakeVisible(EFalse); + } + else + { + if(iHighlighted) + { + iCandidateSelected->MakeVisible(ETrue); + } + } + + TBufC buf; + TPtr newText = buf.Des(); + + for(TInt i = 0; i < iVisibleCount; i ++) + { + CEikLabel* candidateLabel = iCandidateLabelArray[i]; + const TDesC* txtLabel = candidateLabel->Text(); + newText = (*iCandidateArray)[curPage.iStartIndex + i]; + + if((txtLabel->Compare(newText) != 0) ) + { + // we have already allocated enough memory for this + TRAP_IGNORE( candidateLabel->SetTextL(newText)); + } + + // need to update the character if it is in the current selected candidate + if(i == iSelected) + { + iCandidateSelected->SetText(newText); + iCandidateSelected->SetOrdinal(i + 1); + DrawDeferred(); + } + if(i < iVisibleCount) + { + // only redraw labels that are visible + TRect rect = candidateLabel->Rect(); + Window().Invalidate(rect); + } + } + LayoutLabels(); + LayoutCandidateSelected(); + DrawDeferred(); + UpdateLabelVisibility(); + } + +void CAknFepUICtrlCandidatePane::SetHighlighted(TBool aHighlighted) + { + if(!COMPARE_BOOLS(iHighlighted, aHighlighted)) + { + iHighlighted = aHighlighted; + iCandidateSelected->MakeVisible(aHighlighted); + + iCandidateSelected->DrawDeferred(); + } + } + +TBool CAknFepUICtrlCandidatePane::Highlighted() const + { + return iHighlighted; + } + +void CAknFepUICtrlCandidatePane::SetCandidateMode(TInt aIndex, TCandidateMode aMode) + { + __ASSERT_DEBUG(aIndex < EMaxCandidates, AknFepUiInterfacePanic(EAknFepUiInterfacePanicAttemptedSetModeOutsideMaxCandidates)); + __ASSERT_DEBUG(aIndex >= 0, AknFepUiInterfacePanic(EAknFepUiInterfacePanicAttemptedSetModeOutsideMaxCandidates)); + + TCandidateMode oldMode = iCandidateModeArray[aIndex]; + if(oldMode != aMode) + { + iCandidateModeArray[aIndex] = aMode; + if(iSelected == aIndex) + { + LayoutCandidateSelected(); + } + // only do drawing if visible + if(aIndex < iVisibleCount) + { + LayoutLabel(aIndex); + if(iSelected == aIndex && iHighlighted) + { + iCandidateSelected->DrawDeferred(); + } + else + { + CEikLabel* candidateLabel = iCandidateLabelArray[aIndex]; + TRect rect = candidateLabel->Rect(); + Window().Invalidate(rect); + } + } + } + } + +CAknFepUICtrlCandidatePane::TCandidateMode CAknFepUICtrlCandidatePane::CandidateMode(TInt aIndex) + { + return iCandidateModeArray[aIndex]; + } + +TBool CAknFepUICtrlCandidatePane::IsShowHorizontalScrollArrows() const + { + return EFalse; + } + +void CAknFepUICtrlCandidatePane::ShowHorizontalScrollArrows(TBool /*aValue*/) + { + // If the state is changed, the arrows will be redrawn in the new state. + // if(!COMPARE_BOOLS(iShowHorizontalScrollArrows, aValue)) + // { + // iShowHorizontalScrollArrows = aValue; + // TRect rect = iIndiFepArrowLeft.Rect(); + // Window().Invalidate(rect); + // rect = iIndiFepArrowRight.Rect(); + // Window().Invalidate(rect); + // } + } + +void CAknFepUICtrlCandidatePane::ShowUpScrollArrows(TBool aValue) + { + if (iShowUpScrollArrows != aValue) + { + iShowUpScrollArrows = aValue; + TRect rect = iIndiFepArrowUp.Rect(); + Window().Invalidate(rect); + } + } + +void CAknFepUICtrlCandidatePane::ShowDownScrollArrows(TBool aValue) + { + if (iShowDownScrollArrows != aValue) + { + iShowDownScrollArrows = aValue; + TRect rect = iIndiFepArrowDown.Rect(); + Window().Invalidate(rect); + } + + } + +void CAknFepUICtrlCandidatePane::ShowLeftScrollArrows(TBool /*aValue*/) + { + // if (iShowLeftScrollArrows != aValue) + // { + // iShowLeftScrollArrows = aValue; + // TRect rect = iIndiFepArrowLeft.Rect(); + // Window().Invalidate(rect); + // } + } + +void CAknFepUICtrlCandidatePane::ShowRightScrollArrows(TBool /*aValue*/) + { + // if (iShowRightScrollArrows != aValue) + // { + // iShowRightScrollArrows = aValue; + // TRect rect = iIndiFepArrowRight.Rect(); + // Window().Invalidate(rect); + // } + } + +TBool CAknFepUICtrlCandidatePane::IsShowVerticalScrollArrows() const + { + return iShowVerticalScrollArrows; + } + +void CAknFepUICtrlCandidatePane::ShowVerticalScrollArrows(TBool aValue) + { + // If the state is changed, the arrows will be redrawn in the new state. + if(!COMPARE_BOOLS(iShowVerticalScrollArrows, aValue)) + { + iShowVerticalScrollArrows = aValue; + TRect rect = iIndiFepArrowUp.Rect(); + Window().Invalidate(rect); + rect = iIndiFepArrowDown.Rect(); + Window().Invalidate(rect); + } + } + +void CAknFepUICtrlCandidatePane::ShowCandidateOrdinals(TBool aValue) + { + if(!COMPARE_BOOLS(iShowCandidateOrdinals, aValue)) + { + iShowCandidateOrdinals = aValue; + iCandidateSelected->ShowOrdinal(aValue); + UpdateLabelVisibility(); + } + } + +TBool CAknFepUICtrlCandidatePane::IsShowCandidateOrdinals() const + { + return iShowCandidateOrdinals; + } + +TInt CAknFepUICtrlCandidatePane::VisibleCandidateCount() const + { + return iVisibleCount; + } + +void CAknFepUICtrlCandidatePane::SetVisibleCandidateCount(TInt aCount) + { + __ASSERT_DEBUG(aCount > 0, AknFepUiInterfacePanic(EAknFepUiInterfacePanicNewVisibleCountExceedsRange)); + __ASSERT_DEBUG(aCount <= EMaxCandidates, AknFepUiInterfacePanic(EAknFepUiInterfacePanicNewVisibleCountExceedsRange)); + if(iVisibleCount != aCount) + { + if(aCount - 1 < iSelected) + { + // automatically move the selection to be at the end of the new + // candidate buffer + SelectIndex(aCount - 1); // ignore return code + } + iVisibleCount = aCount; + UpdateLabelVisibility(); + } + } + +TBool CAknFepUICtrlCandidatePane::SelectFirstPhrase() + { + if(iVisibleCount >= 1) + { + return SelectIndex(0,EFalse); + } + else + { + return EFalse; + } + } + +TBool CAknFepUICtrlCandidatePane::SelectFirst() + { + if(iBuffer.Length()) + { + return SelectIndex(0); + } + else + { + return EFalse; + } + } + +TBool CAknFepUICtrlCandidatePane::SelectLastPhrase() + { + if(iVisibleCount > 1) + { + return SelectIndex(iVisibleCount - 1); + } + else + { + return EFalse; + } + } + +TBool CAknFepUICtrlCandidatePane::SelectLast() + { + TInt length = iBuffer.Length(); + if(length) + { + TInt index = length < iVisibleCount ? length : iVisibleCount; + return SelectIndex(index - 1); + } + else + { + return EFalse; + } + } + +TBool CAknFepUICtrlCandidatePane::SelectNext() + { + if(iSelected < iVisibleCount - 1) + { + return SelectIndex(iSelected + 1); + } + else + { + return EFalse; + } + } + +TBool CAknFepUICtrlCandidatePane::SelectPrev() + { + if(iSelected > 0) + { + return SelectIndex(iSelected - 1); + } + else + { + return EFalse; + } + } + +TBool CAknFepUICtrlCandidatePane::SelectIndex(TInt aIndex, TBool selected) + { + if(aIndex + 1 > iVisibleCount || aIndex < 0) + { + return EFalse; + } + if(iSelected != aIndex) + { + if(iSelected + 1 > iVisibleCount && iHighlighted) + { + // candidate selection is currently hidden, as the current + // selection is outside the range of valid candidates, therefore + // show it again + iCandidateSelected->MakeVisible(ETrue); + } + iSelected = aIndex; + // move and repopulate the selected candidate control + const TDesC* txtLabel = iCandidateLabelArray[aIndex]->Text(); + iCandidateSelected->SetText(*txtLabel); + iCandidateSelected->SetOrdinal(iSelected + 1); + + LayoutCandidateSelected(); + if( selected ) + { + + DrawDeferred(); + } + + } + return ETrue; + } + +TInt CAknFepUICtrlCandidatePane::SelectedIndex() const + { + return iSelected; + } + +TPtrC CAknFepUICtrlCandidatePane::CurrentPhraseCandidate() const + { + __ASSERT_DEBUG(iSelected >= 0, AknFepUiInterfacePanic(EAknFepUiInterfacePanicCurrentSelectionOutsideVisibleCandidates)); + if(iVisibleCount > iSelected) + { + return *(iCandidateLabelArray[iSelected]->Text()); + } + else + { + return TPtrC(); + } + } + +TPtrC CAknFepUICtrlCandidatePane::CurrentCandidate() const + { + __ASSERT_DEBUG(iSelected >= 0, AknFepUiInterfacePanic(EAknFepUiInterfacePanicCurrentSelectionOutsideVisibleCandidates)); + if(iBuffer.Length() > iSelected) + { + return iBuffer.Mid(iSelected, EOneCandidate); + } + else + { + return TPtrC(); + } + } + +TInt CAknFepUICtrlCandidatePane::LabelTextWidthInPixels( TInt aIndex) + { + TAknLayoutText layoutText; + TAknTextLineLayout candidatePaneLayoutText = + CAknFepChineseUIDataConv::AnyToTextLine(iLafDataMgr->RequestData( ECandidatePaneTextLine )); + + layoutText.LayoutText(Rect(), candidatePaneLayoutText); + + const CFont* font = layoutText.Font(); + + TInt labelWidthInPixels = 0; + if(font) + { + const TDesC* txtLabel = iCandidateLabelArray[aIndex]->Text(); + if(txtLabel->Length() != 0) + { + labelWidthInPixels = font->TextWidthInPixels(*txtLabel); + } + } + return labelWidthInPixels; + } +void CAknFepUICtrlCandidatePane::SetPaneLayout(CAknFepUICtrlContainerChinese::TPaneLayout aPaneLayout) + { + iPaneLayout = aPaneLayout; + } + +void CAknFepUICtrlCandidatePane::SplitPhraseCandidatesIntoPages() + { + iPages.Reset(); + iUnpagedIndex = 0; + + InternalSpilitPhraseCandidate(); + + if( iPages.Count() == 0 ) + { + iVisibleCount = 0; + } + else + { + iCurDisplayPage = 0; + SetVisibleCandidateCount(iPages[0].iEndIndex - iPages[0].iStartIndex + 1); + } + } + +void CAknFepUICtrlCandidatePane::NextCandidatePage(void) + { + if(iCurDisplayPage == (iPages.Count() - 1)) + { + if( iUnpagedIndex < iCandidateArray->Count() ) + { + //continue page + InternalSpilitPhraseCandidate(); + iCurDisplayPage++; + } + else + { + iCurDisplayPage = 0; + } + } + else + { + iCurDisplayPage ++; + } + // For fix bug of when the count of character in the last page is less than + // the previous page of the last page. And then select the last character of + // the previous page of the last page, and select next page. First of the last + // page is not refreshed. + iSelected = 0; + } + +void CAknFepUICtrlCandidatePane::PreviousCandidatePage(void) + { + if(iCurDisplayPage == 0) + { + iCurDisplayPage = iPages.Count() - 1; + } + else + { + iCurDisplayPage --; + } + } + +void CAknFepUICtrlCandidatePane::SizeChanged() + { + LayoutRects(); + LayoutContainedControls(); + } + +TInt CAknFepUICtrlCandidatePane::CountComponentControls() const + { + TInt count = 0; + count += iCandidateLabelArray.Count(); + count += iOrdinalLabelArray.Count(); + + CCoeControl* controls[] = + { + iCandidateSelected + } ; + + for (TUint ii = 0 ; ii < (sizeof(controls) / sizeof(CCoeControl*)) ; ii++) + { + if(controls[ii]) + { + count++ ; + } + } + return count ; + } + +CCoeControl* CAknFepUICtrlCandidatePane::ComponentControl(TInt aIndex) const + { + TInt candidateCount = iCandidateLabelArray.Count(); + TInt ordinalCount = iOrdinalLabelArray.Count(); + + if(aIndex < candidateCount) + { + // because this method is const, the const [] operator is selected + // which means that the pointer is const, so have to cast away constness + // - a possible alternative is to make the array mutable? + return CONST_CAST(CEikLabel*, iCandidateLabelArray[aIndex]); + } + aIndex -= candidateCount; + + if(aIndex < ordinalCount) + { + // because this method is const, the const [] operator is selected + // which means that the pointer is const, so have to cast away constness + // - a possible alternative is to make the array mutable? + return CONST_CAST(CEikLabel*, iOrdinalLabelArray[aIndex]); + } + aIndex -= ordinalCount; + + CCoeControl* controls[] = + { + iCandidateSelected + } ; + + for (TUint ii = 0; (ii < sizeof(controls) / sizeof(CCoeControl*)) ; ii++) + { + if (controls[ii] && aIndex-- == 0) + { + return controls[ii] ; + } + } + // shouldn't be called while no components. + return NULL ; + } + +void CAknFepUICtrlCandidatePane::Draw(const TRect& /* aRect */) const + { + CWindowGc& gc = SystemGc(); + + if(iShowHorizontalScrollArrows) + { + if (iShowLeftScrollArrows) + { + iIndiFepArrowLeft.DrawImage(gc, + iNaviArrowBitmapLeft, + iNaviArrowBitmapLeftMask); + } + + if (iShowRightScrollArrows) + { + iIndiFepArrowRight.DrawImage(gc, + iNaviArrowBitmapRight, + iNaviArrowBitmapRightMask); + } + } + if(iShowVerticalScrollArrows) + { + if (iShowUpScrollArrows) + { + iIndiFepArrowUp.DrawImage(gc, + iNaviArrowBitmapUp, + iNaviArrowBitmapUpMask); + } + + if (iShowDownScrollArrows) + { + iIndiFepArrowDown.DrawImage(gc, + iNaviArrowBitmapDown, + iNaviArrowBitmapDownMask); + } + } + } + +void CAknFepUICtrlCandidatePane::ConstructL(RWindow& aParent) + { + SetContainerWindowL(aParent); + ConstructBitmapsL(); + + TBuf ordinal; + for(TInt i = 0; i < EMaxCandidates; i++) + { + CEikLabel* candidateLabel = new(ELeave) CEikLabel; + CleanupStack::PushL(candidateLabel); + candidateLabel->SetContainerWindowL(aParent); + candidateLabel->SetBufferReserveLengthL(EPhraseLength); + // ownership is passed, unless allocation is unsuccessful, in which case we still have it on the stack + User::LeaveIfError(iCandidateLabelArray.Append(candidateLabel)); + CleanupStack::Pop(); // candidateLabel + + CEikLabel* ordinalLabel = new(ELeave) CEikLabel; + CleanupStack::PushL(ordinalLabel); + ordinalLabel->SetContainerWindowL(aParent); + ordinalLabel->SetBufferReserveLengthL(EOneCandidate); + ordinal.Num((i+1)%10); // digits are [1, 2,,, 9, 0] - only want the last digit in the case of 10! + ordinalLabel->SetTextL(ordinal); + // ownership is passed, unless allocation is unsuccessful, in which case we still have it on the stack + User::LeaveIfError(iOrdinalLabelArray.Append(ordinalLabel)); + CleanupStack::Pop(); // ordinalLabel + + User::LeaveIfError(iCandidateModeArray.Append(ECandidateModeNormal)); + } + + iCandidateSelected = CAknFepUICtrlCandidateSelected::NewL(aParent); + iCandidateSelected->MakeVisible(iHighlighted); + iCandidateSelected->SetMopParent(this); + iCandidateArray = new(ELeave) CDesCArrayFlat(1); + } + +void CAknFepUICtrlCandidatePane::ConstructBitmapsL() + { + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + + TFileName bmpFile; + bmpFile.Copy(_L("z:")); + bmpFile.Append(KDC_BITMAP_DIR); + bmpFile.Append(KFepUiControlsBitmapFile); + + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnIndiFepArrowLeft, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG20, + iNaviArrowBitmapLeft, + iNaviArrowBitmapLeftMask, + bmpFile, + EMbmAknfepuictrlsQgn_indi_fep_arrow_left, + EMbmAknfepuictrlsQgn_indi_fep_arrow_left_mask, + AKN_LAF_COLOR( 0 ) + ); + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnIndiFepArrowRight, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG20, + iNaviArrowBitmapRight, + iNaviArrowBitmapRightMask, + bmpFile, + EMbmAknfepuictrlsQgn_indi_fep_arrow_right, + EMbmAknfepuictrlsQgn_indi_fep_arrow_right_mask, + AKN_LAF_COLOR( 0 ) + ); + + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnIndiFepArrowUp, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG20, + iNaviArrowBitmapUp, + iNaviArrowBitmapUpMask, + bmpFile, + EMbmAknfepuictrlsQgn_indi_fep_arrow_up, + EMbmAknfepuictrlsQgn_indi_fep_arrow_up_mask, + AKN_LAF_COLOR( 0 ) + ); + AknsUtils::CreateColorIconL( skin, + KAknsIIDQgnIndiFepArrowDown, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG20, + iNaviArrowBitmapDown, + iNaviArrowBitmapDownMask, + bmpFile, + EMbmAknfepuictrlsQgn_indi_fep_arrow_down, + EMbmAknfepuictrlsQgn_indi_fep_arrow_down_mask, + AKN_LAF_COLOR( 0 ) + ); + } + +CAknFepUICtrlCandidatePane::CAknFepUICtrlCandidatePane(CAknFepUiLayoutDataMgr* aLafDataMgr) + : + iPaneLayout(CAknFepUICtrlContainerChinese::ELayoutCandidate), + iHighlighted(EFalse), + iShowHorizontalScrollArrows(EFalse), + iShowVerticalScrollArrows(EFalse), + iShowUpScrollArrows(ETrue), + iShowDownScrollArrows(ETrue), + iShowLeftScrollArrows(ETrue), + iShowRightScrollArrows(ETrue), + iShowCandidateOrdinals(ETrue), + iCurDisplayPage(0), + iOrdinalLableWidth(0) + { + iLafDataMgr = aLafDataMgr; + } + +void CAknFepUICtrlCandidatePane::LayoutRects() + { + TRect rect = Rect(); + + TAknWindowLineLayout candidateWindowLine1 = + CAknFepChineseUIDataConv::AnyToWindowLine( iLafDataMgr->RequestData(ECandidateWindowLine1)); + TAknWindowLineLayout candidateWindowLine2 = + CAknFepChineseUIDataConv::AnyToWindowLine( iLafDataMgr->RequestData(ECandidateWindowLine2)); + TAknWindowLineLayout candidateWindowLine3 = + CAknFepChineseUIDataConv::AnyToWindowLine( iLafDataMgr->RequestData(ECandidateWindowLine3)); + TAknWindowLineLayout candidateWindowLine4 = + CAknFepChineseUIDataConv::AnyToWindowLine( iLafDataMgr->RequestData(ECandidateWindowLine4)); + + iIndiFepArrowLeft.LayoutRect(rect, candidateWindowLine1); + AknIconUtils::SetSize(iNaviArrowBitmapLeft, iIndiFepArrowLeft.Rect().Size()); + + iIndiFepArrowRight.LayoutRect(rect, candidateWindowLine2); + AknIconUtils::SetSize(iNaviArrowBitmapRight, iIndiFepArrowRight.Rect().Size()); + + iIndiFepArrowUp.LayoutRect(rect, candidateWindowLine3); + AknIconUtils::SetSize(iNaviArrowBitmapUp, iIndiFepArrowUp.Rect().Size()); + + iIndiFepArrowDown.LayoutRect(rect, candidateWindowLine4); + AknIconUtils::SetSize( iNaviArrowBitmapDown, iIndiFepArrowDown.Rect().Size() ); + } + +void CAknFepUICtrlCandidatePane::LayoutContainedControls() + { + LayoutLabels(); + LayoutCandidateSelected(); + } + +void CAknFepUICtrlCandidatePane::LayoutLabel(TInt aIndex) + { + __ASSERT_DEBUG(aIndex >= 0, AknFepUiInterfacePanic(EAknFepUiInterfacePanicAttemptedLayoutOutsideVisibleCount)); + __ASSERT_DEBUG(aIndex < iVisibleCount, AknFepUiInterfacePanic(EAknFepUiInterfacePanicAttemptedLayoutOutsideVisibleCount)); + TRect rect = Rect(); + CEikLabel* candidateLabel = iCandidateLabelArray[aIndex]; + CEikLabel* ordinalLabel = iOrdinalLabelArray[aIndex]; + TAknWindowLineLayout layoutCandidateItem = + CAknFepChineseUIDataConv::AnyToWindowLine( iLafDataMgr->RequestData(ELayoutCandidateItem)); + TAknTextLineLayout candidateLayout = + CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData(ECandidatePaneTextLine)); + + // layout candidate label + TAknLayoutRect layoutRectCandidateItem; + layoutRectCandidateItem.LayoutRect(rect,layoutCandidateItem); + TRect rectCandidateItem = layoutRectCandidateItem.Rect(); + + if(aIndex > 0) + { + rectCandidateItem.iTl.iX = iCandidateLabelArray[aIndex - 1]->Rect().iBr.iX; + } + TAknLayoutText layoutText; + layoutText.LayoutText(rectCandidateItem,candidateLayout); + TRect rectText = layoutText.TextRect(); + rectText.SetWidth(LabelTextWidthInPixels(aIndex)); + + candidateLabel->SetRect(rectText); + candidateLabel->SetFont(layoutText.Font()); + + // layout ordinal label + TAknTextLineLayout ordinalLayout = + CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData(EOrdinalCandidateTextLayout)); + TBufC16<1> buf; + TAknLayoutText layoutOrdinal; + TPtr16 ptr = buf.Des(); + ptr = (*(ordinalLabel->Text())).Left(EOneCandidate); + + layoutOrdinal.LayoutText(rectCandidateItem,ordinalLayout); + + const CFont* font = layoutOrdinal.Font(); + + TRect rectOrdinal = layoutOrdinal.TextRect(); + // align ordinal label and candidate label + + /* removed in 2006.03.29 + rectOrdinal.iTl.iY = rectText.iTl.iY; + rectOrdinal.SetWidth(font->TextWidthInPixels(ptr)); + rectOrdinal.SetHeight(font->HeightInPixels()); + */ + + // inserted in 2006.03.29 + TPoint ordinalPosition; + TInt ordinalWidth = font->TextWidthInPixels(ptr); + ordinalPosition.iX = rectText.iTl.iX - ordinalWidth; + ordinalPosition.iY = rectText.iTl.iY; + + rectOrdinal = TRect(ordinalPosition, + TPoint(ordinalPosition.iX + rectOrdinal.Width(), + ordinalPosition.iY + rectOrdinal.Height())); + // end inserting + + ordinalLabel->SetRect(rectOrdinal); + ordinalLabel->SetFont(font); + iOrdinalLableWidth = rectOrdinal.Width(); + + // override colours if skin data present + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + TRgb candidateLabelTextColor = layoutText.Color(); + TRgb ordinalLabelTextColor = layoutOrdinal.Color(); + + AknsUtils::GetCachedColor(skin, candidateLabelTextColor, + KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19); + + AknsUtils::GetCachedColor(skin, ordinalLabelTextColor, + KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19); + + TRAP_IGNORE( + candidateLabel->OverrideColorL(EColorLabelText, candidateLabelTextColor); + ordinalLabel->OverrideColorL(EColorLabelText, ordinalLabelTextColor); + ); + } + +void CAknFepUICtrlCandidatePane::LayoutLabels() + { + for(TInt i = 0; i < iVisibleCount; i++) + { + LayoutLabel(i); + } + } + +void CAknFepUICtrlCandidatePane::LayoutCandidateSelected() + { + TCandidateMode candidateMode = iCandidateModeArray[iSelected]; + iCandidateSelected->SetCandidateMode(candidateMode); + iCandidateSelected->SetLayout(iPaneLayout); + + TRect ordinalRect = iOrdinalLabelArray[iSelected]->Rect(); + + TAknLayoutRect layoutRect; + TAknWindowLineLayout layoutCandidateItem = + CAknFepChineseUIDataConv::AnyToWindowLine( iLafDataMgr->RequestData(ELayoutCandidateItem)); + layoutRect.LayoutRect(Rect(),layoutCandidateItem); + + TRect rectLayoutCandidateItem = layoutRect.Rect(); + rectLayoutCandidateItem.iTl.iX = ordinalRect.iTl.iX; + + TAknTextLineLayout candidateLayout = + CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData(ECandidatePaneTextLine)); + TAknTextLineLayout ordinalLayout = + CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData(EOrdinalCandidateTextLayout)); + rectLayoutCandidateItem.SetWidth(iCandidateLabelArray[iSelected]->Rect().Width() + candidateLayout.il - ordinalLayout.il); + + rectLayoutCandidateItem.SetHeight(rectLayoutCandidateItem.Height() - 1); + + iCandidateSelected->SetRect(rectLayoutCandidateItem); + } + +void CAknFepUICtrlCandidatePane::UpdateLabelVisibility() + { + TInt number = 0; + // only show the labels corresponding to candidates that have been set + if(iPages.Count() != 0) + { + number = iPages[iCurDisplayPage].iEndIndex - iPages[iCurDisplayPage].iStartIndex + 1; + } + else + { + number = iBuffer.Length(); + } + + if(number > iVisibleCount) + { + number = iVisibleCount; + } + for(TInt i = 0; i < EMaxCandidates; i++) + { + CEikLabel* candidateLabel = iCandidateLabelArray[i]; + CEikLabel* ordinalLabel = iOrdinalLabelArray[i]; + if(i < number) + { + candidateLabel->MakeVisible(ETrue); + ordinalLabel->MakeVisible(iShowCandidateOrdinals); // only show if needed + } + else + { + candidateLabel->MakeVisible(EFalse); + ordinalLabel->MakeVisible(EFalse); // don't show it as there is no character to go with it + } + } + } + +void CAknFepUICtrlCandidatePane::ResetCandidateState() + { + iPages.Reset(); + } + +void CAknFepUICtrlCandidatePane::DrawBackground(const TRect& aRect) const + { + // instead of drawing one blank rectangle over each of the 20 labels, + // just draw one big rectangle covering the entire pane + CWindowGc& gc = SystemGc(); + TRgb background = AKN_LAF_COLOR(0); + gc.SetBrushColor(background); + gc.Clear(aRect); + } + +void CAknFepUICtrlCandidatePane::InternalSpilitPhraseCandidate() + { + //__ASSERT_DEBUG(aStartIndex + aCount <= iCandidateArray->Count()); + + TInt phraseCandidateNum = iCandidateArray->Count(); + if( phraseCandidateNum == iUnpagedIndex ) + { + //nothing need to be paged + return; + } + + TPage curPage; + TInt index = iUnpagedIndex; + CEikLabel* candidateLabel; + + curPage.iStartIndex = index; + curPage.iEndIndex = index; + TInt candidateLeftNum = phraseCandidateNum - index > EMaxCandidates? + EMaxCandidates : phraseCandidateNum - index; + + TAknWindowLineLayout layoutCandidateItem = + CAknFepChineseUIDataConv::AnyToWindowLine( iLafDataMgr->RequestData(ELayoutCandidateItem)); + TAknTextLineLayout candidateLayout = + CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData(ECandidatePaneTextLine)); + + // avoid accessing layout data member + TAknLayoutRect layoutRect; + layoutRect.LayoutRect(Rect(),layoutCandidateItem); + TRect rectLayoutCandidateItem = layoutRect.Rect(); + + TAknLayoutText layoutText; + layoutText.LayoutText(rectLayoutCandidateItem,candidateLayout); + TRect rectText = layoutText.TextRect(); + + TInt distance = rectText.iTl.iX - rectLayoutCandidateItem.iTl.iX + rectLayoutCandidateItem.iBr.iX - rectText.iBr.iX; + rectLayoutCandidateItem.iTl.iX += distance; + + TInt width = 0; + TInt i = 0; + + const TInt candidateWidth = rectLayoutCandidateItem.Width(); + for ( i = 0; i < candidateLeftNum; i ++ ) + { + // Initialization + candidateLabel = iCandidateLabelArray[i]; + // labelWidth in the font + const CFont* font = layoutText.Font(); + TPtrC newText = (*iCandidateArray)[iUnpagedIndex + i]; + TInt labelWidth = font->TextWidthInPixels( newText ); + if ( labelWidth > candidateWidth ) + { + TBufC buf1; + TPtr text( buf1.Des() ); + + AknBidiTextUtils::ConvertToVisualAndClip(newText, text, *font, + candidateWidth, candidateWidth, + AknBidiTextUtils::EImplicit,0xFFFF); + + iCandidateArray->Delete( iUnpagedIndex + i ); + TRAP_IGNORE( + { + iCandidateArray->InsertL( iUnpagedIndex + i, text ); + candidateLabel->SetTextL(text); + }); + + } + else + { + TRAP_IGNORE( candidateLabel->SetTextL(newText)); + width = LabelTextWidthInPixels(i)+ iOrdinalLableWidth; + rectLayoutCandidateItem.iTl.iX += width; + } + if (rectLayoutCandidateItem.iTl.iX >= rectLayoutCandidateItem.iBr.iX) + { + if (index>0) + { + curPage.iEndIndex = index - 1; + } + else + { + curPage.iEndIndex = index; + } + + iPages.Append(curPage); + break; + } + else + { + index ++; + } + + if( i == EMaxCandidates -1 ) + { + curPage.iEndIndex = index - 1; + iPages.Append(curPage); + break; + } + + } + + if( i >= candidateLeftNum ) + { + curPage.iEndIndex = index - 1; + iPages.Append(curPage); + } + + iUnpagedIndex = index; + } + +TBool CAknFepUICtrlCandidatePane::IsFirstPage() + { + return iCurDisplayPage == 0; + } + +TBool CAknFepUICtrlCandidatePane::IsLastPage() + { + if( iCandidateArray->Count() == iUnpagedIndex ) + { + return iCurDisplayPage == iPages.Count() - 1; + } + return EFalse; + } + +void CAknFepUICtrlCandidatePane::SetInVisiable() + { + for (TInt i = 0; i < EMaxCandidates; i ++) + { + CEikLabel* candidateLabel = iCandidateLabelArray[i]; + CEikLabel* ordinalLabel = iOrdinalLabelArray[i]; + candidateLabel->MakeVisible(EFalse); + ordinalLabel->MakeVisible(EFalse); + } + iCandidateSelected->MakeVisible(EFalse); + } + +TBool CAknFepUICtrlCandidatePane::NeedGetNewCandidatePage() + { + return (iCandidateArray->Count() - iUnpagedIndex < CandidateCountLeft); + + } + +//Bug Fixing for ESSG-7P5CSZ +void CAknFepUICtrlCandidatePane::Enable(TBool aEnable) + { + if (!aEnable) + { + for (TInt i=0; iSetTextL(KNullDesC)); + } + iCandidateArray->Reset(); + iVisibleCount = 0; + DrawNow(); + } + } +// End of file