Use stdint.h types throughout PDFium.

fpdfsdk/src/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 "../../include/pdfwindow/PDFWindow.h"
 #include "../../include/pdfwindow/PWL_Wnd.h"
 #include "../../include/pdfwindow/PWL_FontMap.h"
 
@@ skipping 31 matching lines @@
                 if (CPDF_ModuleMgr::Get())
                 {
                         m_pPDFDoc = new CPDF_Document;
                         m_pPDFDoc->CreateNewDoc();
                 }
         }
 
         return m_pPDFDoc;
 }
 
-CPDF_Font* CPWL_FontMap::GetPDFFont(FX_INT32 nFontIndex)
+CPDF_Font* CPWL_FontMap::GetPDFFont(int32_t nFontIndex)
 {
         if (nFontIndex >=0 && nFontIndex < m_aData.GetSize())
         {
                 if (CPWL_FontMap_Data* pData = m_aData.GetAt(nFontIndex))
                 {
                         return pData->pFont;
                 }
         }
 
         return NULL;
 }
 
-CFX_ByteString CPWL_FontMap::GetPDFFontAlias(FX_INT32 nFontIndex)
+CFX_ByteString CPWL_FontMap::GetPDFFontAlias(int32_t nFontIndex)
 {
         if (nFontIndex >=0 && nFontIndex < m_aData.GetSize())
         {
                 if (CPWL_FontMap_Data* pData = m_aData.GetAt(nFontIndex))
                 {
                         return pData->sFontName;
                 }
         }
 
         return "";
 }
 
-FX_BOOL CPWL_FontMap::KnowWord(FX_INT32 nFontIndex, FX_WORD word)
+FX_BOOL CPWL_FontMap::KnowWord(int32_t nFontIndex, FX_WORD word)
 {
         if (nFontIndex >=0 && nFontIndex < m_aData.GetSize())
         {
                 if (m_aData.GetAt(nFontIndex))
                 {       
                         return CharCodeFromUnicode(nFontIndex, word) >= 0;
                 }
         }
 
         return FALSE;
 }
 
-FX_INT32 CPWL_FontMap::GetWordFontIndex(FX_WORD word, FX_INT32 nCharset, FX_INT32 nFontIndex)
+int32_t CPWL_FontMap::GetWordFontIndex(FX_WORD 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 || 
                                 nCharset == pData->nCharset)
                         {
                                 if (KnowWord(0, word))
                                 {
                                         return 0;
                                 }
                         }
                 }
         }
 
-        FX_INT32 nNewFontIndex = -1;
+        int32_t nNewFontIndex = -1;
 
         nNewFontIndex = this->GetFontIndex(GetNativeFontName(nCharset), nCharset, TRUE);
         if (nNewFontIndex >= 0)
         {
                 if (KnowWord(nNewFontIndex, word))
                         return nNewFontIndex;
         }
 
         nNewFontIndex = this->GetFontIndex("Arial Unicode MS", DEFAULT_CHARSET, FALSE);
         if (nNewFontIndex >= 0)
         {
                 if (KnowWord(nNewFontIndex, word))
                 return nNewFontIndex;
         }
 
         return -1;
 }
 
-FX_INT32 CPWL_FontMap::CharCodeFromUnicode(FX_INT32 nFontIndex, FX_WORD word)
+int32_t CPWL_FontMap::CharCodeFromUnicode(int32_t nFontIndex, FX_WORD word)
 {
         if (CPWL_FontMap_Data* pData = m_aData.GetAt(nFontIndex))
         {
                 if (pData->pFont)
                 {
                         if (pData->pFont->IsUnicodeCompatible())
                         {
                                 int nCharCode = pData->pFont->CharCodeFromUnicode(word);
                                 pData->pFont->GlyphFromCharCode(nCharCode);
                                 return nCharCode;
                         }
                         else
                         {
                                 if (word < 0xFF)
                                         return word;
                         }
                 }
         }
 
         return -1;
 }
 
