/*

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

     {

     TInt ret = KErrNone;

     CnvUtilities::SMethod method;

     switch (aOriginalCharset)

         {

         case ECharsetShiftJis:

             method.iNumberOfBytesAbleToConvert =

                 CnvPictographShared::NumberOfBytesAbleToConvertSJisDirectMap;

             method.iConvertToIntermediateBufferInPlace =

                 DummyConvertToIntermediateBufferInPlace;

             method.iConversionData =

                 &CnvShiftJisDirectmap::ConversionData();

             method.iNumberOfBytesPerCharacter = 2;

             method.iNumberOfCoreBytesPerCharacter = 2;

             ret |= aArrayOfMethods.Append(method);

             break;

         case ECharsetEucJp:

             method.iNumberOfBytesAbleToConvert =

                 CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap1;

             method.iConvertToIntermediateBufferInPlace =

                 CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace;

             method.iConversionData =

                 &CnvShiftJisDirectmap::ConversionData();

             method.iNumberOfBytesPerCharacter = 2;

             method.iNumberOfCoreBytesPerCharacter = 2;

             ret |= aArrayOfMethods.Append(method);

             method.iNumberOfBytesAbleToConvert =

                 CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap2;

             method.iConvertToIntermediateBufferInPlace =

                 CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace;

             method.iConversionData =

                 &CnvShiftJisDirectmap::ConversionData();

             method.iNumberOfBytesPerCharacter = 3;

             method.iNumberOfCoreBytesPerCharacter = 2;

             ret |= aArrayOfMethods.Append(method);

             break;

         default:

             break;

         }

     __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));

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

     {

     TInt ret = KErrNone;

     CnvUtilities::SCharacterSet characterSet;

     switch (aOriginalCharset)

         {

         case ECharsetShiftJis:

             // Append the character set for pictograph

             characterSet.iConversionData =

                 &CnvShiftJisDirectmap::ConversionData();

             characterSet.iConvertFromIntermediateBufferInPlace =

                 DummyConvertFromIntermediateBufferInPlace;

             characterSet.iEscapeSequence = &KNullDesC8;

             ret |= aArrayOfStates.Append(characterSet);

             break;

         case ECharsetEucJp:

             // Append the character set for pictograph1

             characterSet.iConversionData = &CnvShiftJisDirectmap::ConversionData();

             characterSet.iConvertFromIntermediateBufferInPlace =

                 ConvertFromPictogaphToEucJpDirectmapInPlace;

             characterSet.iEscapeSequence = &KNullDesC8;

             ret |= aArrayOfStates.Append(characterSet);

             // Append the character set for pictograph2

             characterSet.iConversionData = &CnvShiftJisDirectmap::ConversionData();

             characterSet.iConvertFromIntermediateBufferInPlace =

                 ConvertFromPictogaphToEucJpDirectmapInPlace;

             characterSet.iEscapeSequence = &KNullDesC8;

             ret |= aArrayOfStates.Append(characterSet);

             break;

         default:

             break;

         }

     __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));

     }

 // -----------------------------------------------------------------------------

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