charconvfw/Charconv/ongoing/Source/foreign/plugins/ISO2022JP1.CPP
changeset 0 1fb32624e06b
equal deleted inserted replaced
-1:000000000000 0:1fb32624e06b
       
     1 /*
       
     2 * Copyright (c) 2022 Nokia Corporation and/or its subsidiary(-ies). 
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:      
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 
       
    21 
       
    22 
       
    23 
       
    24 #include <bldvariant.hrh>
       
    25 #include "PictographObserver.h"
       
    26 #include <featmgr.h> 
       
    27 
       
    28 #include <e32std.h>
       
    29 #include <charconv.h>
       
    30 #include <convutils.h>
       
    31 #include <JISBASE.H>
       
    32 #include <jisx0201.h>
       
    33 #include <jisx0208.h>
       
    34 #include <jisx0212.h>
       
    35 #include <ecom/implementationproxy.h>
       
    36 #include "charactersetconverter.h"
       
    37 
       
    38 _LIT8(KLit8EscapeSequenceForJisRoman, "\x1b\x28\x4a");
       
    39 _LIT8(KLit8EscapeSequenceForAscii, "\x1b\x28\x42");
       
    40 _LIT8(KLit8EscapeSequenceForJisC6226_1978, "\x1b\x24\x40");
       
    41 _LIT8(KLit8EscapeSequenceForJisX0208_1983, "\x1b\x24\x42");
       
    42 _LIT8(KLit8EscapeSequenceForJisX0212_1990, "\x1b\x24\x28\x44");
       
    43 _LIT8(KLit8EscapeSequenceForHalfWidthKatakana, "\x1b\x28\x49");
       
    44 _LIT8(KLit8Iso2022Jp1ReplacementForUnconvertibleUnicodeCharacters, "\x1b\x24\x42\x21\x29"); // fullwidth question mark
       
    45 
       
    46 
       
    47 class CISO2022JP1ConverterImpl : public CCharacterSetConverterPluginInterface
       
    48 	{
       
    49 
       
    50 public:
       
    51 	virtual const TDesC8& ReplacementForUnconvertibleUnicodeCharacters();
       
    52 
       
    53 	virtual TInt ConvertFromUnicode(
       
    54 		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 
       
    55 		const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 
       
    56 		TDes8& aForeign, 
       
    57 		const TDesC16& aUnicode, 
       
    58 		CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters);
       
    59 
       
    60 	virtual TInt ConvertToUnicode(
       
    61 		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 
       
    62 		TDes16& aUnicode, 
       
    63 		const TDesC8& aForeign, 
       
    64 		TInt& aState, 
       
    65 		TInt& aNumberOfUnconvertibleCharacters, 
       
    66 		TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter);
       
    67 
       
    68 	virtual TBool IsInThisCharacterSetL(
       
    69 		TBool& aSetToTrue, 
       
    70 		TInt& aConfidenceLevel, 
       
    71 		const TDesC8& aSample);
       
    72 
       
    73 	static CISO2022JP1ConverterImpl* NewL();
       
    74 	virtual ~CISO2022JP1ConverterImpl();
       
    75 
       
    76 private:
       
    77 	CISO2022JP1ConverterImpl();
       
    78 	void ConstructL();
       
    79 
       
    80 	};
       
    81 
       
    82 
       
    83 const TDesC8& CISO2022JP1ConverterImpl::ReplacementForUnconvertibleUnicodeCharacters()
       
    84 	{
       
    85 	return KLit8Iso2022Jp1ReplacementForUnconvertibleUnicodeCharacters;
       
    86 	}
       
    87 
       
    88 LOCAL_C void ConvertFromJisRomanToJisInPlace(TInt aStartPositionInDescriptor, TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
       
    89 	{
       
    90 	CnvUtilities::ConvertFromIntermediateBufferInPlace(aStartPositionInDescriptor, aDescriptor, aNumberOfCharactersThatDroppedOut, KLit8EscapeSequenceForJisRoman, 1);
       
    91 	}
       
    92 
       
    93 LOCAL_C void ConvertFromAsciiToJisInPlace(TInt aStartPositionInDescriptor, TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
       
    94 	{
       
    95 	CnvUtilities::ConvertFromIntermediateBufferInPlace(aStartPositionInDescriptor, aDescriptor, aNumberOfCharactersThatDroppedOut, KLit8EscapeSequenceForAscii, 1);
       
    96 	}
       
    97 
       
    98 LOCAL_C void ConvertFromJisX0208ToJisInPlace(TInt aStartPositionInDescriptor, TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
       
    99 	{
       
   100 	CnvUtilities::ConvertFromIntermediateBufferInPlace(aStartPositionInDescriptor, aDescriptor, aNumberOfCharactersThatDroppedOut, KLit8EscapeSequenceForJisX0208_1983, 2);
       
   101 	}
       
   102 
       
   103 LOCAL_C void ConvertFromJisX0212ToJisInPlace(TInt aStartPositionInDescriptor, TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
       
   104 	{
       
   105 	CnvUtilities::ConvertFromIntermediateBufferInPlace(aStartPositionInDescriptor, aDescriptor, aNumberOfCharactersThatDroppedOut, KLit8EscapeSequenceForJisX0212_1990, 2);
       
   106 	}
       
   107 
       
   108 TInt CISO2022JP1ConverterImpl::ConvertFromUnicode(
       
   109 		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 
       
   110 		const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 
       
   111 		TDes8& aForeign, 
       
   112 		const TDesC16& aUnicode, 
       
   113 		CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)
       
   114 	{
       
   115     RArray<CnvUtilities::SCharacterSet> characterSets;
       
   116     if ( FeatureManager::FeatureSupported(KFeatureIdJapanesePicto) )
       
   117         {        
       
   118         CnvUtilities::SCharacterSet characterSet;
       
   119         characterSet.iConversionData=&CnvJisRoman::ConversionData();
       
   120         characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromJisRomanToJisInPlace;
       
   121         characterSet.iEscapeSequence=&KLit8EscapeSequenceForJisRoman;
       
   122         characterSets.Append(characterSet);
       
   123         characterSet.iConversionData=&CCnvCharacterSetConverter::AsciiConversionData();
       
   124         characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromAsciiToJisInPlace;
       
   125         characterSet.iEscapeSequence=&KLit8EscapeSequenceForAscii;
       
   126         characterSets.Append(characterSet);
       
   127         characterSet.iConversionData=&CnvJisX0208::ConversionData();
       
   128         characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromJisX0208ToJisInPlace;
       
   129         characterSet.iEscapeSequence=&KLit8EscapeSequenceForJisX0208_1983;
       
   130         characterSets.Append(characterSet);
       
   131         characterSet.iConversionData=&CnvJisX0212::ConversionData();
       
   132         characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromJisX0212ToJisInPlace;
       
   133         characterSet.iEscapeSequence=&KLit8EscapeSequenceForJisX0212_1990;
       
   134         characterSets.Append(characterSet);
       
   135 
       
   136         SetCharacterSetsForPictograph(characterSets);
       
   137         }
       
   138     else
       
   139         {        
       
   140         CnvUtilities::SCharacterSet characterSet;
       
   141 	    characterSet.iConversionData=&CnvJisRoman::ConversionData();
       
   142 	    characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromJisRomanToJisInPlace;
       
   143 	    characterSet.iEscapeSequence=&KLit8EscapeSequenceForJisRoman;
       
   144         characterSets.Append(characterSet);
       
   145     	characterSet.iConversionData=&CCnvCharacterSetConverter::AsciiConversionData();
       
   146     	characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromAsciiToJisInPlace;
       
   147     	characterSet.iEscapeSequence=&KLit8EscapeSequenceForAscii;
       
   148         characterSets.Append(characterSet);
       
   149     	characterSet.iConversionData=&CnvJisX0208::ConversionData();
       
   150     	characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromJisX0208ToJisInPlace;
       
   151     	characterSet.iEscapeSequence=&KLit8EscapeSequenceForJisX0208_1983;
       
   152         characterSets.Append(characterSet);
       
   153     	characterSet.iConversionData=&CnvJisX0212::ConversionData();
       
   154     	characterSet.iConvertFromIntermediateBufferInPlace=ConvertFromJisX0212ToJisInPlace;
       
   155     	characterSet.iEscapeSequence=&KLit8EscapeSequenceForJisX0212_1990;
       
   156         characterSets.Append(characterSet);
       
   157         }
       
   158 	TUint notUsed;
       
   159 	TUint inputConversionFlags=CCnvCharacterSetConverter::EInputConversionFlagMustEndInDefaultCharacterSet;
       
   160     TInt unconvert = CnvUtilities::ConvertFromUnicode(aDefaultEndiannessOfForeignCharacters, aReplacementForUnconvertibleUnicodeCharacters, aForeign, aUnicode, aIndicesOfUnconvertibleCharacters, 
       
   161         characterSets.Array(),notUsed,inputConversionFlags);
       
   162 
       
   163     characterSets.Close();
       
   164     return unconvert;
       
   165 	}
       
   166 
       
   167 TInt CISO2022JP1ConverterImpl::ConvertToUnicode(
       
   168 		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 
       
   169 		TDes16& aUnicode, 
       
   170 		const TDesC8& aForeign, 
       
   171 		TInt& aState, 
       
   172 		TInt& aNumberOfUnconvertibleCharacters, 
       
   173 		TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)
       
   174 	{
       
   175 	return CnvJisBase::ConvertToUnicode(aDefaultEndiannessOfForeignCharacters, aUnicode, aForeign, aState, aNumberOfUnconvertibleCharacters, aIndexOfFirstByteOfFirstUnconvertibleCharacter);
       
   176 	}
       
   177 
       
   178 TBool CISO2022JP1ConverterImpl::IsInThisCharacterSetL(
       
   179 		TBool& aSetToTrue, 
       
   180 		TInt& aConfidenceLevel, 
       
   181 		const TDesC8& aSample)
       
   182 	{
       
   183 	aSetToTrue=ETrue;
       
   184 	CnvJisBase::IsCharacterJISBased(aConfidenceLevel, aSample);
       
   185 	return ETrue;
       
   186 	}
       
   187 
       
   188 CISO2022JP1ConverterImpl* CISO2022JP1ConverterImpl::NewL()
       
   189 	{
       
   190 	CISO2022JP1ConverterImpl* self = new(ELeave) CISO2022JP1ConverterImpl();
       
   191 	CleanupStack::PushL(self);
       
   192 	self->ConstructL();
       
   193 	CleanupStack::Pop(self);
       
   194 	return self;
       
   195 	}
       
   196 
       
   197 CISO2022JP1ConverterImpl::~CISO2022JP1ConverterImpl()
       
   198 	{
       
   199 	FeatureManager::UnInitializeLib();
       
   200 	}
       
   201 
       
   202 CISO2022JP1ConverterImpl::CISO2022JP1ConverterImpl()
       
   203 	{
       
   204 	}
       
   205 
       
   206 void CISO2022JP1ConverterImpl::ConstructL()
       
   207 	{
       
   208 	FeatureManager::InitializeLibL();
       
   209 	}
       
   210 
       
   211 const TImplementationProxy ImplementationTable[] = 
       
   212 	{
       
   213 		IMPLEMENTATION_PROXY_ENTRY(0x100066A3,	CISO2022JP1ConverterImpl::NewL)
       
   214 	};
       
   215 
       
   216 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
       
   217 	{
       
   218 	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
       
   219 
       
   220 	return ImplementationTable;
       
   221 	}
       
   222