Rename dictionary set and get methods

core/fpdfapi/fpdf_parser/cpdf_document.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 "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 
 #include <memory>
 #include <set>
@@ skipping 237 matching lines @@
   }
   FX_Free(widths);
 }
 
 int InsertDeletePDFPage(CPDF_Document* pDoc,
                         CPDF_Dictionary* pPages,
                         int nPagesToGo,
                         CPDF_Dictionary* pPage,
                         FX_BOOL bInsert,
                         std::set<CPDF_Dictionary*>* pVisited) {
-  CPDF_Array* pKidList = pPages->GetArrayBy("Kids");
+  CPDF_Array* pKidList = pPages->GetArrayFor("Kids");
   if (!pKidList)
     return -1;
 
   for (size_t i = 0; i < pKidList->GetCount(); i++) {
     CPDF_Dictionary* pKid = pKidList->GetDictAt(i);
-    if (pKid->GetStringBy("Type") == "Page") {
+    if (pKid->GetStringFor("Type") == "Page") {
       if (nPagesToGo == 0) {
         if (bInsert) {
           pKidList->InsertAt(i, new CPDF_Reference(pDoc, pPage->GetObjNum()));
-          pPage->SetAtReference("Parent", pDoc, pPages->GetObjNum());
+          pPage->SetReferenceFor("Parent", pDoc, pPages->GetObjNum());
         } else {
           pKidList->RemoveAt(i);
         }
-        pPages->SetAtInteger(
-            "Count", pPages->GetIntegerBy("Count") + (bInsert ? 1 : -1));
+        pPages->SetIntegerFor(
+            "Count", pPages->GetIntegerFor("Count") + (bInsert ? 1 : -1));
         return 1;
       }
       nPagesToGo--;
     } else {
-      int nPages = pKid->GetIntegerBy("Count");
+      int nPages = pKid->GetIntegerFor("Count");
       if (nPagesToGo < nPages) {
         if (pdfium::ContainsKey(*pVisited, pKid))
           return -1;
 
         pdfium::ScopedSetInsertion<CPDF_Dictionary*> insertion(pVisited, pKid);
         if (InsertDeletePDFPage(pDoc, pKid, nPagesToGo, pPage, bInsert,
                                 pVisited) < 0) {
           return -1;
         }
-        pPages->SetAtInteger(
-            "Count", pPages->GetIntegerBy("Count") + (bInsert ? 1 : -1));
+        pPages->SetIntegerFor(
+            "Count", pPages->GetIntegerFor("Count") + (bInsert ? 1 : -1));
         return 1;
       }
       nPagesToGo -= nPages;
     }
   }
   return 0;
 }
 
 int InsertNewPage(CPDF_Document* pDoc,
                   int iPage,
                   CPDF_Dictionary* pPageDict,
                   CFX_ArrayTemplate<uint32_t>& pageList) {
   CPDF_Dictionary* pRoot = pDoc->GetRoot();
-  CPDF_Dictionary* pPages = pRoot ? pRoot->GetDictBy("Pages") : nullptr;
+  CPDF_Dictionary* pPages = pRoot ? pRoot->GetDictFor("Pages") : nullptr;
   if (!pPages)
     return -1;
 
   int nPages = pDoc->GetPageCount();
   if (iPage < 0 || iPage > nPages)
     return -1;
 
   if (iPage == nPages) {
-    CPDF_Array* pPagesList = pPages->GetArrayBy("Kids");
+    CPDF_Array* pPagesList = pPages->GetArrayFor("Kids");
     if (!pPagesList) {
       pPagesList = new CPDF_Array;
-      pPages->SetAt("Kids", pPagesList);
+      pPages->SetFor("Kids", pPagesList);
     }
     pPagesList->Add(pPageDict, pDoc);
-    pPages->SetAtInteger("Count", nPages + 1);
-    pPageDict->SetAtReference("Parent", pDoc, pPages->GetObjNum());
+    pPages->SetIntegerFor("Count", nPages + 1);
+    pPageDict->SetReferenceFor("Parent", pDoc, pPages->GetObjNum());
   } else {
     std::set<CPDF_Dictionary*> stack = {pPages};
     if (InsertDeletePDFPage(pDoc, pPages, iPage, pPageDict, TRUE, &stack) < 0)
       return -1;
   }
   pageList.InsertAt(iPage, pPageDict->GetObjNum());
   return iPage;
 }
 
 int CountPages(CPDF_Dictionary* pPages,
                std::set<CPDF_Dictionary*>* visited_pages) {
-  int count = pPages->GetIntegerBy("Count");
+  int count = pPages->GetIntegerFor("Count");
   if (count > 0 && count < FPDF_PAGE_MAX_NUM)
     return count;
-  CPDF_Array* pKidList = pPages->GetArrayBy("Kids");
+  CPDF_Array* pKidList = pPages->GetArrayFor("Kids");
   if (!pKidList)
     return 0;
   count = 0;
   for (size_t i = 0; i < pKidList->GetCount(); i++) {
     CPDF_Dictionary* pKid = pKidList->GetDictAt(i);
     if (!pKid || pdfium::ContainsKey(*visited_pages, pKid))
       continue;
     if (pKid->KeyExist("Kids")) {
       // Use |visited_pages| to help detect circular references of pages.
       pdfium::ScopedSetInsertion<CPDF_Dictionary*> local_add(visited_pages,
                                                              pKid);
       count += CountPages(pKid, visited_pages);
     } else {
       // This page is a leaf node.
       count++;
     }
   }
-  pPages->SetAtInteger("Count", count);
+  pPages->SetIntegerFor("Count", count);
   return count;
 }
 
 int CalculateFlags(bool bold,
                    bool italic,
                    bool fixedPitch,
                    bool serif,
                    bool script,
                    bool symbolic) {
   int flags = 0;
@@ skipping 18 matching lines @@
                     bool bold,
                     bool italic,
                     CFX_ByteString basefont,
                     CPDF_Array* pWidths) {
   if (bold && italic)
     basefont += ",BoldItalic";
   else if (bold)
     basefont += ",Bold";
   else if (italic)
     basefont += ",Italic";
-  pBaseDict->SetAtName("Subtype", "TrueType");
-  pBaseDict->SetAtName("BaseFont", basefont);
-  pBaseDict->SetAtNumber("FirstChar", 32);
-  pBaseDict->SetAtNumber("LastChar", 255);
-  pBaseDict->SetAt("Widths", pWidths);
+  pBaseDict->SetNameFor("Subtype", "TrueType");
+  pBaseDict->SetNameFor("BaseFont", basefont);
+  pBaseDict->SetNumberFor("FirstChar", 32);
+  pBaseDict->SetNumberFor("LastChar", 255);
+  pBaseDict->SetFor("Widths", pWidths);
 }
 
 }  // namespace
 
 CPDF_Document::CPDF_Document(std::unique_ptr<CPDF_Parser> pParser)
     : CPDF_IndirectObjectHolder(),
       m_pParser(std::move(pParser)),
       m_pRootDict(nullptr),
       m_pInfoDict(nullptr),
       m_bLinearized(false),
