/*
* 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:         This class is a utitlity class for conversion of Vodafone
*                pictograph.
*
*/








// PICTOGRAPH_SHARED.CPP
//
//

#include "CnvPictographShared.h"
// #include "CnvPictograph1.h"
#include "CnvShiftJisDirectmap.h"
#include <convgeneratedcpp.h>


// CONSTANTS
// Escape sequence for Vodafone pictograph
_LIT8(KLit8EscapeSequenceForPictograph, "\x1b\x24");
// _LIT8(KLit8EscapeSequenceForPictograph1, "\x1b\x24\x47");

const TInt KEscape = 0x1B;
const TInt KShiftIn = 0x0F;

// Intermidiate buffers for pictograph
const TInt KIntermediateBuffer1 = 'G';

const TUint KSingleByteRangeFirstBlockStart = 0xF0;
const TUint KSingleByteRangeFirstBlockEnd = 0xF9;
const TUint KSingleByteRangeSecondBlockStart = 0x40;
const TUint KSingleByteRangeSecondBlockEnd = 0xFC;

const TUint KFirstByteRangeFirstBlockStart = 0xF5;
const TUint KFirstByteRangeFirstBlockEnd = 0xFE;
const TUint KSecondByteRangeSecondBlockStart = 0xA1;
const TUint KSecondByteRangeSecondBlockEnd = 0xFE;

const TUint KEUCJPSecondBlockStart = 0xF5;
const TUint KEUCJPBlockSize = 0x5D;
const TUint KSingleShift3=0x8f;
// used for EucJp
const TUint KPictographStartFirstByte = 0xF0;
const TUint KPictographStartSecondByte = 0x40;
const TUint KShiftJisTrailByteIllegal = 0x7F;

// ============================ LOCAL FUNCTIONS ===============================


// -----------------------------------------------------------------------------
// DummyConvertToIntermediateBufferInPlace ?description.
//
// -----------------------------------------------------------------------------
//
LOCAL_C void DummyConvertToIntermediateBufferInPlace(TDes8&)
    {
    }

// -----------------------------------------------------------------------------
// DummyConvertFromIntermediateBufferInPlace
//
// -----------------------------------------------------------------------------
//
LOCAL_C void DummyConvertFromIntermediateBufferInPlace(TInt, TDes8&,
                                TInt& aNumberOfCharactersThatDroppedOut)
    {
    aNumberOfCharactersThatDroppedOut=0;
    }