-CFX_ByteString CPWL_FontMap::GetNativeFontName(FX_INT32 nCharset)
+CFX_ByteString CPWL_FontMap::GetNativeFontName(int32_t nCharset)
 {
         //searching native font is slow, so we must save time
-        for (FX_INT32 i=0,sz=m_aNativeFont.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aNativeFont.GetSize(); i<sz; i++)
         {
                 if (CPWL_FontMap_Native* pData = m_aNativeFont.GetAt(i))
                 {
                         if (pData->nCharset == nCharset)
                                 return pData->sFontName;
                 }
         }
 
         CFX_ByteString sNew = GetNativeFont(nCharset);
 
         if (!sNew.IsEmpty())
         {
                 CPWL_FontMap_Native* pNewData = new CPWL_FontMap_Native;
                 pNewData->nCharset = nCharset;
                 pNewData->sFontName = sNew;
 
                 m_aNativeFont.Add(pNewData);
         }
 
         return sNew;
 }
 
 void CPWL_FontMap::Empty()
 {
         {
-                for (FX_INT32 i=0, sz=m_aData.GetSize(); i<sz; i++)
+                for (int32_t i=0, sz=m_aData.GetSize(); i<sz; i++)
                         delete m_aData.GetAt(i);
 
                 m_aData.RemoveAll();
         }
         {
-                for (FX_INT32 i=0, sz=m_aNativeFont.GetSize(); i<sz; i++)
+                for (int32_t i=0, sz=m_aNativeFont.GetSize(); i<sz; i++)
                         delete m_aNativeFont.GetAt(i);
 
                 m_aNativeFont.RemoveAll();
         }
 }
 
 void CPWL_FontMap::Initial(FX_LPCSTR fontname)
 {
         CFX_ByteString sFontName = fontname;
 
@@ skipping 14 matching lines @@
 Symbol, ZapfDingbats
 */
 
 const char* g_sDEStandardFontName[] = {"Courier", "Courier-Bold", "Courier-BoldOblique", "Courier-Oblique",
         "Helvetica", "Helvetica-Bold", "Helvetica-BoldOblique", "Helvetica-Oblique",
         "Times-Roman", "Times-Bold", "Times-Italic", "Times-BoldItalic",
         "Symbol", "ZapfDingbats"};
 
 FX_BOOL CPWL_FontMap::IsStandardFont(const CFX_ByteString& sFontName)
 {
-        for (FX_INT32 i=0; i<14; i++)
+        for (int32_t i=0; i<14; i++)
         {
                 if (sFontName == g_sDEStandardFontName[i])
                         return TRUE;
         }
 
         return FALSE;
 }
 
-FX_INT32 CPWL_FontMap::FindFont(const CFX_ByteString& sFontName, FX_INT32 nCharset)
+int32_t CPWL_FontMap::FindFont(const CFX_ByteString& sFontName, int32_t nCharset)
 {
-        for (FX_INT32 i=0,sz=m_aData.GetSize(); i<sz; i++)
+        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 (sFontName.IsEmpty() || pData->sFontName == sFontName)
                                         return i;
                         }
                 }
         }
 
         return -1;
 }
 
-FX_INT32 CPWL_FontMap::GetFontIndex(const CFX_ByteString& sFontName, FX_INT32 nCharset, FX_BOOL bFind)
+int32_t CPWL_FontMap::GetFontIndex(const CFX_ByteString& sFontName, int32_t nCharset, FX_BOOL bFind)
 {
-        FX_INT32 nFontIndex = FindFont(EncodeFontAlias(sFontName, nCharset), nCharset);
+        int32_t nFontIndex = FindFont(EncodeFontAlias(sFontName, nCharset), nCharset);
         if (nFontIndex >= 0) return nFontIndex;
 
 //      nFontIndex = FindFont("", nCharset);
 //      if (nFontIndex >= 0) return nFontIndex;
 
         CFX_ByteString sAlias;
         CPDF_Font* pFont = NULL;
 
         if (bFind)
                 pFont = FindFontSameCharset(sAlias, nCharset);
@@ skipping 13 matching lines @@
                 {
                         sAlias = EncodeFontAlias(sTemp, nCharset);
                 }               
         }
 
         AddedFont(pFont, sAlias);
 
         return AddFontData(pFont, sAlias, nCharset);
 }
 
