Member function name refactoring

fpdfsdk/src/fsdk_baseannot.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 <algorithm>
 
 #include "core/include/fxcrt/fx_ext.h"
 #include "fpdfsdk/include/fsdk_baseannot.h"
@@ skipping 545 matching lines @@
 
 void CPDFSDK_BAAnnot::DrawAppearance(CFX_RenderDevice* pDevice,
                                      const CFX_Matrix* pUser2Device,
                                      CPDF_Annot::AppearanceMode mode,
                                      const CPDF_RenderOptions* pOptions) {
   m_pAnnot->DrawAppearance(m_pPageView->GetPDFPage(), pDevice, pUser2Device,
                            mode, pOptions);
 }
 
 FX_BOOL CPDFSDK_BAAnnot::IsAppearanceValid() {
-  return m_pAnnot->GetAnnotDict()->GetDict("AP") != NULL;
+  return m_pAnnot->GetAnnotDict()->GetDictBy("AP") != NULL;
 }
 
 FX_BOOL CPDFSDK_BAAnnot::IsAppearanceValid(CPDF_Annot::AppearanceMode mode) {
-  CPDF_Dictionary* pAP = m_pAnnot->GetAnnotDict()->GetDict("AP");
+  CPDF_Dictionary* pAP = m_pAnnot->GetAnnotDict()->GetDictBy("AP");
   if (!pAP)
     return FALSE;
 
   // Choose the right sub-ap
   const FX_CHAR* ap_entry = "N";
   if (mode == CPDF_Annot::Down)
     ap_entry = "D";
   else if (mode == CPDF_Annot::Rollover)
     ap_entry = "R";
   if (!pAP->KeyExist(ap_entry))
@@ skipping 16 matching lines @@
 
 void CPDFSDK_BAAnnot::SetContents(const CFX_WideString& sContents) {
   if (sContents.IsEmpty())
     m_pAnnot->GetAnnotDict()->RemoveAt("Contents");
   else
     m_pAnnot->GetAnnotDict()->SetAtString("Contents",
                                           PDF_EncodeText(sContents));
 }
 
 CFX_WideString CPDFSDK_BAAnnot::GetContents() const {
-  return m_pAnnot->GetAnnotDict()->GetUnicodeText("Contents");
+  return m_pAnnot->GetAnnotDict()->GetUnicodeTextBy("Contents");
 }
 
 void CPDFSDK_BAAnnot::SetAnnotName(const CFX_WideString& sName) {
   if (sName.IsEmpty())
     m_pAnnot->GetAnnotDict()->RemoveAt("NM");
   else
     m_pAnnot->GetAnnotDict()->SetAtString("NM", PDF_EncodeText(sName));
 }
 
 CFX_WideString CPDFSDK_BAAnnot::GetAnnotName() const {
-  return m_pAnnot->GetAnnotDict()->GetUnicodeText("NM");
+  return m_pAnnot->GetAnnotDict()->GetUnicodeTextBy("NM");
 }
 
 void CPDFSDK_BAAnnot::SetModifiedDate(const FX_SYSTEMTIME& st) {
   CPDFSDK_DateTime dt(st);
   CFX_ByteString str = dt.ToPDFDateTimeString();
 
   if (str.IsEmpty())
     m_pAnnot->GetAnnotDict()->RemoveAt("M");
   else
     m_pAnnot->GetAnnotDict()->SetAtString("M", str);
 }
 
 FX_SYSTEMTIME CPDFSDK_BAAnnot::GetModifiedDate() const {
   FX_SYSTEMTIME systime;
-  CFX_ByteString str = m_pAnnot->GetAnnotDict()->GetString("M");
+  CFX_ByteString str = m_pAnnot->GetAnnotDict()->GetStringBy("M");
 
   CPDFSDK_DateTime dt(str);
   dt.ToSystemTime(systime);
 
   return systime;
 }
 
 void CPDFSDK_BAAnnot::SetFlags(int nFlags) {
   m_pAnnot->GetAnnotDict()->SetAtInteger("F", nFlags);
 }
 
 int CPDFSDK_BAAnnot::GetFlags() const {
-  return m_pAnnot->GetAnnotDict()->GetInteger("F");
+  return m_pAnnot->GetAnnotDict()->GetIntegerBy("F");
 }
 
 void CPDFSDK_BAAnnot::SetAppState(const CFX_ByteString& str) {
   if (str.IsEmpty())
     m_pAnnot->GetAnnotDict()->RemoveAt("AS");
   else
     m_pAnnot->GetAnnotDict()->SetAtString("AS", str);
 }
 
 CFX_ByteString CPDFSDK_BAAnnot::GetAppState() const {
-  return m_pAnnot->GetAnnotDict()->GetString("AS");
+  return m_pAnnot->GetAnnotDict()->GetStringBy("AS");
 }
 
 void CPDFSDK_BAAnnot::SetStructParent(int key) {
   m_pAnnot->GetAnnotDict()->SetAtInteger("StructParent", key);
 }
 
 int CPDFSDK_BAAnnot::GetStructParent() const {
-  return m_pAnnot->GetAnnotDict()->GetInteger("StructParent");
+  return m_pAnnot->GetAnnotDict()->GetIntegerBy("StructParent");
 }
 
 // border
 void CPDFSDK_BAAnnot::SetBorderWidth(int nWidth) {
-  CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArray("Border");
+  CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArrayBy("Border");
 
   if (pBorder) {
     pBorder->SetAt(2, new CPDF_Number(nWidth));
   } else {
-    CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDict("BS");
+    CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictBy("BS");
 
     if (!pBSDict) {
       pBSDict = new CPDF_Dictionary;
       m_pAnnot->GetAnnotDict()->SetAt("BS", pBSDict);
     }
 
     pBSDict->SetAtInteger("W", nWidth);
   }
 }
 
 int CPDFSDK_BAAnnot::GetBorderWidth() const {
-  if (CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArray("Border")) {
-    return pBorder->GetInteger(2);
+  if (CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArrayBy("Border")) {
+    return pBorder->GetIntegerAt(2);
   }
-  if (CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDict("BS")) {
-    return pBSDict->GetInteger("W", 1);
+  if (CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictBy("BS")) {
+    return pBSDict->GetIntegerBy("W", 1);
   }
   return 1;
 }
 
 void CPDFSDK_BAAnnot::SetBorderStyle(int nStyle) {
-  CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDict("BS");
+  CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictBy("BS");
   if (!pBSDict) {
     pBSDict = new CPDF_Dictionary;
     m_pAnnot->GetAnnotDict()->SetAt("BS", pBSDict);
   }
 
   switch (nStyle) {
     case BBS_SOLID:
       pBSDict->SetAtName("S", "S");
       break;
     case BBS_DASH:
       pBSDict->SetAtName("S", "D");
       break;
     case BBS_BEVELED:
       pBSDict->SetAtName("S", "B");
       break;
     case BBS_INSET:
       pBSDict->SetAtName("S", "I");
       break;
     case BBS_UNDERLINE:
       pBSDict->SetAtName("S", "U");
       break;
   }
 }
 
 int CPDFSDK_BAAnnot::GetBorderStyle() const {
-  CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDict("BS");
+  CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictBy("BS");
   if (pBSDict) {
-    CFX_ByteString sBorderStyle = pBSDict->GetString("S", "S");
+    CFX_ByteString sBorderStyle = pBSDict->GetStringBy("S", "S");
     if (sBorderStyle == "S")
       return BBS_SOLID;
     if (sBorderStyle == "D")
       return BBS_DASH;
     if (sBorderStyle == "B")
       return BBS_BEVELED;
     if (sBorderStyle == "I")
       return BBS_INSET;
     if (sBorderStyle == "U")
       return BBS_UNDERLINE;
   }
 
-  CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArray("Border");
+  CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArrayBy("Border");
   if (pBorder) {
     if (pBorder->GetCount() >= 4) {
-      CPDF_Array* pDP = pBorder->GetArray(3);
+      CPDF_Array* pDP = pBorder->GetArrayAt(3);
       if (pDP && pDP->GetCount() > 0)
         return BBS_DASH;
     }
   }
 
   return BBS_SOLID;
 }
 
 void CPDFSDK_BAAnnot::SetBorderDash(const CFX_IntArray& array) {
-  CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDict("BS");
+  CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictBy("BS");
   if (!pBSDict) {
     pBSDict = new CPDF_Dictionary;
     m_pAnnot->GetAnnotDict()->SetAt("BS", pBSDict);
   }
 
   CPDF_Array* pArray = new CPDF_Array;
   for (int i = 0, sz = array.GetSize(); i < sz; i++) {
     pArray->AddInteger(array[i]);
   }
 
   pBSDict->SetAt("D", pArray);
 }
 
 void CPDFSDK_BAAnnot::GetBorderDash(CFX_IntArray& array) const {
   CPDF_Array* pDash = NULL;
 
-  CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArray("Border");
+  CPDF_Array* pBorder = m_pAnnot->GetAnnotDict()->GetArrayBy("Border");
   if (pBorder) {
-    pDash = pBorder->GetArray(3);
+    pDash = pBorder->GetArrayAt(3);
   } else {
-    CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDict("BS");
+    CPDF_Dictionary* pBSDict = m_pAnnot->GetAnnotDict()->GetDictBy("BS");
     if (pBSDict) {
-      pDash = pBSDict->GetArray("D");
+      pDash = pBSDict->GetArrayBy("D");
     }
   }
 
   if (pDash) {
     for (int i = 0, sz = pDash->GetCount(); i < sz; i++) {
-      array.Add(pDash->GetInteger(i));
+      array.Add(pDash->GetIntegerAt(i));
     }
   }
 }
 
 void CPDFSDK_BAAnnot::SetColor(FX_COLORREF color) {
   CPDF_Array* pArray = new CPDF_Array;
   pArray->AddNumber((FX_FLOAT)FXSYS_GetRValue(color) / 255.0f);
   pArray->AddNumber((FX_FLOAT)FXSYS_GetGValue(color) / 255.0f);
   pArray->AddNumber((FX_FLOAT)FXSYS_GetBValue(color) / 255.0f);
   m_pAnnot->GetAnnotDict()->SetAt("C", pArray);
 }
 
 void CPDFSDK_BAAnnot::RemoveColor() {
   m_pAnnot->GetAnnotDict()->RemoveAt("C");
 }
 
 FX_BOOL CPDFSDK_BAAnnot::GetColor(FX_COLORREF& color) const {
-  if (CPDF_Array* pEntry = m_pAnnot->GetAnnotDict()->GetArray("C")) {
+  if (CPDF_Array* pEntry = m_pAnnot->GetAnnotDict()->GetArrayBy("C")) {
     int nCount = pEntry->GetCount();
     if (nCount == 1) {
-      FX_FLOAT g = pEntry->GetNumber(0) * 255;
+      FX_FLOAT g = pEntry->GetNumberAt(0) * 255;
 
       color = FXSYS_RGB((int)g, (int)g, (int)g);
 
       return TRUE;
     } else if (nCount == 3) {
-      FX_FLOAT r = pEntry->GetNumber(0) * 255;
-      FX_FLOAT g = pEntry->GetNumber(1) * 255;
-      FX_FLOAT b = pEntry->GetNumber(2) * 255;
+      FX_FLOAT r = pEntry->GetNumberAt(0) * 255;
+      FX_FLOAT g = pEntry->GetNumberAt(1) * 255;
+      FX_FLOAT b = pEntry->GetNumberAt(2) * 255;
 
       color = FXSYS_RGB((int)r, (int)g, (int)b);
 
       return TRUE;
     } else if (nCount == 4) {
-      FX_FLOAT c = pEntry->GetNumber(0);
-      FX_FLOAT m = pEntry->GetNumber(1);
-      FX_FLOAT y = pEntry->GetNumber(2);
-      FX_FLOAT k = pEntry->GetNumber(3);
+      FX_FLOAT c = pEntry->GetNumberAt(0);
+      FX_FLOAT m = pEntry->GetNumberAt(1);
+      FX_FLOAT y = pEntry->GetNumberAt(2);
+      FX_FLOAT k = pEntry->GetNumberAt(3);
 
       FX_FLOAT r = 1.0f - std::min(1.0f, c + k);
       FX_FLOAT g = 1.0f - std::min(1.0f, m + k);
       FX_FLOAT b = 1.0f - std::min(1.0f, y + k);
 
       color = FXSYS_RGB((int)(r * 255), (int)(g * 255), (int)(b * 255));
 
       return TRUE;
     }
   }
 
   return FALSE;
 }
 
 void CPDFSDK_BAAnnot::WriteAppearance(const CFX_ByteString& sAPType,
                                       const CPDF_Rect& rcBBox,
                                       const CFX_Matrix& matrix,
                                       const CFX_ByteString& sContents,
                                       const CFX_ByteString& sAPState) {
-  CPDF_Dictionary* pAPDict = m_pAnnot->GetAnnotDict()->GetDict("AP");
+  CPDF_Dictionary* pAPDict = m_pAnnot->GetAnnotDict()->GetDictBy("AP");
 
   if (!pAPDict) {
     pAPDict = new CPDF_Dictionary;
     m_pAnnot->GetAnnotDict()->SetAt("AP", pAPDict);
   }
 
   CPDF_Stream* pStream = nullptr;
   CPDF_Dictionary* pParentDict = nullptr;
 
   if (sAPState.IsEmpty()) {
     pParentDict = pAPDict;
-    pStream = pAPDict->GetStream(sAPType);
+    pStream = pAPDict->GetStreamBy(sAPType);
   } else {
-    CPDF_Dictionary* pAPTypeDict = pAPDict->GetDict(sAPType);
+    CPDF_Dictionary* pAPTypeDict = pAPDict->GetDictBy(sAPType);
     if (!pAPTypeDict) {
       pAPTypeDict = new CPDF_Dictionary;
       pAPDict->SetAt(sAPType, pAPTypeDict);
     }
 
     pParentDict = pAPTypeDict;
-    pStream = pAPTypeDict->GetStream(sAPState);
+    pStream = pAPTypeDict->GetStreamBy(sAPState);
   }
 
   if (!pStream) {
     pStream = new CPDF_Stream(nullptr, 0, nullptr);
 
     CPDF_Document* pDoc = m_pPageView->GetPDFDocument();
     int32_t objnum = pDoc->AddIndirectObject(pStream);
     pParentDict->SetAtReference(sAPType, pDoc, objnum);
   }
 
@@ skipping 29 matching lines @@
 FX_BOOL CPDFSDK_BAAnnot::CreateFormFiller() {
   return TRUE;
 }
 FX_BOOL CPDFSDK_BAAnnot::IsVisible() const {
   int nFlags = GetFlags();
   return !((nFlags & ANNOTFLAG_INVISIBLE) || (nFlags & ANNOTFLAG_HIDDEN) ||
            (nFlags & ANNOTFLAG_NOVIEW));
 }
 
 CPDF_Action CPDFSDK_BAAnnot::GetAction() const {
-  return CPDF_Action(m_pAnnot->GetAnnotDict()->GetDict("A"));
+  return CPDF_Action(m_pAnnot->GetAnnotDict()->GetDictBy("A"));
 }
 
 void CPDFSDK_BAAnnot::SetAction(const CPDF_Action& action) {
   ASSERT(action);
   if ((CPDF_Action&)action !=
-      CPDF_Action(m_pAnnot->GetAnnotDict()->GetDict("A"))) {
+      CPDF_Action(m_pAnnot->GetAnnotDict()->GetDictBy("A"))) {
     CPDF_Document* pDoc = m_pPageView->GetPDFDocument();
     CPDF_Dictionary* pDict = action.GetDict();
     if (pDict && pDict->GetObjNum() == 0) {
       pDoc->AddIndirectObject(pDict);
     }
     m_pAnnot->GetAnnotDict()->SetAtReference("A", pDoc, pDict->GetObjNum());
   }
 }
 
 void CPDFSDK_BAAnnot::RemoveAction() {
   m_pAnnot->GetAnnotDict()->RemoveAt("A");
 }
 
 CPDF_AAction CPDFSDK_BAAnnot::GetAAction() const {
-  return m_pAnnot->GetAnnotDict()->GetDict("AA");
+  return m_pAnnot->GetAnnotDict()->GetDictBy("AA");
 }
 
 void CPDFSDK_BAAnnot::SetAAction(const CPDF_AAction& aa) {
-  if ((CPDF_AAction&)aa != m_pAnnot->GetAnnotDict()->GetDict("AA"))
+  if ((CPDF_AAction&)aa != m_pAnnot->GetAnnotDict()->GetDictBy("AA"))
     m_pAnnot->GetAnnotDict()->SetAt("AA", (CPDF_AAction&)aa);
 }
 
 void CPDFSDK_BAAnnot::RemoveAAction() {
   m_pAnnot->GetAnnotDict()->RemoveAt("AA");
 }
 
 CPDF_Action CPDFSDK_BAAnnot::GetAAction(CPDF_AAction::AActionType eAAT) {
   CPDF_AAction AAction = GetAAction();
 
@@ skipping 14 matching lines @@
                            CPDF_Annot::Normal, NULL);
 }
 
 UnderlyingPageType* CPDFSDK_Annot::GetUnderlyingPage() {
   return GetPDFPage();
 }
 
 CPDF_Page* CPDFSDK_Annot::GetPDFPage() {
   return m_pPageView ? m_pPageView->GetPDFPage() : nullptr;
 }