// -----------------------------------------------------------------------------
// ConvertFromPictogaphToEucJpDirectmapInPlace
// Converts from EucJp packed Pictograph to Unicode
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertFromPictogaphToEucJpDirectmapInPlace(
        TInt aStartPositionInDescriptor, TDes8& aDescriptor,
        TInt& aNumberOfCharactersThatDroppedOut)
    {
    TInt descriptorLength=aDescriptor.Length();
    TInt bytesPerCharacter = 2;
    if (aDescriptor[0] >= KEUCJPSecondBlockStart)
        {
        bytesPerCharacter = 3;
        }

    aNumberOfCharactersThatDroppedOut =
        Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -
        ((aDescriptor.MaxLength() - aStartPositionInDescriptor) /
        bytesPerCharacter));
    descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;
    if (descriptorLength <= aStartPositionInDescriptor)
        {
        aDescriptor.SetLength(descriptorLength);
        }
    else
        {
        // pointerToTargetByte is initialized properly when descriptorLength
        // has been offset to the actual final length of aDescriptor
        TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
        const TUint8* const pointerToFirstByte =
            pointerToTargetByte + aStartPositionInDescriptor;
        const TUint8* pointerToSourceByte =
            pointerToTargetByte + (descriptorLength - 1);
        descriptorLength = (((descriptorLength - aStartPositionInDescriptor)
            * bytesPerCharacter) / 2) + aStartPositionInDescriptor;
        aDescriptor.SetLength(descriptorLength);
        // pointerToTargetByte is is initialized properly here
        pointerToTargetByte += descriptorLength - 1;
        for (;pointerToTargetByte > pointerToFirstByte; )
            {
            TInt secondByte = *pointerToSourceByte;
            TInt firstByte = *(pointerToSourceByte - 1);

            if (bytesPerCharacter == 3)
                {
                firstByte = (firstByte - KEUCJPSecondBlockStart) * 2 +
                    KFirstByteRangeFirstBlockStart;
                }
            else
                {
                firstByte = (firstByte - KPictographStartFirstByte) * 2 +
                    KFirstByteRangeFirstBlockStart;
                }
            if (static_cast<TInt>(KEUCJPBlockSize + KPictographStartSecondByte + 1)
                 < secondByte)
                {
                if (secondByte > KShiftJisTrailByteIllegal)
                    secondByte -= 1;
                secondByte = secondByte -(KPictographStartSecondByte +
                    KEUCJPBlockSize + 1) + KSecondByteRangeSecondBlockStart;
                firstByte++;
                }
            else
                {
                if (secondByte > KShiftJisTrailByteIllegal)
                    secondByte -= 1;
                secondByte += KSecondByteRangeSecondBlockStart - KPictographStartSecondByte;
                }
            *pointerToTargetByte = static_cast<TUint8>(secondByte);
            --pointerToTargetByte;
            *pointerToTargetByte = static_cast<TUint8>(firstByte);
            if (bytesPerCharacter == 3)
                {
                --pointerToTargetByte;
                *pointerToTargetByte = KSingleShift3;
                }
            --pointerToTargetByte;
            pointerToSourceByte -= 2;
            }
        }
    }

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CnvPictographShared::SetCharacterSetsForPictograph
// It sets parameters to SCharacterSet array. It called in ConvertFromUnicode().
// It makes possible that pictograph conversion is called from other conversion
// plug-ins.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CnvPictographShared::SetCharacterSetsForPictograph(
        RArray<CnvUtilities::SCharacterSet>& /*aArrayOfCharacterSets*/)
    {
    // SAMPLE CODE
    // If this module needs to support escape sequence pictograph,
    // Remove the comment from the following code.

    // CnvUtilities::SCharacterSet characterSet;
    // characterSet.iConversionData = &CnvPictograph1::ConversionData();
    // characterSet.iConvertFromIntermediateBufferInPlace =
    //     CnvPictographShared::ConvertToPictograph1InPlace;
    // characterSet.iEscapeSequence = &KLit8EscapeSequenceForPictograph1;
    // aArrayOfCharacterSets.Append(characterSet);

    }

