/*

* 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 "AknFepUiInterfacePanic.h"

#include "AknFepUIAvkonCtrlCandidatePane.h"

#include "aknfepchineseuidataconv.h"

#include "aknfepuilayoutdatamgr.h"

#include "data_caging_path_literals.hrh"

const TInt CandidateCountLeft = 10;

_LIT(KFepUiControlsBitmapFile, "aknfepuictrls.mbm");

    {

    CleanupStack::PushL(self);

    self->ConstructL(aParent);

    CleanupStack::Pop();

    return self;

    }

CAknFepUICtrlCandidatePane::~CAknFepUICtrlCandidatePane()

    {

    if(iCandidateArray)

    	{

    	iCandidateArray->Reset();

		delete iCandidateArray;

    	}

    iCandidateLabelArray.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

        }

    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)

            }

        }

    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

                }

            }

        ptr.Copy(newText);

        LayoutLabels();

        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)

        {

        }

    else

        {

        if(iHighlighted)

            {

            }

        }

    TBufC<EPhraseLength> buf;

    TPtr newText = buf.Des();

    for(TInt i = 0; i < iVisibleCount; i ++)

        {

        const TDesC* txtLabel = candidateLabel->Text();

        newText = (*iCandidateArray)[curPage.iStartIndex + i];

            {

            // we have already allocated enough memory for this

            }

            }

        }

    LayoutLabels();

    DrawDeferred();

    UpdateLabelVisibility();

    }

void CAknFepUICtrlCandidatePane::SetHighlighted(TBool aHighlighted)

    {

    if(!COMPARE_BOOLS(iHighlighted, aHighlighted))

        {

        iHighlighted = aHighlighted;

        }

    }

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;

        // only do drawing if visible

        if(aIndex < iVisibleCount)

            {

            LayoutLabel(aIndex);

            if(iSelected == aIndex && iHighlighted)

                {

                }

            else

                {

                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*/)

    {

    }

void CAknFepUICtrlCandidatePane::ShowUpScrollArrows(TBool aValue)

    {

    }

void CAknFepUICtrlCandidatePane::ShowDownScrollArrows(TBool aValue)

    {

    }

void CAknFepUICtrlCandidatePane::ShowLeftScrollArrows(TBool /*aValue*/)

    {

    }

void CAknFepUICtrlCandidatePane::ShowRightScrollArrows(TBool /*aValue*/)

    {

    }

TBool CAknFepUICtrlCandidatePane::IsShowVerticalScrollArrows() const

    {

    }

void CAknFepUICtrlCandidatePane::ShowVerticalScrollArrows(TBool aValue)

    {

    }

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;

        }

    }

    {

        {

        return EFalse;

        }

        iSelected = aIndex;

    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 = 

    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)

        {