1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/textandloc/charconvfw/charconvplugins/src/shared/CnvPictographShared.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,712 @@
1.4 +/*
1.5 +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
1.6 +* All rights reserved.
1.7 +* This component and the accompanying materials are made available
1.8 +* under the terms of "Eclipse Public License v1.0"
1.9 +* which accompanies this distribution, and is available
1.10 +* at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.11 +*
1.12 +* Initial Contributors:
1.13 +* Nokia Corporation - initial contribution.
1.14 +*
1.15 +* Contributors:
1.16 +*
1.17 +* Description: This class is a utitlity class for conversion of Vodafone
1.18 +* pictograph.
1.19 +*
1.20 +*/
1.21 +
1.22 +
1.23 +
1.24 +
1.25 +
1.26 +
1.27 +
1.28 +
1.29 +// PICTOGRAPH_SHARED.CPP
1.30 +//
1.31 +//
1.32 +
1.33 +#include "CnvPictographShared.h"
1.34 +// #include "CnvPictograph1.h"
1.35 +#include "CnvShiftJisDirectmap.h"
1.36 +#include <convgeneratedcpp.h>
1.37 +
1.38 +
1.39 +// CONSTANTS
1.40 +// Escape sequence for Vodafone pictograph
1.41 +_LIT8(KLit8EscapeSequenceForPictograph, "\x1b\x24");
1.42 +// _LIT8(KLit8EscapeSequenceForPictograph1, "\x1b\x24\x47");
1.43 +
1.44 +const TInt KEscape = 0x1B;
1.45 +const TInt KShiftIn = 0x0F;
1.46 +
1.47 +// Intermidiate buffers for pictograph
1.48 +const TInt KIntermediateBuffer1 = 'G';
1.49 +
1.50 +const TUint KSingleByteRangeFirstBlockStart = 0xF0;
1.51 +const TUint KSingleByteRangeFirstBlockEnd = 0xF9;
1.52 +const TUint KSingleByteRangeSecondBlockStart = 0x40;
1.53 +const TUint KSingleByteRangeSecondBlockEnd = 0xFC;
1.54 +
1.55 +const TUint KFirstByteRangeFirstBlockStart = 0xF5;
1.56 +const TUint KFirstByteRangeFirstBlockEnd = 0xFE;
1.57 +const TUint KSecondByteRangeSecondBlockStart = 0xA1;
1.58 +const TUint KSecondByteRangeSecondBlockEnd = 0xFE;
1.59 +
1.60 +const TUint KEUCJPSecondBlockStart = 0xF5;
1.61 +const TUint KEUCJPBlockSize = 0x5D;
1.62 +const TUint KSingleShift3=0x8f;
1.63 +// used for EucJp
1.64 +const TUint KPictographStartFirstByte = 0xF0;
1.65 +const TUint KPictographStartSecondByte = 0x40;
1.66 +const TUint KShiftJisTrailByteIllegal = 0x7F;
1.67 +
1.68 +// ============================ LOCAL FUNCTIONS ===============================
1.69 +
1.70 +
1.71 +// -----------------------------------------------------------------------------
1.72 +// DummyConvertToIntermediateBufferInPlace ?description.
1.73 +//
1.74 +// -----------------------------------------------------------------------------
1.75 +//
1.76 +LOCAL_C void DummyConvertToIntermediateBufferInPlace(TDes8&)
1.77 + {
1.78 + }
1.79 +
1.80 +// -----------------------------------------------------------------------------
1.81 +// DummyConvertFromIntermediateBufferInPlace
1.82 +//
1.83 +// -----------------------------------------------------------------------------
1.84 +//
1.85 +LOCAL_C void DummyConvertFromIntermediateBufferInPlace(TInt, TDes8&,
1.86 + TInt& aNumberOfCharactersThatDroppedOut)
1.87 + {
1.88 + aNumberOfCharactersThatDroppedOut=0;
1.89 + }
1.90 +
1.91 +// -----------------------------------------------------------------------------
1.92 +// ConvertFromPictogaphToEucJpDirectmapInPlace
1.93 +// Converts from EucJp packed Pictograph to Unicode
1.94 +// -----------------------------------------------------------------------------
1.95 +//
1.96 +LOCAL_C void ConvertFromPictogaphToEucJpDirectmapInPlace(
1.97 + TInt aStartPositionInDescriptor, TDes8& aDescriptor,
1.98 + TInt& aNumberOfCharactersThatDroppedOut)
1.99 + {
1.100 + TInt descriptorLength=aDescriptor.Length();
1.101 + TInt bytesPerCharacter = 2;
1.102 + if (aDescriptor[0] >= KEUCJPSecondBlockStart)
1.103 + {
1.104 + bytesPerCharacter = 3;
1.105 + }
1.106 +
1.107 + aNumberOfCharactersThatDroppedOut =
1.108 + Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -
1.109 + ((aDescriptor.MaxLength() - aStartPositionInDescriptor) /
1.110 + bytesPerCharacter));
1.111 + descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;
1.112 + if (descriptorLength <= aStartPositionInDescriptor)
1.113 + {
1.114 + aDescriptor.SetLength(descriptorLength);
1.115 + }
1.116 + else
1.117 + {
1.118 + // pointerToTargetByte is initialized properly when descriptorLength
1.119 + // has been offset to the actual final length of aDescriptor
1.120 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.121 + const TUint8* const pointerToFirstByte =
1.122 + pointerToTargetByte + aStartPositionInDescriptor;
1.123 + const TUint8* pointerToSourceByte =
1.124 + pointerToTargetByte + (descriptorLength - 1);
1.125 + descriptorLength = (((descriptorLength - aStartPositionInDescriptor)
1.126 + * bytesPerCharacter) / 2) + aStartPositionInDescriptor;
1.127 + aDescriptor.SetLength(descriptorLength);
1.128 + // pointerToTargetByte is is initialized properly here
1.129 + pointerToTargetByte += descriptorLength - 1;
1.130 + for (;pointerToTargetByte > pointerToFirstByte; )
1.131 + {
1.132 + TInt secondByte = *pointerToSourceByte;
1.133 + TInt firstByte = *(pointerToSourceByte - 1);
1.134 +
1.135 + if (bytesPerCharacter == 3)
1.136 + {
1.137 + firstByte = (firstByte - KEUCJPSecondBlockStart) * 2 +
1.138 + KFirstByteRangeFirstBlockStart;
1.139 + }
1.140 + else
1.141 + {
1.142 + firstByte = (firstByte - KPictographStartFirstByte) * 2 +
1.143 + KFirstByteRangeFirstBlockStart;
1.144 + }
1.145 + if (static_cast<TInt>(KEUCJPBlockSize + KPictographStartSecondByte + 1)
1.146 + < secondByte)
1.147 + {
1.148 + if (secondByte > KShiftJisTrailByteIllegal)
1.149 + secondByte -= 1;
1.150 + secondByte = secondByte -(KPictographStartSecondByte +
1.151 + KEUCJPBlockSize + 1) + KSecondByteRangeSecondBlockStart;
1.152 + firstByte++;
1.153 + }
1.154 + else
1.155 + {
1.156 + if (secondByte > KShiftJisTrailByteIllegal)
1.157 + secondByte -= 1;
1.158 + secondByte += KSecondByteRangeSecondBlockStart - KPictographStartSecondByte;
1.159 + }
1.160 + *pointerToTargetByte = static_cast<TUint8>(secondByte);
1.161 + --pointerToTargetByte;
1.162 + *pointerToTargetByte = static_cast<TUint8>(firstByte);
1.163 + if (bytesPerCharacter == 3)
1.164 + {
1.165 + --pointerToTargetByte;
1.166 + *pointerToTargetByte = KSingleShift3;
1.167 + }
1.168 + --pointerToTargetByte;
1.169 + pointerToSourceByte -= 2;
1.170 + }
1.171 + }
1.172 + }
1.173 +
1.174 +// ============================ MEMBER FUNCTIONS ===============================
1.175 +
1.176 +// -----------------------------------------------------------------------------
1.177 +// CnvPictographShared::SetCharacterSetsForPictograph
1.178 +// It sets parameters to SCharacterSet array. It called in ConvertFromUnicode().
1.179 +// It makes possible that pictograph conversion is called from other conversion
1.180 +// plug-ins.
1.181 +// (other items were commented in a header).
1.182 +// -----------------------------------------------------------------------------
1.183 +//
1.184 +void CnvPictographShared::SetCharacterSetsForPictograph(
1.185 + RArray<CnvUtilities::SCharacterSet>& /*aArrayOfCharacterSets*/)
1.186 + {
1.187 + // SAMPLE CODE
1.188 + // If this module needs to support escape sequence pictograph,
1.189 + // Remove the comment from the following code.
1.190 +
1.191 + // CnvUtilities::SCharacterSet characterSet;
1.192 + // characterSet.iConversionData = &CnvPictograph1::ConversionData();
1.193 + // characterSet.iConvertFromIntermediateBufferInPlace =
1.194 + // CnvPictographShared::ConvertToPictograph1InPlace;
1.195 + // characterSet.iEscapeSequence = &KLit8EscapeSequenceForPictograph1;
1.196 + // aArrayOfCharacterSets.Append(characterSet);
1.197 +
1.198 + }
1.199 +
1.200 +// -----------------------------------------------------------------------------
1.201 +// CnvPictographShared::SetMethodsForPictograph
1.202 +// It sets parameters to SMethod array. It called in ConvertToUnicode().
1.203 +// It makes possible that pictograph conversion is called from other conversion
1.204 +// plug-ins.
1.205 +// (other items were commented in a header).
1.206 +// -----------------------------------------------------------------------------
1.207 +//
1.208 +void CnvPictographShared::SetMethodsForPictograph(
1.209 + RArray<CnvUtilities::SMethod>& aArrayOfMethods, TOriginalCharset aOriginalCharset)
1.210 + {
1.211 + TInt ret = KErrNone;
1.212 + CnvUtilities::SMethod method;
1.213 + switch (aOriginalCharset)
1.214 + {
1.215 + case ECharsetShiftJis:
1.216 + method.iNumberOfBytesAbleToConvert =
1.217 + CnvPictographShared::NumberOfBytesAbleToConvertSJisDirectMap;
1.218 + method.iConvertToIntermediateBufferInPlace =
1.219 + DummyConvertToIntermediateBufferInPlace;
1.220 + method.iConversionData =
1.221 + &CnvShiftJisDirectmap::ConversionData();
1.222 + method.iNumberOfBytesPerCharacter = 2;
1.223 + method.iNumberOfCoreBytesPerCharacter = 2;
1.224 + ret |= aArrayOfMethods.Append(method);
1.225 + break;
1.226 + case ECharsetEucJp:
1.227 + method.iNumberOfBytesAbleToConvert =
1.228 + CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap1;
1.229 + method.iConvertToIntermediateBufferInPlace =
1.230 + CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace;
1.231 + method.iConversionData =
1.232 + &CnvShiftJisDirectmap::ConversionData();
1.233 + method.iNumberOfBytesPerCharacter = 2;
1.234 + method.iNumberOfCoreBytesPerCharacter = 2;
1.235 + ret |= aArrayOfMethods.Append(method);
1.236 + method.iNumberOfBytesAbleToConvert =
1.237 + CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap2;
1.238 + method.iConvertToIntermediateBufferInPlace =
1.239 + CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace;
1.240 + method.iConversionData =
1.241 + &CnvShiftJisDirectmap::ConversionData();
1.242 + method.iNumberOfBytesPerCharacter = 3;
1.243 + method.iNumberOfCoreBytesPerCharacter = 2;
1.244 + ret |= aArrayOfMethods.Append(method);
1.245 + break;
1.246 + default:
1.247 + break;
1.248 + }
1.249 + __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));
1.250 + // SAMPLE CODE
1.251 + // If this module needs to support escape sequence pictograph,
1.252 + // Remove the comment from the following code.
1.253 +
1.254 + // method.iNumberOfBytesAbleToConvert =
1.255 + // CnvPictographShared::NumberOfBytesAbleToConvertToPicto1;
1.256 + // method.iConvertToIntermediateBufferInPlace =
1.257 + // CnvPictographShared::ConvertToPictographFromUnicode;
1.258 + // method.iConversionData = &CnvPictograph1::ConversionData();
1.259 + // method.iNumberOfBytesPerCharacter = 1;
1.260 + // method.iNumberOfCoreBytesPerCharacter = 1;
1.261 + // aArrayOfMethods.Append(method);
1.262 + }
1.263 +
1.264 +// -----------------------------------------------------------------------------
1.265 +// CnvPictographShared::SetCharacterSetsForPictograph
1.266 +// It sets parameters to SState array. It called in ConvertToUnicode().
1.267 +// It makes possible that pictograph conversion is called from other
1.268 +// conversion plug-ins.
1.269 +// (other items were commented in a header).
1.270 +// -----------------------------------------------------------------------------
1.271 +//
1.272 +void CnvPictographShared::SetCharacterSetsForPictograph(
1.273 + RArray<CnvUtilities::SCharacterSet>& aArrayOfStates,
1.274 + TOriginalCharset aOriginalCharset)
1.275 + {
1.276 + TInt ret = KErrNone;
1.277 + CnvUtilities::SCharacterSet characterSet;
1.278 + switch (aOriginalCharset)
1.279 + {
1.280 + case ECharsetShiftJis:
1.281 + // Append the character set for pictograph
1.282 + characterSet.iConversionData =
1.283 + &CnvShiftJisDirectmap::ConversionData();
1.284 + characterSet.iConvertFromIntermediateBufferInPlace =
1.285 + DummyConvertFromIntermediateBufferInPlace;
1.286 + characterSet.iEscapeSequence = &KNullDesC8;
1.287 + ret |= aArrayOfStates.Append(characterSet);
1.288 + break;
1.289 + case ECharsetEucJp:
1.290 + // Append the character set for pictograph1
1.291 + characterSet.iConversionData = &CnvShiftJisDirectmap::ConversionData();
1.292 + characterSet.iConvertFromIntermediateBufferInPlace =
1.293 + ConvertFromPictogaphToEucJpDirectmapInPlace;
1.294 + characterSet.iEscapeSequence = &KNullDesC8;
1.295 + ret |= aArrayOfStates.Append(characterSet);
1.296 +
1.297 + // Append the character set for pictograph2
1.298 + characterSet.iConversionData = &CnvShiftJisDirectmap::ConversionData();
1.299 + characterSet.iConvertFromIntermediateBufferInPlace =
1.300 + ConvertFromPictogaphToEucJpDirectmapInPlace;
1.301 + characterSet.iEscapeSequence = &KNullDesC8;
1.302 + ret |= aArrayOfStates.Append(characterSet);
1.303 + break;
1.304 + default:
1.305 + break;
1.306 + }
1.307 + __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));
1.308 + }
1.309 +
1.310 +// -----------------------------------------------------------------------------
1.311 +// CnvPictographShared::SetStatesForPictograph
1.312 +// It sets parameters to SState array. It called in ConvertToUnicode().
1.313 +// It makes possible that pictograph conversion is called from other
1.314 +// conversion plug-ins.
1.315 +// (other items were commented in a header).
1.316 +// -----------------------------------------------------------------------------
1.317 +//
1.318 +void CnvPictographShared::SetStatesForPictograph(
1.319 + RArray<CnvUtilities::SState>& /*aArrayOfStates*/)
1.320 + {
1.321 + // SAMPLE CODE
1.322 + // If this module needs to support escape sequence pictograph,
1.323 + // Remove the comment from the following code.
1.324 +
1.325 + // CnvUtilities::SState state;
1.326 + // state.iEscapeSequence = &KLit8EscapeSequenceForPictograph1;
1.327 + // state.iConversionData = &CnvPictograph1::ConversionData();
1.328 + // aArrayOfStates.Append(state);
1.329 + }
1.330 +
1.331 +// -----------------------------------------------------------------------------
1.332 +// CnvPictographShared::ConvertToPictograph1InPlace
1.333 +// It converts from an intermediate buffer to a pictograph code.
1.334 +// After that, it adds shift-in code(0x0F).
1.335 +// (other items were commented in a header).
1.336 +// -----------------------------------------------------------------------------
1.337 +//
1.338 +// void CnvPictographShared::ConvertToPictograph1InPlace(
1.339 +// TInt aStartPositionInDescriptor,
1.340 +// TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
1.341 +// {
1.342 +// CnvUtilities::ConvertFromIntermediateBufferInPlace(
1.343 +// aStartPositionInDescriptor, aDescriptor,
1.344 +// aNumberOfCharactersThatDroppedOut,
1.345 +// KLit8EscapeSequenceForPictograph1, 1);
1.346 +// AppendShiftIn(aDescriptor, aNumberOfCharactersThatDroppedOut);
1.347 +// }
1.348 +
1.349 +
1.350 +// -----------------------------------------------------------------------------
1.351 +// CnvPictographShared::NumberOfBytesAbleToConvertToPicto1
1.352 +// It returns a number of bytes that the conversion to pictograph is
1.353 +// possible in the descriptor.
1.354 +// (other items were commented in a header).
1.355 +// -----------------------------------------------------------------------------
1.356 +//
1.357 +TInt CnvPictographShared::NumberOfBytesAbleToConvertSJisDirectMap(
1.358 + const TDesC8& aDescriptor)
1.359 + {
1.360 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr()-1;
1.361 + const TUint8* const pointerToLastByte =
1.362 + pointerToPreviousByte + aDescriptor.Length();
1.363 + if (pointerToPreviousByte == pointerToLastByte)
1.364 + {
1.365 + return 0;
1.366 + }
1.367 + for (; pointerToPreviousByte < pointerToLastByte; )
1.368 + {
1.369 + const TUint currentByte = *(pointerToPreviousByte + 1);
1.370 + const TUint nextByte = *(pointerToPreviousByte + 2);
1.371 + if (((currentByte < KSingleByteRangeFirstBlockStart) ||
1.372 + (currentByte > KSingleByteRangeFirstBlockEnd)) ||
1.373 + ((nextByte < KSingleByteRangeSecondBlockStart) ||
1.374 + (nextByte > KSingleByteRangeSecondBlockEnd)))
1.375 + {
1.376 + break;
1.377 + }
1.378 + pointerToPreviousByte += 2;
1.379 + }
1.380 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.381 + }
1.382 +
1.383 +// -----------------------------------------------------------------------------
1.384 +// NumberOfBytesAbleToConvertToEucJpDirectMap1
1.385 +//
1.386 +// -----------------------------------------------------------------------------
1.387 +//
1.388 +TInt CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap1(
1.389 + const TDesC8& aDescriptor)
1.390 + {
1.391 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.392 + const TUint8* const pointerToLastByte =
1.393 + pointerToPreviousByte + aDescriptor.Length();
1.394 + if (pointerToPreviousByte == pointerToLastByte)
1.395 + {
1.396 + return 0;
1.397 + }
1.398 + for (;pointerToPreviousByte < pointerToLastByte;)
1.399 + {
1.400 + TUint currentByte = *(pointerToPreviousByte + 1);
1.401 + const TUint nextByte = *(pointerToPreviousByte + 2);
1.402 + if (((currentByte < KFirstByteRangeFirstBlockStart) ||
1.403 + (currentByte > KFirstByteRangeFirstBlockEnd)) ||
1.404 + ((nextByte < KSecondByteRangeSecondBlockStart) ||
1.405 + (nextByte > KSecondByteRangeSecondBlockEnd)))
1.406 + {
1.407 + break;
1.408 + }
1.409 + pointerToPreviousByte += 2;
1.410 + }
1.411 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.412 + }
1.413 +
1.414 +// -----------------------------------------------------------------------------
1.415 +// NumberOfBytesAbleToConvertToPictograph
1.416 +//
1.417 +// -----------------------------------------------------------------------------
1.418 +//
1.419 +TInt CnvPictographShared::NumberOfBytesAbleToConvertToEucJpDirectMap2(
1.420 + const TDesC8& aDescriptor)
1.421 + {
1.422 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.423 + const TUint8* const pointerToLastByte =
1.424 + pointerToPreviousByte + aDescriptor.Length();
1.425 + if (pointerToPreviousByte == pointerToLastByte)
1.426 + {
1.427 + return 0;
1.428 + }
1.429 + for (;pointerToPreviousByte < pointerToLastByte;)
1.430 + {
1.431 + TUint currentByte = *(pointerToPreviousByte + 1);
1.432 + if (currentByte == KSingleShift3)
1.433 + {
1.434 + pointerToPreviousByte++;
1.435 + currentByte = *(pointerToPreviousByte + 1);
1.436 + }
1.437 + else
1.438 + {
1.439 + break;
1.440 + }
1.441 + if (currentByte < 0xa0)
1.442 + {
1.443 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.444 + }
1.445 + const TUint nextByte = *(pointerToPreviousByte + 2);
1.446 + if (nextByte < 0xa0)
1.447 + {
1.448 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.449 + }
1.450 + if (((currentByte < KFirstByteRangeFirstBlockStart) ||
1.451 + (currentByte > KFirstByteRangeFirstBlockEnd)) ||
1.452 + ((nextByte < KSecondByteRangeSecondBlockStart) ||
1.453 + (nextByte > KSecondByteRangeSecondBlockEnd)))
1.454 + {
1.455 + // return the previous byte to the beginning of loop.
1.456 + pointerToPreviousByte--;
1.457 + break;
1.458 + }
1.459 + pointerToPreviousByte += 2;
1.460 + }
1.461 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.462 + }
1.463 +
1.464 +// -----------------------------------------------------------------------------
1.465 +// CnvPictographShared::NumberOfBytesAbleToConvertToPicto1
1.466 +// It returns a number of bytes that the conversion to pictograph is
1.467 +// possible in the descriptor.
1.468 +// (other items were commented in a header).
1.469 +// -----------------------------------------------------------------------------
1.470 +//
1.471 +TInt CnvPictographShared::NumberOfBytesAbleToConvertToPicto1(
1.472 + const TDesC8& aDescriptor)
1.473 + {
1.474 + return NumberOfBytesAbleToConvertToPictograph(aDescriptor,
1.475 + KIntermediateBuffer1);
1.476 + }
1.477 +
1.478 +// -----------------------------------------------------------------------------
1.479 +// CnvPictographShared::NumberOfBytesAbleToConvertToPictograph
1.480 +// It's a common function for checking the number of bytes that the conversion
1.481 +// to pictograph
1.482 +// (other items were commented in a header).
1.483 +// -----------------------------------------------------------------------------
1.484 +//
1.485 +TInt CnvPictographShared::NumberOfBytesAbleToConvertToPictograph(
1.486 + const TDesC8& aDescriptor, TInt aIntermidiateCode)
1.487 + {
1.488 + TInt compLen(KLit8EscapeSequenceForPictograph().Length());
1.489 + TInt ret(0);
1.490 + if (aDescriptor.Left(compLen) == KLit8EscapeSequenceForPictograph)
1.491 + {
1.492 + const TInt intermidiateBuff = aDescriptor[compLen];
1.493 + if (intermidiateBuff == aIntermidiateCode)
1.494 + {
1.495 + ret = compLen + 2;
1.496 +
1.497 + const TInt descriptorLength = aDescriptor.Length();
1.498 + const TUint8* pointerToCurrentByte = aDescriptor.Ptr();
1.499 + const TUint8* pointerToLastByte = pointerToCurrentByte +
1.500 + (descriptorLength - 1);
1.501 + pointerToCurrentByte += compLen + 2;
1.502 + for (; pointerToCurrentByte <= pointerToLastByte;
1.503 + pointerToCurrentByte++)
1.504 + {
1.505 + if (*pointerToCurrentByte == KShiftIn)
1.506 + {
1.507 + ret++;
1.508 + break;
1.509 + }
1.510 + if (*pointerToCurrentByte == KEscape)
1.511 + break;
1.512 + ret++;
1.513 + }
1.514 + }
1.515 + }
1.516 + return ret;
1.517 + }
1.518 +
1.519 +// -----------------------------------------------------------------------------
1.520 +// CnvPictographShared::ConvertToPictographFromUnicode
1.521 +// It converts the string which includes a pictograph's escape sequence
1.522 +// to unicode.
1.523 +// (other items were commented in a header).
1.524 +// -----------------------------------------------------------------------------
1.525 +//
1.526 +void CnvPictographShared::ConvertToPictographFromUnicode(TDes8& aDescriptor)
1.527 + {
1.528 + const TInt descriptorLength = aDescriptor.Length();
1.529 + TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.530 + TUint8* pointerToDataByte = pointerToCurrentByte +
1.531 + KLit8EscapeSequenceForPictograph().Length();
1.532 + const TUint8* const pointerToLastByte = pointerToCurrentByte +
1.533 + (descriptorLength - 1);
1.534 + const TUint8* const pointerToFirstByte = pointerToCurrentByte;
1.535 + pointerToDataByte++;
1.536 +
1.537 + for (; pointerToDataByte <= pointerToLastByte; pointerToDataByte++)
1.538 + {
1.539 + if (*pointerToDataByte != KShiftIn)
1.540 + {
1.541 + *pointerToCurrentByte = *pointerToDataByte;
1.542 + pointerToCurrentByte++;
1.543 + }
1.544 + }
1.545 + aDescriptor.SetLength(pointerToCurrentByte - pointerToFirstByte);
1.546 + }
1.547 +
1.548 +// -----------------------------------------------------------------------------
1.549 +// CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace
1.550 +// Converts from EucJp packed Pictograph to Unicode
1.551 +// -----------------------------------------------------------------------------
1.552 +//
1.553 +void CnvPictographShared::ConvertToPictographFromEucJpPackedInPlace(TDes8& aDescriptor)
1.554 + {
1.555 + const TInt descriptorLength = aDescriptor.Length();
1.556 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.557 + const TUint8* pointerToSourceByte = pointerToTargetByte;
1.558 + const TUint8* const pointerToLastByte =
1.559 + pointerToSourceByte + (descriptorLength - 1);
1.560 + TInt bytesPerCharacter = 2;
1.561 + TInt sjisStartbyte = KSingleByteRangeFirstBlockStart;
1.562 + if (*pointerToSourceByte == KSingleShift3)
1.563 + {
1.564 + ++pointerToSourceByte;
1.565 + bytesPerCharacter = 3;
1.566 + sjisStartbyte = KEUCJPSecondBlockStart;
1.567 + }
1.568 + for (;pointerToSourceByte < pointerToLastByte; )
1.569 + {
1.570 + TUint firstByte = (*pointerToSourceByte
1.571 + - KFirstByteRangeFirstBlockStart) / 2 + sjisStartbyte;
1.572 + TUint secondByte = *(pointerToSourceByte + 1);
1.573 + if ((*pointerToSourceByte % 2) == 0)
1.574 + {
1.575 + secondByte += KSingleByteRangeSecondBlockStart - KSecondByteRangeSecondBlockStart
1.576 + + KEUCJPBlockSize + 1;
1.577 + if (secondByte >= KShiftJisTrailByteIllegal)
1.578 + secondByte++;
1.579 + }
1.580 + else
1.581 + {
1.582 + secondByte += KSingleByteRangeSecondBlockStart - KSecondByteRangeSecondBlockStart;
1.583 + if (secondByte >= KShiftJisTrailByteIllegal)
1.584 + secondByte++;
1.585 + }
1.586 + *pointerToTargetByte = static_cast<TUint8>(firstByte);
1.587 +
1.588 + ++pointerToTargetByte;
1.589 + *pointerToTargetByte = static_cast<TUint8>(secondByte);
1.590 + pointerToSourceByte += 2;
1.591 + ++pointerToTargetByte;
1.592 + }
1.593 + aDescriptor.SetLength((descriptorLength / bytesPerCharacter) * 2);
1.594 + }
1.595 +
1.596 +// -----------------------------------------------------------------------------
1.597 +// CnvPictographShared::AppendShiftIn
1.598 +// It appends a shift-in code to the descriptor.
1.599 +// (other items were commented in a header).
1.600 +// -----------------------------------------------------------------------------
1.601 +//
1.602 +void CnvPictographShared::AppendShiftIn(TDes8& aDescriptor,
1.603 + TInt& aNumberOfCharactersThatDroppedOut)
1.604 + {
1.605 + if (aDescriptor.MaxLength() > aDescriptor.Length())
1.606 + {
1.607 + aDescriptor.Append(KShiftIn);
1.608 + }
1.609 + else
1.610 + {
1.611 + aNumberOfCharactersThatDroppedOut++;
1.612 + }
1.613 + }
1.614 +
1.615 +// ========================== OTHER EXPORTED FUNCTIONS =========================
1.616 +
1.617 +// -----------------------------------------------------------------------------
1.618 +// SetCharacterSetsForPictograph()
1.619 +// It sets parameters to SCharacterSet array.
1.620 +// It called in ConvertFromUnicode().
1.621 +// It makes possible that pictograph conversion is called from other
1.622 +// conversion plug-ins.
1.623 +// @since 2.6
1.624 +// @param aArrayOfCharacterSets The conversion table array
1.625 +// -----------------------------------------------------------------------------
1.626 +//
1.627 +EXPORT_C void SetCharacterSetsForPictograph(
1.628 + RArray<CnvUtilities::SCharacterSet>& aArrayOfCharacterSets)
1.629 + {
1.630 + CnvPictographShared::SetCharacterSetsForPictograph(aArrayOfCharacterSets);
1.631 + }
1.632 +
1.633 +// -----------------------------------------------------------------------------
1.634 +// SetCharacterSetsForPictograph()
1.635 +// It sets parameters to SCharacterSet array.
1.636 +// It called in ConvertFromUnicode().
1.637 +// It makes possible that pictograph conversion is called from other
1.638 +// conversion plug-ins.
1.639 +// @since 2.6
1.640 +// @param aArrayOfCharacterSets The conversion table array
1.641 +// @param aOriginalCharset The character set
1.642 +// -----------------------------------------------------------------------------
1.643 +//
1.644 +EXPORT_C void SetCharacterSetsForPictograph(
1.645 + RArray<CnvUtilities::SCharacterSet>& aArrayOfCharacterSets,
1.646 + TOriginalCharset aOriginalCharset)
1.647 + {
1.648 + CnvPictographShared::SetCharacterSetsForPictograph(aArrayOfCharacterSets,
1.649 + aOriginalCharset);
1.650 + }
1.651 +
1.652 +// -----------------------------------------------------------------------------
1.653 +// SetMethodsForPictograph()
1.654 +// It sets parameters to SMethod array.
1.655 +// It called in ConvertToUnicode().
1.656 +// It makes possible that pictograph conversion is called from other
1.657 +// conversion plug-ins.
1.658 +// @since 2.6
1.659 +// @param aArrayOfMethods The conversion table array
1.660 +// @param aOriginalCharset The character set
1.661 +// -----------------------------------------------------------------------------
1.662 +//
1.663 +EXPORT_C void SetMethodsForPictograph(
1.664 + RArray<CnvUtilities::SMethod>& aArrayOfMethods,
1.665 + TOriginalCharset aOriginalCharset)
1.666 + {
1.667 + CnvPictographShared::SetMethodsForPictograph(aArrayOfMethods,
1.668 + aOriginalCharset);
1.669 + }
1.670 +
1.671 +// -----------------------------------------------------------------------------
1.672 +// SetStatesForPictograph()
1.673 +// It sets parameters to SState array.
1.674 +// It called in ConvertToUnicode().
1.675 +// It makes possible that pictograph conversion is called from other
1.676 +// conversion plug-ins.
1.677 +// @since 2.6
1.678 +// @param aArrayOfMethods The conversion table array
1.679 +// -----------------------------------------------------------------------------
1.680 +//
1.681 +EXPORT_C void SetStatesForPictograph(
1.682 + RArray<CnvUtilities::SState>& aArrayOfStates)
1.683 + {
1.684 + CnvPictographShared::SetStatesForPictograph(aArrayOfStates);
1.685 + }
1.686 +
1.687 +// -----------------------------------------------------------------------------
1.688 +// CountOfPictographPagesFromUnicode()
1.689 +// It returns count of pictograph pages.
1.690 +// This method is used for the conversion from Unicode to foreign character
1.691 +// set.
1.692 +// @since 2.6
1.693 +// @return count of pictograph pages.
1.694 +// -----------------------------------------------------------------------------
1.695 +//
1.696 +EXPORT_C TInt CountOfPictographPagesFromUnicode()
1.697 + {
1.698 + return KCountOfPictoPages;
1.699 + }
1.700 +
1.701 +// -----------------------------------------------------------------------------
1.702 +// CountOfPictographPagesToUnicode()
1.703 +// It returns count of pictograph pages.
1.704 +// This method is used for the conversion from foreign character set to
1.705 +// Unicode.
1.706 +// @since 2.6
1.707 +// @return count of pictograph pages.
1.708 +// -----------------------------------------------------------------------------
1.709 +//
1.710 +EXPORT_C TInt CountOfPictographPagesToUnicode()
1.711 + {
1.712 + return KCountOfPictoPages + 1;
1.713 + }
1.714 +
1.715 +// End of File