// -----------------------------------------------------------------------------
// CnvPictographShared::SetMethodsForPictograph
// It sets parameters to SMethod array. It called in ConvertToUnicode().
// It makes possible that pictograph conversion is called from other conversion
// plug-ins.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CnvPictographShared::SetMethodsForPictograph(
        RArray<CnvUtilities::SMethod>& aArrayOfMethods, TOriginalCharset aOriginalCharset)
    {
    CnvUtilities::SMethod method;
    switch (aOriginalCharset)
        {
        case ECharsetShiftJis:
            method.iNumberOfBytesAbleToConvert =
                CnvPictographShared::NumberOfBytesAbleToConvertSJisDirectMap;
            method.iConvertToIntermediateBufferInPlace =
                DummyConvertToIntermediateBufferInPlace;
            method.iConversionData =
                &CnvShiftJisDirectmap::ConversionData();
            method.iNumberOfBytesPerCharacter = 2;
            method.iNumberOfCoreBytesPerCharacter = 2;
            aArrayOfMethods.Append(method);
            break;
        case ECharsetEucJp:
            method.iNumberOfBytesAbleToConvert =
                CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap1;
            method.iConvertToIntermediateBufferInPlace =
                CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace;
            method.iConversionData =
                &CnvShiftJisDirectmap::ConversionData();
            method.iNumberOfBytesPerCharacter = 2;
            method.iNumberOfCoreBytesPerCharacter = 2;
            aArrayOfMethods.Append(method);
            method.iNumberOfBytesAbleToConvert =
                CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap2;
            method.iConvertToIntermediateBufferInPlace =
                CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace;
            method.iConversionData =
                &CnvShiftJisDirectmap::ConversionData();
            method.iNumberOfBytesPerCharacter = 3;
            method.iNumberOfCoreBytesPerCharacter = 2;
            aArrayOfMethods.Append(method);
            break;
        default:
            break;
        }

    // SAMPLE CODE
    // If this module needs to support escape sequence pictograph,
    // Remove the comment from the following code.

    // method.iNumberOfBytesAbleToConvert =
    //     CnvPictographShared::NumberOfBytesAbleToConvertToPicto1;
    // method.iConvertToIntermediateBufferInPlace =
    //     CnvPictographShared::ConvertToPictographFromUnicode;
    // method.iConversionData = &CnvPictograph1::ConversionData();
    // method.iNumberOfBytesPerCharacter = 1;
    // method.iNumberOfCoreBytesPerCharacter = 1;
    // aArrayOfMethods.Append(method);
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::SetCharacterSetsForPictograph
// It sets parameters to SState array. It called in ConvertToUnicode().
// It makes possible that pictograph conversion is called from other
// conversion plug-ins.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CnvPictographShared::SetCharacterSetsForPictograph(
        RArray<CnvUtilities::SCharacterSet>& aArrayOfStates,
        TOriginalCharset aOriginalCharset)
    {
    CnvUtilities::SCharacterSet characterSet;
    switch (aOriginalCharset)
        {
        case ECharsetShiftJis:
            // Append the character set for pictograph
            characterSet.iConversionData =
                &CnvShiftJisDirectmap::ConversionData();
            characterSet.iConvertFromIntermediateBufferInPlace =
                DummyConvertFromIntermediateBufferInPlace;
            characterSet.iEscapeSequence = &KNullDesC8;
            aArrayOfStates.Append(characterSet);
            break;
        case ECharsetEucJp:
            // Append the character set for pictograph1
            characterSet.iConversionData = &CnvShiftJisDirectmap::ConversionData();
            characterSet.iConvertFromIntermediateBufferInPlace =
                ConvertFromPictogaphToEucJpDirectmapInPlace;
            characterSet.iEscapeSequence = &KNullDesC8;
            aArrayOfStates.Append(characterSet);

            // Append the character set for pictograph2
            characterSet.iConversionData = &CnvShiftJisDirectmap::ConversionData();
            characterSet.iConvertFromIntermediateBufferInPlace =
                ConvertFromPictogaphToEucJpDirectmapInPlace;
            characterSet.iEscapeSequence = &KNullDesC8;
            aArrayOfStates.Append(characterSet);
            break;
        default:
            break;
        }
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::SetStatesForPictograph
// It sets parameters to SState array. It called in ConvertToUnicode().
// It makes possible that pictograph conversion is called from other
// conversion plug-ins.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CnvPictographShared::SetStatesForPictograph(
        RArray<CnvUtilities::SState>& /*aArrayOfStates*/)
    {
    // SAMPLE CODE
    // If this module needs to support escape sequence pictograph,
    // Remove the comment from the following code.

    // CnvUtilities::SState state;
    // state.iEscapeSequence = &KLit8EscapeSequenceForPictograph1;
    // state.iConversionData = &CnvPictograph1::ConversionData();
    // aArrayOfStates.Append(state);
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::ConvertToPictograph1InPlace
// It converts from an intermediate buffer to a pictograph code.
// After that, it adds shift-in code(0x0F).
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
// void CnvPictographShared::ConvertToPictograph1InPlace(
//         TInt aStartPositionInDescriptor,
//         TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
//     {
//     CnvUtilities::ConvertFromIntermediateBufferInPlace(
//         aStartPositionInDescriptor, aDescriptor,
//         aNumberOfCharactersThatDroppedOut,
//         KLit8EscapeSequenceForPictograph1, 1);
//     AppendShiftIn(aDescriptor, aNumberOfCharactersThatDroppedOut);
//     }


// -----------------------------------------------------------------------------
// CnvPictographShared::NumberOfBytesAbleToConvertToPicto1
// It returns a number of bytes that the conversion to pictograph is
// possible in the descriptor.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CnvPictographShared::NumberOfBytesAbleToConvertSJisDirectMap(
        const TDesC8& aDescriptor)
    {
    const TUint8* pointerToPreviousByte = aDescriptor.Ptr()-1;
    const TUint8* const pointerToLastByte =
            pointerToPreviousByte + aDescriptor.Length();
    if (pointerToPreviousByte == pointerToLastByte)
        {
        return 0;
        }
    for (; pointerToPreviousByte < pointerToLastByte; )
        {
        const TUint currentByte = *(pointerToPreviousByte + 1);
        const TUint nextByte = *(pointerToPreviousByte + 2);
        if (((currentByte < KSingleByteRangeFirstBlockStart) ||
             (currentByte > KSingleByteRangeFirstBlockEnd)) ||
            ((nextByte < KSingleByteRangeSecondBlockStart) ||
             (nextByte > KSingleByteRangeSecondBlockEnd)))
            {
            break;
            }
        pointerToPreviousByte += 2;
        }
    return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
    }

// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToEucJpDirectMap1
//
// -----------------------------------------------------------------------------
//
TInt CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap1(
        const TDesC8& aDescriptor)
    {
    const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
    const TUint8* const pointerToLastByte =
        pointerToPreviousByte + aDescriptor.Length();
    if (pointerToPreviousByte == pointerToLastByte)
        {
        return 0;
        }
    for (;pointerToPreviousByte < pointerToLastByte;)
        {
        TUint currentByte = *(pointerToPreviousByte + 1);
        const TUint nextByte = *(pointerToPreviousByte + 2);
        if (((currentByte < KFirstByteRangeFirstBlockStart) ||
             (currentByte > KFirstByteRangeFirstBlockEnd)) ||
            ((nextByte < KSecondByteRangeSecondBlockStart) ||
             (nextByte > KSecondByteRangeSecondBlockEnd)))
            {
            break;
            }
        pointerToPreviousByte += 2;
        }
    return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
    }

// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToPictograph
//
// -----------------------------------------------------------------------------
//
TInt CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap2(
        const TDesC8& aDescriptor)
    {
    const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
    const TUint8* const pointerToLastByte =
        pointerToPreviousByte + aDescriptor.Length();
    if (pointerToPreviousByte == pointerToLastByte)
        {
        return 0;
        }
    for (;pointerToPreviousByte < pointerToLastByte;)
        {
        TUint currentByte = *(pointerToPreviousByte + 1);
        if (currentByte == KSingleShift3)
            {
            pointerToPreviousByte++;
            currentByte = *(pointerToPreviousByte + 1);
            }
        else
            {
            break;
            }
        if (currentByte < 0xa0)
            {
            return CCnvCharacterSetConverter::EErrorIllFormedInput;
            }
        const TUint nextByte = *(pointerToPreviousByte + 2);
        if (nextByte < 0xa0)
            {
            return CCnvCharacterSetConverter::EErrorIllFormedInput;
            }
        if (((currentByte < KFirstByteRangeFirstBlockStart) ||
             (currentByte > KFirstByteRangeFirstBlockEnd)) ||
            ((nextByte < KSecondByteRangeSecondBlockStart) ||
             (nextByte > KSecondByteRangeSecondBlockEnd)))
            {
            // return the previous byte to the beginning of loop.
            pointerToPreviousByte--;
            break;
            }
        pointerToPreviousByte += 2;
        }
    return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::NumberOfBytesAbleToConvertToPicto1
// It returns a number of bytes that the conversion to pictograph is
// possible in the descriptor.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CnvPictographShared::NumberOfBytesAbleToConvertToPicto1(
        const TDesC8& aDescriptor)
    {
    return NumberOfBytesAbleToConvertToPictograph(aDescriptor,
        KIntermediateBuffer1);
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::NumberOfBytesAbleToConvertToPictograph
// It's a common function for checking the number of bytes that the conversion
// to pictograph
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CnvPictographShared::NumberOfBytesAbleToConvertToPictograph(
        const TDesC8& aDescriptor, TInt aIntermidiateCode)
    {
    TInt compLen(KLit8EscapeSequenceForPictograph().Length());
    TInt ret(0);
    if (aDescriptor.Left(compLen) == KLit8EscapeSequenceForPictograph)
        {
        const TInt intermidiateBuff = aDescriptor[compLen];
        if (intermidiateBuff == aIntermidiateCode)
            {
            ret = compLen + 2;

            const TInt descriptorLength = aDescriptor.Length();
            const TUint8* pointerToCurrentByte = aDescriptor.Ptr();
            const TUint8* pointerToLastByte = pointerToCurrentByte +
                (descriptorLength - 1);
            pointerToCurrentByte += compLen + 2;
            for (; pointerToCurrentByte <= pointerToLastByte;
                 pointerToCurrentByte++)
                {
                if (*pointerToCurrentByte == KShiftIn)
                    {
                    ret++;
                    break;
                    }
                if (*pointerToCurrentByte == KEscape)
                    break;
                ret++;
                }
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::ConvertToPictographFromUnicode
// It converts the string which includes a pictograph's escape sequence
// to unicode.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CnvPictographShared::ConvertToPictographFromUnicode(TDes8& aDescriptor)
    {
    const TInt descriptorLength = aDescriptor.Length();
    TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
    TUint8* pointerToDataByte = pointerToCurrentByte +
        KLit8EscapeSequenceForPictograph().Length();
    const TUint8* const pointerToLastByte = pointerToCurrentByte +
        (descriptorLength - 1);
    const TUint8* const pointerToFirstByte = pointerToCurrentByte;
    pointerToDataByte++;

    for (; pointerToDataByte <= pointerToLastByte; pointerToDataByte++)
        {
        if (*pointerToDataByte != KShiftIn)
            {
            *pointerToCurrentByte = *pointerToDataByte;
            pointerToCurrentByte++;
            }
        }
    aDescriptor.SetLength(pointerToCurrentByte - pointerToFirstByte);
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace
// Converts from EucJp packed Pictograph to Unicode
// -----------------------------------------------------------------------------
//
void CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace(TDes8& aDescriptor)
    {
    const TInt descriptorLength = aDescriptor.Length();
    TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
    const TUint8* pointerToSourceByte = pointerToTargetByte;
    const TUint8* const pointerToLastByte =
        pointerToSourceByte + (descriptorLength - 1);
    TInt bytesPerCharacter = 2;
    TInt sjisStartbyte = KSingleByteRangeFirstBlockStart;
    if (*pointerToSourceByte == KSingleShift3)
        {
        ++pointerToSourceByte;
        bytesPerCharacter = 3;
        sjisStartbyte = KEUCJPSecondBlockStart;
        }
    for (;pointerToSourceByte < pointerToLastByte; )
        {
        TUint firstByte = (*pointerToSourceByte
            - KFirstByteRangeFirstBlockStart) / 2 + sjisStartbyte;
        TUint secondByte = *(pointerToSourceByte + 1);
        if ((*pointerToSourceByte % 2) == 0)
            {
            secondByte += KSingleByteRangeSecondBlockStart - KSecondByteRangeSecondBlockStart
                + KEUCJPBlockSize + 1;
            if (secondByte >= KShiftJisTrailByteIllegal)
                secondByte++;
            }
        else
            {
            secondByte += KSingleByteRangeSecondBlockStart - KSecondByteRangeSecondBlockStart;
            if (secondByte >= KShiftJisTrailByteIllegal)
                secondByte++;
            }
        *pointerToTargetByte = static_cast<TUint8>(firstByte);

        ++pointerToTargetByte;
        *pointerToTargetByte = static_cast<TUint8>(secondByte);
        pointerToSourceByte += 2;
        ++pointerToTargetByte;
        }
    aDescriptor.SetLength((descriptorLength / bytesPerCharacter) * 2);
    }

// -----------------------------------------------------------------------------
// CnvPictographShared::AppendShiftIn
// It appends a shift-in code to the descriptor.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CnvPictographShared::AppendShiftIn(TDes8& aDescriptor,
        TInt& aNumberOfCharactersThatDroppedOut)
    {
    if (aDescriptor.MaxLength() > aDescriptor.Length())
        {
        aDescriptor.Append(KShiftIn);
        }
    else
        {
        aNumberOfCharactersThatDroppedOut++;
        }
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// SetCharacterSetsForPictograph()
// It sets parameters to SCharacterSet array.
// It called in ConvertFromUnicode().
// It makes possible that pictograph conversion is called from other
// conversion plug-ins.
// @since 2.6
// @param aArrayOfCharacterSets The conversion table array
// -----------------------------------------------------------------------------
//
EXPORT_C void SetCharacterSetsForPictograph(
            RArray<CnvUtilities::SCharacterSet>& aArrayOfCharacterSets)
    {
    CnvPictographShared::SetCharacterSetsForPictograph(aArrayOfCharacterSets);
    }

// -----------------------------------------------------------------------------
// SetCharacterSetsForPictograph()
// It sets parameters to SCharacterSet array.
// It called in ConvertFromUnicode().
// It makes possible that pictograph conversion is called from other
// conversion plug-ins.
// @since 2.6
// @param aArrayOfCharacterSets The conversion table array
// @param aOriginalCharset The character set
// -----------------------------------------------------------------------------
//
EXPORT_C void SetCharacterSetsForPictograph(
            RArray<CnvUtilities::SCharacterSet>& aArrayOfCharacterSets,
            TOriginalCharset aOriginalCharset)
    {
    CnvPictographShared::SetCharacterSetsForPictograph(aArrayOfCharacterSets,
                                                       aOriginalCharset);
    }

// -----------------------------------------------------------------------------
// SetMethodsForPictograph()
// It sets parameters to SMethod array.
// It called in ConvertToUnicode().
// It makes possible that pictograph conversion is called from other
// conversion plug-ins.
// @since 2.6
// @param aArrayOfMethods The conversion table array
// @param aOriginalCharset The character set
// -----------------------------------------------------------------------------
//
EXPORT_C void SetMethodsForPictograph(
            RArray<CnvUtilities::SMethod>& aArrayOfMethods,
            TOriginalCharset aOriginalCharset)
    {
    CnvPictographShared::SetMethodsForPictograph(aArrayOfMethods,
        aOriginalCharset);
    }

// -----------------------------------------------------------------------------
// SetStatesForPictograph()
// It sets parameters to SState array.
// It called in ConvertToUnicode().
// It makes possible that pictograph conversion is called from other
// conversion plug-ins.
// @since 2.6
// @param aArrayOfMethods The conversion table array
// -----------------------------------------------------------------------------
//
EXPORT_C void SetStatesForPictograph(
            RArray<CnvUtilities::SState>& aArrayOfStates)
    {
    CnvPictographShared::SetStatesForPictograph(aArrayOfStates);
    }

// -----------------------------------------------------------------------------
// CountOfPictographPagesFromUnicode()
// It returns count of pictograph pages.
// This method is used for the conversion from Unicode to foreign character
// set.
// @since 2.6
// @return count of pictograph pages.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CountOfPictographPagesFromUnicode()
    {
    return KCountOfPictoPages;
    }

// -----------------------------------------------------------------------------
// CountOfPictographPagesToUnicode()
// It returns count of pictograph pages.
// This method is used for the conversion from foreign character set to
// Unicode.
// @since 2.6
// @return count of pictograph pages.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CountOfPictographPagesToUnicode()
    {
    return KCountOfPictoPages + 1;
    }

//  End of File
