OdCharMapper.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
 
 
#ifndef _OD_CHARMAPPER_H_
#define _OD_CHARMAPPER_H_
 
#include "TD_PackPush.h"
 
#include "OdCodePage.h"
#include "OdError.h"
#include "OdArray.h"
#include "IntArray.h"
 
class OdStreamBuf;
class OdString;
class OdFont;
typedef OdArray <char, OdMemoryAllocator<char> > OdAnsiCharArray;
typedef OdArray<OdChar, OdMemoryAllocator<OdChar> > OdCharArray;
 
 
class FIRSTDLL_EXPORT OdCharMapper
{
  static OdString m_MapFile;
private:
        OdCharMapper();
public:
//      static OdResult initialize(OdStreamBuf* pIo);
 
  static OdResult initialize(const OdString& filename);
 
  static OdResult unicodeToCodepage(OdChar sourceChar,
    OdCodePageId codepageId,
    OdChar& codepageChar,
    bool bTryToUseSystemCP = true );
 
  static OdResult unicodeToCodepage2(OdChar sourceChar,
    OdCodePageId codepageId,
    OdChar& codepageChar);
 
  static OdResult codepageToUnicode(OdChar sourceChar,
    OdCodePageId codepageId,
    OdChar& unicodeChar);
 
  static bool isLeadByte(OdUInt8 testByte, OdCodePageId codepageId);
 
  static OdResult codepageDescToId(const OdString& description, OdCodePageId& codepageId);
 
  static OdResult codepageIdToDesc(OdCodePageId codepageId, OdString& description);
 
  static OdUInt32 numValidCodepages();
 
  static OdCodePageId ansiCpToAcadCp(OdUInt32 ansiCodePage);
 
  static OdUInt32 acadCpToAnsiCp(OdCodePageId acadCodePageId);
 
   static OdCodePageId getCodepageByCharset(OdUInt16 ansiCharacterSet);
 
   static OdUInt16 getReorderCharsetByChar(OdChar ch);
 
   static bool isConversionSupported(OdCodePageId codepageId);
 
   static void wideCharToMultiByte(OdCodePageId codePage, const OdChar* srcBuf, int srcSize, OdAnsiCharArray& dstBuf);
 
   static void multiByteToWideChar(OdCodePageId codePage, const char* srcBuf, int srcSize, OdCharArray& dstBuf);
 
   // This is actually CESU-8 encoding used in DXF (http://www.unicode.org/reports/tr26/)
   static bool utf8ToUnicode(const char* srcBuf, int srcSize, OdCharArray& dstBuf);
 
   static void unicodeToUtf8(const OdChar* srcBuf, int srcSize, OdAnsiCharArray& dstBuf);
 
   static OdResult addBigFontWithIndex(const OdString& bigFont, OdInt32 cpIndex);
 
   static OdResult addBigFontWithCodepage(const OdString& bigFont, OdCodePageId codePageId);
 
   static OdResult addBigFonts(OdStreamBuf* io);
 
   static OdCodePageId getCpByBigFont(const OdString& bigFont);
 
   static OdInt32 getCpIndexByBigFont(const OdString& bigFont);
 
   static double getCheckSumAnsi(OdAnsiString str);
 
   static double getCheckSumUnicode(OdString str);
 
   static OdString convertCIFcoding(const OdString& strText);
 
   static OdString convertAlphaNumJapanese(const OdString& strText);
 
   static OdAnsiString convertAlphaNumJapanese(const OdAnsiString& strText);
 
   static bool containsSpecialSequence(OdString& str, OdFont* font, OdIntArray& ulRanges);
 
   static OdString embedTextRawData(const OdString &msg, const OdIntArray &ulFlags, int *length = NULL, bool *raw = NULL);
};
 
// Surrogate pairs support
template<class T> inline bool odIsLeadSurrogate(T chr) {
  return (chr >= 0xD800 && chr <= 0xDFFF);
}
template<class T> inline bool odIsTailSurrogate(T chr) {
  return (chr >= 0xDC00 && chr <= 0xDFFF);
}
template<class T1, class T2> inline T1 odToCodepoint(T1 chr, T2 chr2) {
  return (chr << 10) + chr2 + (0x10000 - (0xD800 << 10) - 0xDC00);
}
template<class T> inline OdUInt32 odToCodeValue(T chr, T chr2) {
  return ((OdUInt32)chr << 10) + chr2 + (0x10000 - (0xD800 << 10) - 0xDC00);
}
template<class T> inline bool odIsCodepoint(T chr) {
  return (chr >= 0x10000 && chr <= 0x10FFFF);
}
template<class T> inline T odToLeadSurrogate(T chr) {
  return ((0xD800 - (0x10000 >> 10)) + (chr >> 10));
}
template<class T> inline T odToTailSurrogate(T chr) {
  return (0xDC00 + (chr & 0x3FF));
}
 
enum OdAsianCpIndex
{
  JAPANESE_CP_INDEX = 1,              // 932
  TRADITIONAL_CHINESE_CP_INDEX = 2,   // 950
  KOREAN_WANSUNG_CP_INDEX = 3,        // 949
  KOREAN_JOHAB_CP_INDEX = 4,          // 1361
  SIMPLIFIED_CHINESE_CP_INDEX = 5     // 936
};
 
#include "TD_PackPop.h"
 
#endif