-FX_INT32 CPWL_FontMap::GetPWLFontIndex(FX_WORD word, FX_INT32 nCharset)
+int32_t CPWL_FontMap::GetPWLFontIndex(FX_WORD word, int32_t nCharset)
 {
-        FX_INT32 nFind = -1;
+        int32_t nFind = -1;
 
-        for (FX_INT32 i=0,sz=m_aData.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aData.GetSize(); i<sz; i++)
         {
                 if (CPWL_FontMap_Data* pData = m_aData.GetAt(i))
                 {
                         if (pData->nCharset == nCharset)
                         {
                                 nFind = i;
                                 break;
                         }
                 }
         }
 
         CPDF_Font* pNewFont = GetPDFFont(nFind);
 
         if (!pNewFont) return -1;
 
         /*
         if (CPDF_Font* pFont = GetPDFFont(nFind))
         {
                 PWLFont.AddWordToFontDict(pFontDict, word);
         }
         */
 
         CFX_ByteString sAlias = EncodeFontAlias("Arial_Chrome", nCharset);
         AddedFont(pNewFont, sAlias);
 
         return AddFontData(pNewFont, sAlias, nCharset);
 }
 
-CPDF_Font* CPWL_FontMap::FindFontSameCharset(CFX_ByteString& sFontAlias, FX_INT32 nCharset)
+CPDF_Font* CPWL_FontMap::FindFontSameCharset(CFX_ByteString& sFontAlias, int32_t nCharset)
 {
         return NULL;
 }
 
-FX_INT32 CPWL_FontMap::AddFontData(CPDF_Font* pFont, const CFX_ByteString& sFontAlias, FX_INT32 nCharset)
+int32_t CPWL_FontMap::AddFontData(CPDF_Font* pFont, const CFX_ByteString& sFontAlias, int32_t nCharset)
 {
         CPWL_FontMap_Data* pNewData = new CPWL_FontMap_Data;
         pNewData->pFont = pFont;
         pNewData->sFontName = sFontAlias;
         pNewData->nCharset = nCharset;
 
         m_aData.Add(pNewData);
 
         return m_aData.GetSize() -1;
 }
 
 void CPWL_FontMap::AddedFont(CPDF_Font* pFont, const CFX_ByteString& sFontAlias)
 {
 }
 
-CFX_ByteString CPWL_FontMap::GetFontName(FX_INT32 nFontIndex)
+CFX_ByteString CPWL_FontMap::GetFontName(int32_t nFontIndex)
 {
         if (nFontIndex >=0 && nFontIndex < m_aData.GetSize())
         {
                 if (CPWL_FontMap_Data* pData = m_aData.GetAt(nFontIndex))
                 {
                         return pData->sFontName;
                 }
         }
 
         return "";
 }
 
-CFX_ByteString CPWL_FontMap::GetNativeFont(FX_INT32 nCharset)
+CFX_ByteString CPWL_FontMap::GetNativeFont(int32_t nCharset)
 {
         CFX_ByteString sFontName;
 
         if (nCharset == DEFAULT_CHARSET)
                 nCharset = GetNativeCharset();
 
         sFontName = GetDefaultFontByCharset(nCharset);
 
         if (m_pSystemHandler)
         {
                 if (m_pSystemHandler->FindNativeTrueTypeFont(nCharset, sFontName))
                         return sFontName;
 
                 sFontName = m_pSystemHandler->GetNativeTrueTypeFont(nCharset);
         }
 
         return sFontName;
 }
 
-CPDF_Font* CPWL_FontMap::AddFontToDocument(CPDF_Document* pDoc, CFX_ByteString& sFontName, FX_BYTE nCharset)
+CPDF_Font* CPWL_FontMap::AddFontToDocument(CPDF_Document* pDoc, CFX_ByteString& sFontName, uint8_t nCharset)
 {
         if (IsStandardFont(sFontName))
                 return AddStandardFont(pDoc, sFontName);
         else
                 return AddSystemFont(pDoc, sFontName, nCharset);
 }
 
 CPDF_Font* CPWL_FontMap::AddStandardFont(CPDF_Document* pDoc, CFX_ByteString& sFontName)
 {
         if (!pDoc) return NULL;
 
         CPDF_Font* pFont = NULL;
 
         if (sFontName == "ZapfDingbats")
                 pFont = pDoc->AddStandardFont(sFontName, NULL);
         else
         {
                 CPDF_FontEncoding fe(PDFFONT_ENCODING_WINANSI);
                 pFont = pDoc->AddStandardFont(sFontName, &fe);
         }
 
         return pFont;
 }
 