@@ skipping 33 matching lines @@
 void CPDF_Document::LoadDoc() {
   LoadDocInternal();
   m_PageList.SetSize(RetrievePageCount());
 }
 
 void CPDF_Document::LoadLinearizedDoc(CPDF_Dictionary* pLinearizationParams) {
   m_bLinearized = true;
   LoadDocInternal();
 
   uint32_t dwPageCount = 0;
-  CPDF_Object* pCount = pLinearizationParams->GetObjectBy("N");
+  CPDF_Object* pCount = pLinearizationParams->GetObjectFor("N");
   if (ToNumber(pCount))
     dwPageCount = pCount->GetInteger();
   m_PageList.SetSize(dwPageCount);
 
-  CPDF_Object* pNo = pLinearizationParams->GetObjectBy("P");
+  CPDF_Object* pNo = pLinearizationParams->GetObjectFor("P");
   if (ToNumber(pNo))
     m_iFirstPageNo = pNo->GetInteger();
 
-  CPDF_Object* pObjNum = pLinearizationParams->GetObjectBy("O");
+  CPDF_Object* pObjNum = pLinearizationParams->GetObjectFor("O");
   if (ToNumber(pObjNum))
     m_dwFirstPageObjNum = pObjNum->GetInteger();
 }
 
 void CPDF_Document::LoadPages() {
   m_PageList.SetSize(RetrievePageCount());
 }
 
 CPDF_Dictionary* CPDF_Document::FindPDFPage(CPDF_Dictionary* pPages,
                                             int iPage,
                                             int nPagesToGo,
                                             int level) {
-  CPDF_Array* pKidList = pPages->GetArrayBy("Kids");
+  CPDF_Array* pKidList = pPages->GetArrayFor("Kids");
   if (!pKidList)
     return nPagesToGo == 0 ? pPages : nullptr;
 
   if (level >= FX_MAX_PAGE_LEVEL)
     return nullptr;
 
   for (size_t i = 0; i < pKidList->GetCount(); i++) {
     CPDF_Dictionary* pKid = pKidList->GetDictAt(i);
     if (!pKid) {
       nPagesToGo--;
       continue;
     }
     if (pKid == pPages)
       continue;
     if (!pKid->KeyExist("Kids")) {
       if (nPagesToGo == 0)
         return pKid;
 
       m_PageList.SetAt(iPage - nPagesToGo, pKid->GetObjNum());
       nPagesToGo--;
     } else {
-      int nPages = pKid->GetIntegerBy("Count");
+      int nPages = pKid->GetIntegerFor("Count");
       if (nPagesToGo < nPages)
         return FindPDFPage(pKid, iPage, nPagesToGo, level + 1);
 
       nPagesToGo -= nPages;
     }
   }
   return nullptr;
 }
 
 CPDF_Dictionary* CPDF_Document::GetPagesDict() const {
   CPDF_Dictionary* pRoot = GetRoot();
-  return pRoot ? pRoot->GetDictBy("Pages") : nullptr;
+  return pRoot ? pRoot->GetDictFor("Pages") : nullptr;
 }
 
 CPDF_Dictionary* CPDF_Document::GetPage(int iPage) {
   if (iPage < 0 || iPage >= m_PageList.GetSize())
     return nullptr;
 
   if (m_bLinearized && (iPage == m_iFirstPageNo)) {
     if (CPDF_Dictionary* pDict =
             ToDictionary(GetOrParseIndirectObject(m_dwFirstPageObjNum))) {
       return pDict;
@@ skipping 27 matching lines @@
     if (objnum == pNode->GetObjNum())
       return index;
 
     if (skip_count)
       skip_count--;
 
     index++;
     return -1;
   }
 
-  CPDF_Array* pKidList = pNode->GetArrayBy("Kids");
+  CPDF_Array* pKidList = pNode->GetArrayFor("Kids");
   if (!pKidList)
     return -1;
 
   if (level >= FX_MAX_PAGE_LEVEL)
     return -1;
 
-  size_t count = pNode->GetIntegerBy("Count");
+  size_t count = pNode->GetIntegerFor("Count");
   if (count <= skip_count) {
     skip_count -= count;
     index += count;
     return -1;
   }
 
   if (count && count == pKidList->GetCount()) {
     for (size_t i = 0; i < count; i++) {
       if (CPDF_Reference* pKid = ToReference(pKidList->GetObjectAt(i))) {
         if (pKid->GetRefObjNum() == objnum) {
@@ skipping 95 matching lines @@
   if (!pObj)
     return nullptr;
 
   ASSERT(pObj->GetObjNum());
   return m_pDocPage->GetImage(pObj);
 }
 
 void CPDF_Document::CreateNewDoc() {
   ASSERT(!m_pRootDict && !m_pInfoDict);
   m_pRootDict = new CPDF_Dictionary;
-  m_pRootDict->SetAtName("Type", "Catalog");
+  m_pRootDict->SetNameFor("Type", "Catalog");
   int objnum = AddIndirectObject(m_pRootDict);
   CPDF_Dictionary* pPages = new CPDF_Dictionary;
-  pPages->SetAtName("Type", "Pages");
-  pPages->SetAtNumber("Count", 0);
-  pPages->SetAt("Kids", new CPDF_Array);
+  pPages->SetNameFor("Type", "Pages");
+  pPages->SetNumberFor("Count", 0);
+  pPages->SetFor("Kids", new CPDF_Array);
   objnum = AddIndirectObject(pPages);
-  m_pRootDict->SetAtReference("Pages", this, objnum);
+  m_pRootDict->SetReferenceFor("Pages", this, objnum);
   m_pInfoDict = new CPDF_Dictionary;
   AddIndirectObject(m_pInfoDict);
 }
 
 CPDF_Dictionary* CPDF_Document::CreateNewPage(int iPage) {
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
-  pDict->SetAtName("Type", "Page");
+  pDict->SetNameFor("Type", "Page");
   uint32_t dwObjNum = AddIndirectObject(pDict);
   if (InsertNewPage(this, iPage, pDict, m_PageList) < 0) {
     ReleaseIndirectObject(dwObjNum);
     return nullptr;
   }
   return pDict;
 }
 
 void CPDF_Document::DeletePage(int iPage) {
   CPDF_Dictionary* pPages = GetPagesDict();
   if (!pPages)
     return;
 
-  int nPages = pPages->GetIntegerBy("Count");
+  int nPages = pPages->GetIntegerFor("Count");
   if (iPage < 0 || iPage >= nPages)
     return;
 
   std::set<CPDF_Dictionary*> stack = {pPages};
   if (InsertDeletePDFPage(this, pPages, iPage, nullptr, FALSE, &stack) < 0)
     return;
 
   m_PageList.RemoveAt(iPage);
 }
 
 CPDF_Font* CPDF_Document::AddStandardFont(const FX_CHAR* font,
                                           CPDF_FontEncoding* pEncoding) {
   CFX_ByteString name(font);
   if (PDF_GetStandardFontName(&name) < 0)
     return nullptr;
   return GetPageData()->GetStandardFont(name, pEncoding);
 }
 
 size_t CPDF_Document::CalculateEncodingDict(int charset,
                                             CPDF_Dictionary* pBaseDict) {
   size_t i;
   for (i = 0; i < FX_ArraySize(g_FX_CharsetUnicodes); ++i) {
     if (g_FX_CharsetUnicodes[i].m_Charset == charset)
       break;
   }
   if (i == FX_ArraySize(g_FX_CharsetUnicodes))
     return i;
   CPDF_Dictionary* pEncodingDict = new CPDF_Dictionary;
-  pEncodingDict->SetAtName("BaseEncoding", "WinAnsiEncoding");
+  pEncodingDict->SetNameFor("BaseEncoding", "WinAnsiEncoding");
   CPDF_Array* pArray = new CPDF_Array;
   pArray->AddInteger(128);
   const uint16_t* pUnicodes = g_FX_CharsetUnicodes[i].m_pUnicodes;
   for (int j = 0; j < 128; j++) {
     CFX_ByteString name = PDF_AdobeNameFromUnicode(pUnicodes[j]);
     pArray->AddName(name.IsEmpty() ? ".notdef" : name);
   }
-  pEncodingDict->SetAt("Differences", pArray);
+  pEncodingDict->SetFor("Differences", pArray);
   AddIndirectObject(pEncodingDict);
-  pBaseDict->SetAtReference("Encoding", this, pEncodingDict);
+  pBaseDict->SetReferenceFor("Encoding", this, pEncodingDict);
   return i;
 }
 
 CPDF_Font* CPDF_Document::AddFont(CFX_Font* pFont, int charset, FX_BOOL bVert) {
   if (!pFont)
     return nullptr;
 
   bool bCJK = charset == FXFONT_CHINESEBIG5_CHARSET ||
               charset == FXFONT_GB2312_CHARSET ||
               charset == FXFONT_HANGEUL_CHARSET ||
               charset == FXFONT_SHIFTJIS_CHARSET;
   CFX_ByteString basefont = pFont->GetFamilyName();
   basefont.Replace(" ", "");
   int flags =
       CalculateFlags(pFont->IsBold(), pFont->IsItalic(), pFont->IsFixedWidth(),
                      false, false, charset == FXFONT_SYMBOL_CHARSET);
 
   CPDF_Dictionary* pBaseDict = new CPDF_Dictionary;
-  pBaseDict->SetAtName("Type", "Font");
+  pBaseDict->SetNameFor("Type", "Font");
   std::unique_ptr<CFX_UnicodeEncoding> pEncoding(
       new CFX_UnicodeEncoding(pFont));
   CPDF_Dictionary* pFontDict = pBaseDict;
   if (!bCJK) {
     CPDF_Array* pWidths = new CPDF_Array;
     for (int charcode = 32; charcode < 128; charcode++) {
       int glyph_index = pEncoding->GlyphFromCharCode(charcode);
       int char_width = pFont->GetGlyphWidth(glyph_index);
       pWidths->AddInteger(char_width);
     }
     if (charset == FXFONT_ANSI_CHARSET || charset == FXFONT_DEFAULT_CHARSET ||
         charset == FXFONT_SYMBOL_CHARSET) {
-      pBaseDict->SetAtName("Encoding", "WinAnsiEncoding");
+      pBaseDict->SetNameFor("Encoding", "WinAnsiEncoding");
       for (int charcode = 128; charcode <= 255; charcode++) {
         int glyph_index = pEncoding->GlyphFromCharCode(charcode);
         int char_width = pFont->GetGlyphWidth(glyph_index);
         pWidths->AddInteger(char_width);
       }
     } else {
       size_t i = CalculateEncodingDict(charset, pBaseDict);
       if (i < FX_ArraySize(g_FX_CharsetUnicodes)) {
         const uint16_t* pUnicodes = g_FX_CharsetUnicodes[i].m_pUnicodes;
         for (int j = 0; j < 128; j++) {
@@ skipping 43 matching lines @@
         pWidthArray->AddInteger(231);
         InsertWidthArray1(pFont, pEncoding.get(), 0x20, 0x7d, pWidthArray);
         pWidthArray->AddInteger(326);
         InsertWidthArray1(pFont, pEncoding.get(), 0xa0, 0xa0, pWidthArray);
         pWidthArray->AddInteger(327);
         InsertWidthArray1(pFont, pEncoding.get(), 0xa1, 0xdf, pWidthArray);
         pWidthArray->AddInteger(631);
         InsertWidthArray1(pFont, pEncoding.get(), 0x7e, 0x7e, pWidthArray);
         break;
     }
-    pBaseDict->SetAtName("Subtype", "Type0");
-    pBaseDict->SetAtName("BaseFont", basefont);
-    pBaseDict->SetAtName("Encoding", cmap);
-    pFontDict->SetAt("W", pWidthArray);
-    pFontDict->SetAtName("Type", "Font");
-    pFontDict->SetAtName("Subtype", "CIDFontType2");
-    pFontDict->SetAtName("BaseFont", basefont);
+    pBaseDict->SetNameFor("Subtype", "Type0");
+    pBaseDict->SetNameFor("BaseFont", basefont);
+    pBaseDict->SetNameFor("Encoding", cmap);
+    pFontDict->SetFor("W", pWidthArray);
+    pFontDict->SetNameFor("Type", "Font");
+    pFontDict->SetNameFor("Subtype", "CIDFontType2");
+    pFontDict->SetNameFor("BaseFont", basefont);
     CPDF_Dictionary* pCIDSysInfo = new CPDF_Dictionary;
-    pCIDSysInfo->SetAtString("Registry", "Adobe");
-    pCIDSysInfo->SetAtString("Ordering", ordering);
-    pCIDSysInfo->SetAtInteger("Supplement", supplement);
-    pFontDict->SetAt("CIDSystemInfo", pCIDSysInfo);
+    pCIDSysInfo->SetStringFor("Registry", "Adobe");
+    pCIDSysInfo->SetStringFor("Ordering", ordering);
+    pCIDSysInfo->SetIntegerFor("Supplement", supplement);
+    pFontDict->SetFor("CIDSystemInfo", pCIDSysInfo);
     CPDF_Array* pArray = new CPDF_Array;
-    pBaseDict->SetAt("DescendantFonts", pArray);
+    pBaseDict->SetFor("DescendantFonts", pArray);
     AddIndirectObject(pFontDict);
     pArray->AddReference(this, pFontDict);
   }
   AddIndirectObject(pBaseDict);
   CPDF_Dictionary* pFontDesc = new CPDF_Dictionary;
-  pFontDesc->SetAtName("Type", "FontDescriptor");
-  pFontDesc->SetAtName("FontName", basefont);
-  pFontDesc->SetAtInteger("Flags", flags);
-  pFontDesc->SetAtInteger(
+  pFontDesc->SetNameFor("Type", "FontDescriptor");
+  pFontDesc->SetNameFor("FontName", basefont);
+  pFontDesc->SetIntegerFor("Flags", flags);
+  pFontDesc->SetIntegerFor(
       "ItalicAngle",
       pFont->GetSubstFont() ? pFont->GetSubstFont()->m_ItalicAngle : 0);
-  pFontDesc->SetAtInteger("Ascent", pFont->GetAscent());
-  pFontDesc->SetAtInteger("Descent", pFont->GetDescent());
+  pFontDesc->SetIntegerFor("Ascent", pFont->GetAscent());
+  pFontDesc->SetIntegerFor("Descent", pFont->GetDescent());
   FX_RECT bbox;
   pFont->GetBBox(bbox);
   CPDF_Array* pBBox = new CPDF_Array;
   pBBox->AddInteger(bbox.left);
   pBBox->AddInteger(bbox.bottom);
   pBBox->AddInteger(bbox.right);
   pBBox->AddInteger(bbox.top);
-  pFontDesc->SetAt("FontBBox", pBBox);
+  pFontDesc->SetFor("FontBBox", pBBox);
   int32_t nStemV = 0;
   if (pFont->GetSubstFont()) {
     nStemV = pFont->GetSubstFont()->m_Weight / 5;
   } else {
     static const FX_CHAR stem_chars[] = {'i', 'I', '!', '1'};
     const size_t count = FX_ArraySize(stem_chars);
     uint32_t glyph = pEncoding->GlyphFromCharCode(stem_chars[0]);
     nStemV = pFont->GetGlyphWidth(glyph);
     for (size_t i = 1; i < count; i++) {
       glyph = pEncoding->GlyphFromCharCode(stem_chars[i]);
       int width = pFont->GetGlyphWidth(glyph);
       if (width > 0 && width < nStemV)
         nStemV = width;
     }
   }
-  pFontDesc->SetAtInteger("StemV", nStemV);
+  pFontDesc->SetIntegerFor("StemV", nStemV);
   AddIndirectObject(pFontDesc);
-  pFontDict->SetAtReference("FontDescriptor", this, pFontDesc);
+  pFontDict->SetReferenceFor("FontDescriptor", this, pFontDesc);
   return LoadFont(pBaseDict);
 }
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTW* pLogFont,
                                          FX_BOOL bVert,
                                          FX_BOOL bTranslateName) {
   LOGFONTA lfa;
   FXSYS_memcpy(&lfa, pLogFont, (char*)lfa.lfFaceName - (char*)&lfa);
   CFX_ByteString face = CFX_ByteString::FromUnicode(pLogFont->lfFaceName);
@@ skipping 42 matching lines @@
 
   int italicangle = ptm->otmItalicAngle / 10;
   int ascend = ptm->otmrcFontBox.top;
   int descend = ptm->otmrcFontBox.bottom;
   int capheight = ptm->otmsCapEmHeight;
   int bbox[4] = {ptm->otmrcFontBox.left, ptm->otmrcFontBox.bottom,
                  ptm->otmrcFontBox.right, ptm->otmrcFontBox.top};
   FX_Free(tm_buf);
   basefont.Replace(" ", "");
   CPDF_Dictionary* pBaseDict = new CPDF_Dictionary;
-  pBaseDict->SetAtName("Type", "Font");
+  pBaseDict->SetNameFor("Type", "Font");
   CPDF_Dictionary* pFontDict = pBaseDict;
   if (!bCJK) {
     if (pLogFont->lfCharSet == ANSI_CHARSET ||
         pLogFont->lfCharSet == DEFAULT_CHARSET ||
         pLogFont->lfCharSet == SYMBOL_CHARSET) {
-      pBaseDict->SetAtName("Encoding", "WinAnsiEncoding");
+      pBaseDict->SetNameFor("Encoding", "WinAnsiEncoding");
     } else {
       CalculateEncodingDict(pLogFont->lfCharSet, pBaseDict);
     }
     int char_widths[224];
     GetCharWidth(hDC, 32, 255, char_widths);
     CPDF_Array* pWidths = new CPDF_Array;
     for (size_t i = 0; i < 224; i++)
       pWidths->AddInteger(char_widths[i]);
     ProcessNonbCJK(pBaseDict, pLogFont->lfWeight > FW_MEDIUM,
                    pLogFont->lfItalic != 0, basefont, pWidths);
@@ skipping 33 matching lines @@
         pWidthArray->AddInteger(231);
         InsertWidthArray(hDC, 0x20, 0x7d, pWidthArray);
         pWidthArray->AddInteger(326);
         InsertWidthArray(hDC, 0xa0, 0xa0, pWidthArray);
         pWidthArray->AddInteger(327);
         InsertWidthArray(hDC, 0xa1, 0xdf, pWidthArray);
         pWidthArray->AddInteger(631);
         InsertWidthArray(hDC, 0x7e, 0x7e, pWidthArray);
         break;
     }
-    pBaseDict->SetAtName("Subtype", "Type0");
-    pBaseDict->SetAtName("BaseFont", basefont);
-    pBaseDict->SetAtName("Encoding", cmap);
-    pFontDict->SetAt("W", pWidthArray);
-    pFontDict->SetAtName("Type", "Font");
-    pFontDict->SetAtName("Subtype", "CIDFontType2");
-    pFontDict->SetAtName("BaseFont", basefont);
+    pBaseDict->SetNameFor("Subtype", "Type0");
+    pBaseDict->SetNameFor("BaseFont", basefont);
+    pBaseDict->SetNameFor("Encoding", cmap);
+    pFontDict->SetFor("W", pWidthArray);
+    pFontDict->SetNameFor("Type", "Font");
+    pFontDict->SetNameFor("Subtype", "CIDFontType2");
+    pFontDict->SetNameFor("BaseFont", basefont);
     CPDF_Dictionary* pCIDSysInfo = new CPDF_Dictionary;
-    pCIDSysInfo->SetAtString("Registry", "Adobe");
-    pCIDSysInfo->SetAtString("Ordering", ordering);
-    pCIDSysInfo->SetAtInteger("Supplement", supplement);
-    pFontDict->SetAt("CIDSystemInfo", pCIDSysInfo);
+    pCIDSysInfo->SetStringFor("Registry", "Adobe");
+    pCIDSysInfo->SetStringFor("Ordering", ordering);
+    pCIDSysInfo->SetIntegerFor("Supplement", supplement);
+    pFontDict->SetFor("CIDSystemInfo", pCIDSysInfo);
     CPDF_Array* pArray = new CPDF_Array;
-    pBaseDict->SetAt("DescendantFonts", pArray);
+    pBaseDict->SetFor("DescendantFonts", pArray);
     AddIndirectObject(pFontDict);
     pArray->AddReference(this, pFontDict);
   }
   AddIndirectObject(pBaseDict);
   CPDF_Dictionary* pFontDesc = new CPDF_Dictionary;
-  pFontDesc->SetAtName("Type", "FontDescriptor");
-  pFontDesc->SetAtName("FontName", basefont);
-  pFontDesc->SetAtInteger("Flags", flags);
+  pFontDesc->SetNameFor("Type", "FontDescriptor");
+  pFontDesc->SetNameFor("FontName", basefont);
+  pFontDesc->SetIntegerFor("Flags", flags);
   CPDF_Array* pBBox = new CPDF_Array;
   for (int i = 0; i < 4; i++)
     pBBox->AddInteger(bbox[i]);
-  pFontDesc->SetAt("FontBBox", pBBox);
-  pFontDesc->SetAtInteger("ItalicAngle", italicangle);
-  pFontDesc->SetAtInteger("Ascent", ascend);
-  pFontDesc->SetAtInteger("Descent", descend);
-  pFontDesc->SetAtInteger("CapHeight", capheight);
-  pFontDesc->SetAtInteger("StemV", pLogFont->lfWeight / 5);
+  pFontDesc->SetFor("FontBBox", pBBox);
+  pFontDesc->SetIntegerFor("ItalicAngle", italicangle);
+  pFontDesc->SetIntegerFor("Ascent", ascend);
+  pFontDesc->SetIntegerFor("Descent", descend);
+  pFontDesc->SetIntegerFor("CapHeight", capheight);
+  pFontDesc->SetIntegerFor("StemV", pLogFont->lfWeight / 5);
   AddIndirectObject(pFontDesc);
-  pFontDict->SetAtReference("FontDescriptor", this, pFontDesc);
+  pFontDict->SetReferenceFor("FontDescriptor", this, pFontDesc);
   hFont = SelectObject(hDC, hFont);
   DeleteObject(hFont);
   DeleteDC(hDC);
   return LoadFont(pBaseDict);
 }
 #endif  //  _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_