Remove duplicated charset definitions

fpdfsdk/pdfwindow/PWL_FontMap.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "fpdfsdk/pdfwindow/PWL_FontMap.h"
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_font/include/cpdf_fontencoding.h"
@@ skipping 75 matching lines @@
 }
 
 int32_t CPWL_FontMap::GetWordFontIndex(uint16_t word,
                                        int32_t nCharset,
                                        int32_t nFontIndex) {
   if (nFontIndex > 0) {
     if (KnowWord(nFontIndex, word))
       return nFontIndex;
   } else {
     if (const CPWL_FontMap_Data* pData = GetFontMapData(0)) {
-      if (nCharset == DEFAULT_CHARSET || pData->nCharset == SYMBOL_CHARSET ||
+      if (nCharset == FXFONT_DEFAULT_CHARSET ||
+          pData->nCharset == FXFONT_SYMBOL_CHARSET ||
           nCharset == pData->nCharset) {
         if (KnowWord(0, word))
           return 0;
       }
     }
   }
 
   int32_t nNewFontIndex =
       GetFontIndex(GetNativeFontName(nCharset), nCharset, TRUE);
   if (nNewFontIndex >= 0) {
     if (KnowWord(nNewFontIndex, word))
       return nNewFontIndex;
   }
-  nNewFontIndex = GetFontIndex("Arial Unicode MS", DEFAULT_CHARSET, FALSE);
+  nNewFontIndex =
+      GetFontIndex("Arial Unicode MS", FXFONT_DEFAULT_CHARSET, FALSE);
   if (nNewFontIndex >= 0) {
     if (KnowWord(nNewFontIndex, word))
       return nNewFontIndex;
   }
   return -1;
 }
 
 int32_t CPWL_FontMap::CharCodeFromUnicode(int32_t nFontIndex, uint16_t word) {
   CPWL_FontMap_Data* pData = m_aData.GetAt(nFontIndex);
   if (!pData)
@@ skipping 39 matching lines @@
   }
   {
     for (int32_t i = 0, sz = m_aNativeFont.GetSize(); i < sz; i++)
       delete m_aNativeFont.GetAt(i);
 
     m_aNativeFont.RemoveAll();
   }
 }
 
 void CPWL_FontMap::Initialize() {
-  GetFontIndex(kDefaultFontName, ANSI_CHARSET, FALSE);
+  GetFontIndex(kDefaultFontName, FXFONT_ANSI_CHARSET, FALSE);
 }
 
 FX_BOOL CPWL_FontMap::IsStandardFont(const CFX_ByteString& sFontName) {
   for (size_t i = 0; i < FX_ArraySize(g_sDEStandardFontName); ++i) {
     if (sFontName == g_sDEStandardFontName[i])
       return TRUE;
   }
 
   return FALSE;
 }
 
 int32_t CPWL_FontMap::FindFont(const CFX_ByteString& sFontName,
                                int32_t nCharset) {
   for (int32_t i = 0, sz = m_aData.GetSize(); i < sz; i++) {
     if (CPWL_FontMap_Data* pData = m_aData.GetAt(i)) {
-      if (nCharset == DEFAULT_CHARSET || nCharset == pData->nCharset) {
+      if (nCharset == FXFONT_DEFAULT_CHARSET || nCharset == pData->nCharset) {
         if (sFontName.IsEmpty() || pData->sFontName == sFontName)
           return i;
       }
     }
   }
 
   return -1;
 }
 
 int32_t CPWL_FontMap::GetFontIndex(const CFX_ByteString& sFontName,
@@ skipping 32 matching lines @@
 
   m_aData.Add(pNewData);
 
   return m_aData.GetSize() - 1;
 }
 
 void CPWL_FontMap::AddedFont(CPDF_Font* pFont,
                              const CFX_ByteString& sFontAlias) {}
 
 CFX_ByteString CPWL_FontMap::GetNativeFont(int32_t nCharset) {
-  if (nCharset == DEFAULT_CHARSET)
+  if (nCharset == FXFONT_DEFAULT_CHARSET)
     nCharset = GetNativeCharset();
 
   CFX_ByteString sFontName = GetDefaultFontByCharset(nCharset);
   if (m_pSystemHandler->FindNativeTrueTypeFont(sFontName))
     return sFontName;
 
   sFontName.clear();
   return sFontName;
 }
 
@@ skipping 24 matching lines @@
 }
 
 CPDF_Font* CPWL_FontMap::AddSystemFont(CPDF_Document* pDoc,
                                        CFX_ByteString& sFontName,
                                        uint8_t nCharset) {
   if (!pDoc)
     return nullptr;
 
   if (sFontName.IsEmpty())
     sFontName = GetNativeFont(nCharset);
-  if (nCharset == DEFAULT_CHARSET)
+  if (nCharset == FXFONT_DEFAULT_CHARSET)
     nCharset = GetNativeCharset();
 
   return m_pSystemHandler->AddNativeTrueTypeFontToPDF(pDoc, sFontName,
                                                       nCharset);
 }
 
 CFX_ByteString CPWL_FontMap::EncodeFontAlias(const CFX_ByteString& sFontName,
                                              int32_t nCharset) {
   CFX_ByteString sPostfix;
   sPostfix.Format("_%02X", nCharset);
   return EncodeFontAlias(sFontName) + sPostfix;
 }
 
 CFX_ByteString CPWL_FontMap::EncodeFontAlias(const CFX_ByteString& sFontName) {
   CFX_ByteString sRet = sFontName;
   sRet.Remove(' ');
   return sRet;
 }
 
 const CPWL_FontMap_Data* CPWL_FontMap::GetFontMapData(int32_t nIndex) const {
   if (nIndex >= 0 && nIndex < m_aData.GetSize()) {
     return m_aData.GetAt(nIndex);
   }
 
   return nullptr;
 }
 
 int32_t CPWL_FontMap::GetNativeCharset() {
-  uint8_t nCharset = ANSI_CHARSET;
+  uint8_t nCharset = FXFONT_ANSI_CHARSET;
   int32_t iCodePage = FXSYS_GetACP();
   switch (iCodePage) {
     case 932:  // Japan
-      nCharset = SHIFTJIS_CHARSET;
+      nCharset = FXFONT_SHIFTJIS_CHARSET;
       break;
     case 936:  // Chinese (PRC, Singapore)
-      nCharset = GB2312_CHARSET;
+      nCharset = FXFONT_GB2312_CHARSET;
       break;
     case 950:  // Chinese (Taiwan; Hong Kong SAR, PRC)
-      nCharset = GB2312_CHARSET;
+      nCharset = FXFONT_GB2312_CHARSET;
       break;
     case 1252:  // Windows 3.1 Latin 1 (US, Western Europe)
-      nCharset = ANSI_CHARSET;
+      nCharset = FXFONT_ANSI_CHARSET;
       break;
     case 874:  // Thai
-      nCharset = THAI_CHARSET;
+      nCharset = FXFONT_THAI_CHARSET;
       break;
     case 949:  // Korean
-      nCharset = HANGUL_CHARSET;
+      nCharset = FXFONT_HANGUL_CHARSET;
       break;
     case 1200:  // Unicode (BMP of ISO 10646)
-      nCharset = ANSI_CHARSET;
+      nCharset = FXFONT_ANSI_CHARSET;
       break;
     case 1250:  // Windows 3.1 Eastern European
-      nCharset = EASTEUROPE_CHARSET;
+      nCharset = FXFONT_EASTEUROPE_CHARSET;
       break;
     case 1251:  // Windows 3.1 Cyrillic
-      nCharset = RUSSIAN_CHARSET;
+      nCharset = FXFONT_RUSSIAN_CHARSET;
       break;
     case 1253:  // Windows 3.1 Greek
-      nCharset = GREEK_CHARSET;
+      nCharset = FXFONT_GREEK_CHARSET;
       break;
     case 1254:  // Windows 3.1 Turkish
-      nCharset = TURKISH_CHARSET;
+      nCharset = FXFONT_TURKISH_CHARSET;
       break;
     case 1255:  // Hebrew
-      nCharset = HEBREW_CHARSET;
+      nCharset = FXFONT_HEBREW_CHARSET;
       break;
     case 1256:  // Arabic
-      nCharset = ARABIC_CHARSET;
+      nCharset = FXFONT_ARABIC_CHARSET;
       break;
     case 1257:  // Baltic
-      nCharset = BALTIC_CHARSET;
+      nCharset = FXFONT_BALTIC_CHARSET;
       break;
     case 1258:  // Vietnamese
-      nCharset = VIETNAMESE_CHARSET;
+      nCharset = FXFONT_VIETNAMESE_CHARSET;
       break;
     case 1361:  // Korean(Johab)
-      nCharset = JOHAB_CHARSET;
+      nCharset = FXFONT_JOHAB_CHARSET;
       break;
   }
   return nCharset;
 }
 
 const FPDF_CharsetFontMap CPWL_FontMap::defaultTTFMap[] = {
-    {ANSI_CHARSET, "Helvetica"},      {GB2312_CHARSET, "SimSun"},
-    {CHINESEBIG5_CHARSET, "MingLiU"}, {SHIFTJIS_CHARSET, "MS Gothic"},
-    {HANGUL_CHARSET, "Batang"},       {RUSSIAN_CHARSET, "Arial"},
+    {FXFONT_ANSI_CHARSET, "Helvetica"},
+    {FXFONT_GB2312_CHARSET, "SimSun"},
+    {FXFONT_CHINESEBIG5_CHARSET, "MingLiU"},
+    {FXFONT_SHIFTJIS_CHARSET, "MS Gothic"},
+    {FXFONT_HANGUL_CHARSET, "Batang"},
+    {FXFONT_RUSSIAN_CHARSET, "Arial"},
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_ || \
     _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
-    {EASTEUROPE_CHARSET, "Arial"},
+    {FXFONT_EASTEUROPE_CHARSET, "Arial"},
 #else
-    {EASTEUROPE_CHARSET, "Tahoma"},
+    {FXFONT_EASTEUROPE_CHARSET, "Tahoma"},
 #endif
-    {ARABIC_CHARSET, "Arial"},        {-1, nullptr}};
+    {FXFONT_ARABIC_CHARSET, "Arial"},
+    {-1, nullptr}};
 
 CFX_ByteString CPWL_FontMap::GetDefaultFontByCharset(int32_t nCharset) {
   int i = 0;
   while (defaultTTFMap[i].charset != -1) {
     if (nCharset == defaultTTFMap[i].charset)
       return defaultTTFMap[i].fontname;
     ++i;
   }
   return "";
 }
 
 int32_t CPWL_FontMap::CharSetFromUnicode(uint16_t word, int32_t nOldCharset) {
   // to avoid CJK Font to show ASCII
   if (word < 0x7F)
-    return ANSI_CHARSET;
+    return FXFONT_ANSI_CHARSET;
   // follow the old charset
-  if (nOldCharset != DEFAULT_CHARSET)
+  if (nOldCharset != FXFONT_DEFAULT_CHARSET)
     return nOldCharset;
 
   // find new charset
   if ((word >= 0x4E00 && word <= 0x9FA5) ||
       (word >= 0xE7C7 && word <= 0xE7F3) ||
       (word >= 0x3000 && word <= 0x303F) ||
       (word >= 0x2000 && word <= 0x206F)) {
-    return GB2312_CHARSET;
+    return FXFONT_GB2312_CHARSET;
   }
 
   if (((word >= 0x3040) && (word <= 0x309F)) ||
       ((word >= 0x30A0) && (word <= 0x30FF)) ||
       ((word >= 0x31F0) && (word <= 0x31FF)) ||
       ((word >= 0xFF00) && (word <= 0xFFEF))) {
-    return SHIFTJIS_CHARSET;
+    return FXFONT_SHIFTJIS_CHARSET;
   }
 
   if (((word >= 0xAC00) && (word <= 0xD7AF)) ||
       ((word >= 0x1100) && (word <= 0x11FF)) ||
       ((word >= 0x3130) && (word <= 0x318F))) {
-    return HANGUL_CHARSET;
+    return FXFONT_HANGUL_CHARSET;
   }
 
   if (word >= 0x0E00 && word <= 0x0E7F)
-    return THAI_CHARSET;
+    return FXFONT_THAI_CHARSET;
 
   if ((word >= 0x0370 && word <= 0x03FF) || (word >= 0x1F00 && word <= 0x1FFF))
-    return GREEK_CHARSET;
+    return FXFONT_GREEK_CHARSET;
 
   if ((word >= 0x0600 && word <= 0x06FF) || (word >= 0xFB50 && word <= 0xFEFC))
-    return ARABIC_CHARSET;
+    return FXFONT_ARABIC_CHARSET;
 
   if (word >= 0x0590 && word <= 0x05FF)
-    return HEBREW_CHARSET;
+    return FXFONT_HEBREW_CHARSET;
 
   if (word >= 0x0400 && word <= 0x04FF)
-    return RUSSIAN_CHARSET;
+    return FXFONT_RUSSIAN_CHARSET;
 
   if (word >= 0x0100 && word <= 0x024F)
-    return EASTEUROPE_CHARSET;
+    return FXFONT_EASTEUROPE_CHARSET;
 
   if (word >= 0x1E00 && word <= 0x1EFF)
-    return VIETNAMESE_CHARSET;
+    return FXFONT_VIETNAMESE_CHARSET;
 
-  return ANSI_CHARSET;
+  return FXFONT_ANSI_CHARSET;
 }