/*

* 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 <uikon/eikdefmacros.h>

#endif

#include <eiklabel.h>

#include <AknsDrawUtils.h>

#include <AknBidiTextUtils.h> 

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <aknfepuictrls.mbg>

#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<EPhraseLength> 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 =