-CPDF_Font* CPWL_FontMap::AddSystemFont(CPDF_Document* pDoc, CFX_ByteString& sFontName, FX_BYTE nCharset)
+CPDF_Font* CPWL_FontMap::AddSystemFont(CPDF_Document* pDoc, CFX_ByteString& sFontName, uint8_t nCharset)
 {
         if (!pDoc) return NULL;
 
         if (sFontName.IsEmpty()) sFontName = GetNativeFont(nCharset);
         if (nCharset == DEFAULT_CHARSET) nCharset = GetNativeCharset();
 
         if (m_pSystemHandler)
                 return m_pSystemHandler->AddNativeTrueTypeFontToPDF(pDoc, sFontName, nCharset);
         
         return NULL;
 }
 
-CFX_ByteString CPWL_FontMap::EncodeFontAlias(const CFX_ByteString& sFontName, FX_INT32 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;
 }
 
-FX_INT32 CPWL_FontMap::GetFontMapCount() const
+int32_t CPWL_FontMap::GetFontMapCount() const
 {
         return m_aData.GetSize();
 }
 
-const CPWL_FontMap_Data* CPWL_FontMap::GetFontMapData(FX_INT32 nIndex) const
+const CPWL_FontMap_Data* CPWL_FontMap::GetFontMapData(int32_t nIndex) const
 {
         if (nIndex >=0 && nIndex < m_aData.GetSize())
         {
                 return m_aData.GetAt(nIndex);
         }
 
         return NULL;
 }
 
-FX_INT32 CPWL_FontMap::GetNativeCharset()
+int32_t CPWL_FontMap::GetNativeCharset()
 {
-        FX_BYTE nCharset = ANSI_CHARSET;
-        FX_INT32 iCodePage = FXSYS_GetACP();
+        uint8_t nCharset = ANSI_CHARSET;
+        int32_t iCodePage = FXSYS_GetACP();
         switch (iCodePage)
         {
         case 932://Japan
                 nCharset = SHIFTJIS_CHARSET;
                 break;
         case 936://Chinese (PRC, Singapore)
                 nCharset = GB2312_CHARSET;
                 break;
         case 950://Chinese (Taiwan; Hong Kong SAR, PRC)
                 nCharset = GB2312_CHARSET;
@@ skipping 50 matching lines @@
         { RUSSIAN_CHARSET, "Arial" },
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_ || _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
         { EASTEUROPE_CHARSET, "Arial" },
 #else
         { EASTEUROPE_CHARSET, "Tahoma" },
 #endif
         { ARABIC_CHARSET, "Arial" },
         { -1, NULL }
 };
 
-CFX_ByteString CPWL_FontMap::GetDefaultFontByCharset(FX_INT32 nCharset)
+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 "";
 }
 
-FX_INT32 CPWL_FontMap::CharSetFromUnicode(FX_WORD word, FX_INT32 nOldCharset)
+int32_t CPWL_FontMap::CharSetFromUnicode(FX_WORD word, int32_t nOldCharset)
 {
         if(m_pSystemHandler && (-1 != m_pSystemHandler->GetCharSet()))
                 return m_pSystemHandler->GetCharSet();
         //to avoid CJK Font to show ASCII
         if (word < 0x7F) return ANSI_CHARSET;
         //follow the old charset
         if (nOldCharset != DEFAULT_CHARSET) return nOldCharset;
 
         //find new charset
         if ((word >= 0x4E00 && word <= 0x9FA5) || 
@@ skipping 54 matching lines @@
 }
 
 CPWL_DocFontMap::~CPWL_DocFontMap()
 {
 }
 
 CPDF_Document* CPWL_DocFontMap::GetDocument()
 {
         return m_pAttachedDoc;
 }