Splitting fpdfdoc/doc_* part III.

core/fpdfdoc/cpdf_formfield.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/fpdfdoc/include/cpdf_formfield.h"
 
 #include "core/fpdfapi/fpdf_parser/include/cfdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_number.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_simple_parser.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_string.h"
 #include "core/fpdfapi/fpdf_parser/include/fpdf_parser_decode.h"
 #include "core/fpdfdoc/cpvt_generateap.h"
-#include "core/fpdfdoc/doc_utils.h"
 #include "core/fpdfdoc/include/cpdf_formcontrol.h"
 #include "core/fpdfdoc/include/cpdf_interform.h"
 
 namespace {
 
+const int kMaxRecursion = 32;
+
 const int kFormListMultiSelect = 0x100;
 
 const int kFormComboEdit = 0x100;
 
 const int kFormFieldReadOnly = 0x01;
 const int kFormFieldRequired = 0x02;
 const int kFormFieldNoExport = 0x04;
 
 const int kFormRadioNoToggleOff = 0x100;
 const int kFormRadioUnison = 0x200;
 
 const int kFormTextMultiLine = 0x100;
 const int kFormTextPassword = 0x200;
 const int kFormTextNoScroll = 0x400;
 const int kFormTextComb = 0x800;
 
-bool PDF_FormField_IsUnison(CPDF_FormField* pField) {
+bool IsUnison(CPDF_FormField* pField) {
   if (pField->GetType() == CPDF_FormField::CheckBox)
     return true;
-
   return (pField->GetFieldFlags() & 0x2000000) != 0;
 }
 
 }  // namespace
 
+CPDF_Object* FPDF_GetFieldAttr(CPDF_Dictionary* pFieldDict,
+                               const FX_CHAR* name,
+                               int nLevel) {
+  if (nLevel > kMaxRecursion)
+    return nullptr;
+  if (!pFieldDict)
+    return nullptr;
+
+  CPDF_Object* pAttr = pFieldDict->GetDirectObjectBy(name);
+  if (pAttr)
+    return pAttr;
+
+  CPDF_Dictionary* pParent = pFieldDict->GetDictBy("Parent");
+  if (!pParent)
+    return nullptr;
+  return FPDF_GetFieldAttr(pParent, name, nLevel + 1);
+}
+
+CFX_WideString FPDF_GetFullName(CPDF_Dictionary* pFieldDict) {
+  CFX_WideString full_name;
+  CPDF_Dictionary* pLevel = pFieldDict;
+  while (pLevel) {
+    CFX_WideString short_name = pLevel->GetUnicodeTextBy("T");
+    if (short_name != L"") {
+      if (full_name == L"")
+        full_name = short_name;
+      else
+        full_name = short_name + L"." + full_name;
+    }
+    pLevel = pLevel->GetDictBy("Parent");
+  }
+  return full_name;
+}
+
 CPDF_FormField::CPDF_FormField(CPDF_InterForm* pForm, CPDF_Dictionary* pDict)
     : m_Type(Unknown),
       m_pForm(pForm),
       m_pDict(pDict),
       m_FontSize(0),
       m_pFont(nullptr) {
   SyncFieldFlags();
 }
 
 CPDF_FormField::~CPDF_FormField() {}
 
 void CPDF_FormField::SyncFieldFlags() {
   CFX_ByteString type_name = FPDF_GetFieldAttr(m_pDict, "FT")
                                  ? FPDF_GetFieldAttr(m_pDict, "FT")->GetString()
                                  : CFX_ByteString();
   uint32_t flags = FPDF_GetFieldAttr(m_pDict, "Ff")
                        ? FPDF_GetFieldAttr(m_pDict, "Ff")->GetInteger()
                        : 0;
   m_Flags = 0;
-  if (flags & 1) {
+  if (flags & 1)
     m_Flags |= kFormFieldReadOnly;
-  }
-  if (flags & 2) {
+  if (flags & 2)
     m_Flags |= kFormFieldRequired;
-  }
-  if (flags & 4) {
+  if (flags & 4)
     m_Flags |= kFormFieldNoExport;
-  }
+
   if (type_name == "Btn") {
     if (flags & 0x8000) {
       m_Type = RadioButton;
-      if (flags & 0x4000) {
+      if (flags & 0x4000)
         m_Flags |= kFormRadioNoToggleOff;
-      }
-      if (flags & 0x2000000) {
+      if (flags & 0x2000000)
         m_Flags |= kFormRadioUnison;
-      }
     } else if (flags & 0x10000) {
       m_Type = PushButton;
     } else {
       m_Type = CheckBox;
     }
   } else if (type_name == "Tx") {
     if (flags & 0x100000) {
       m_Type = File;
     } else if (flags & 0x2000000) {
       m_Type = RichText;
     } else {
       m_Type = Text;
-      if (flags & 0x1000) {
+      if (flags & 0x1000)
         m_Flags |= kFormTextMultiLine;
-      }
-      if (flags & 0x2000) {
+      if (flags & 0x2000)
         m_Flags |= kFormTextPassword;
-      }
-      if (flags & 0x800000) {
+      if (flags & 0x800000)
         m_Flags |= kFormTextNoScroll;
-      }
-      if (flags & 0x100000) {
+      if (flags & 0x100000)
         m_Flags |= kFormTextComb;
-      }
     }
     LoadDA();
   } else if (type_name == "Ch") {
     if (flags & 0x20000) {
       m_Type = ComboBox;
-      if (flags & 0x40000) {
+      if (flags & 0x40000)
         m_Flags |= kFormComboEdit;
-      }
     } else {
       m_Type = ListBox;
-      if (flags & 0x200000) {
+      if (flags & 0x200000)
         m_Flags |= kFormListMultiSelect;
-      }
     }
     LoadDA();
   } else if (type_name == "Sig") {
     m_Type = Sign;
   }
 }
+
 CFX_WideString CPDF_FormField::GetFullName() const {
-  return ::GetFullName(m_pDict);
+  return FPDF_GetFullName(m_pDict);
 }
 
 FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify) {
   switch (m_Type) {
     case CPDF_FormField::CheckBox:
     case CPDF_FormField::RadioButton: {
       int iCount = CountControls();
       if (iCount) {
         // TODO(weili): Check whether anything special needs to be done for
         // unison field. Otherwise, merge these branches.
-        if (PDF_FormField_IsUnison(this)) {
-          for (int i = 0; i < iCount; i++) {
+        if (IsUnison(this)) {
+          for (int i = 0; i < iCount; i++)
             CheckControl(i, GetControl(i)->IsDefaultChecked(), FALSE);
-          }
         } else {
-          for (int i = 0; i < iCount; i++) {
+          for (int i = 0; i < iCount; i++)
             CheckControl(i, GetControl(i)->IsDefaultChecked(), FALSE);
-          }
         }
       }
-      if (bNotify && m_pForm->m_pFormNotify) {
+      if (bNotify && m_pForm->m_pFormNotify)
         m_pForm->m_pFormNotify->AfterCheckedStatusChange(this);
-      }
-    } break;
+      break;
+    }
     case CPDF_FormField::ComboBox:
     case CPDF_FormField::ListBox: {
       CFX_WideString csValue;
       ClearSelection();
       int iIndex = GetDefaultSelectedItem();
       if (iIndex >= 0)
         csValue = GetOptionLabel(iIndex);
 
       if (bNotify && !NotifyListOrComboBoxBeforeChange(csValue))
         return FALSE;
 
       SetItemSelection(iIndex, TRUE);
       if (bNotify)
         NotifyListOrComboBoxAfterChange();
-    } break;
+      break;
+    }
     case CPDF_FormField::Text:
     case CPDF_FormField::RichText:
     case CPDF_FormField::File:
     default: {
       CPDF_Object* pDV = FPDF_GetFieldAttr(m_pDict, "DV");
       CFX_WideString csDValue;
       if (pDV)
         csDValue = pDV->GetUnicodeText();
 
       CPDF_Object* pV = FPDF_GetFieldAttr(m_pDict, "V");
@@ skipping 17 matching lines @@
         if (pRV) {
           CPDF_Object* pCloneR = pDV->Clone();
           m_pDict->SetAt("RV", pCloneR);
         }
       } else {
         m_pDict->RemoveAt("V");
         m_pDict->RemoveAt("RV");
       }
       if (bNotify)
         NotifyAfterValueChange();
-    } break;
+      break;
+    }
   }
   return TRUE;
 }
 
 int CPDF_FormField::GetControlIndex(const CPDF_FormControl* pControl) const {
   if (!pControl)
     return -1;
 
   for (int i = 0; i < m_ControlList.GetSize(); i++) {
     if (m_ControlList.GetAt(i) == pControl)
@@ skipping 26 matching lines @@
   return FIELDTYPE_UNKNOWN;
 }
 
 CPDF_AAction CPDF_FormField::GetAdditionalAction() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "AA");
   return CPDF_AAction(pObj ? pObj->GetDict() : nullptr);
 }
 
 CFX_WideString CPDF_FormField::GetAlternateName() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "TU");
-  if (!pObj) {
-    return L"";
-  }
-  return pObj->GetUnicodeText();
+  return pObj ? pObj->GetUnicodeText() : L"";
 }
+
 CFX_WideString CPDF_FormField::GetMappingName() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "TM");
-  if (!pObj) {
-    return L"";
-  }
-  return pObj->GetUnicodeText();
+  return pObj ? pObj->GetUnicodeText() : L"";
 }
+
 uint32_t CPDF_FormField::GetFieldFlags() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "Ff");
-  if (!pObj) {
-    return 0;
-  }
-  return pObj->GetInteger();
+  return pObj ? pObj->GetInteger() : 0;
 }
+
 CFX_ByteString CPDF_FormField::GetDefaultStyle() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "DS");
-  if (!pObj) {
-    return "";
-  }
-  return pObj->GetString();
+  return pObj ? pObj->GetString() : "";
 }
+
 CFX_WideString CPDF_FormField::GetRichTextString() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "RV");
-  if (!pObj) {
-    return L"";
-  }
-  return pObj->GetUnicodeText();
+  return pObj ? pObj->GetUnicodeText() : L"";
 }
+
 CFX_WideString CPDF_FormField::GetValue(FX_BOOL bDefault) const {
   if (GetType() == CheckBox || GetType() == RadioButton)
     return GetCheckValue(bDefault);
 
   CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, bDefault ? "DV" : "V");
   if (!pValue) {
     if (!bDefault) {
-      if (m_Type == RichText) {
+      if (m_Type == RichText)
         pValue = FPDF_GetFieldAttr(m_pDict, "V");
-      }
-      if (!pValue && m_Type != Text) {
+      if (!pValue && m_Type != Text)
         pValue = FPDF_GetFieldAttr(m_pDict, "DV");
-      }
     }
     if (!pValue)
       return CFX_WideString();
   }
+
   switch (pValue->GetType()) {
     case CPDF_Object::STRING:
     case CPDF_Object::STREAM:
       return pValue->GetUnicodeText();
     case CPDF_Object::ARRAY:
       pValue = pValue->AsArray()->GetDirectObjectAt(0);
       if (pValue)
         return pValue->GetUnicodeText();
       break;
     default:
@@ skipping 36 matching lines @@
         m_pDict->RemoveAt("I");
       } else {
         m_pDict->SetAtString(bDefault ? "DV" : "V", PDF_EncodeText(csValue));
         if (!bDefault) {
           ClearSelection();
           SetItemSelection(iIndex, TRUE);
         }
       }
       if (bNotify)
         NotifyAfterValueChange();
-    } break;
+      break;
+    }
     case ListBox: {
       int iIndex = FindOptionValue(value);
       if (iIndex < 0)
         return FALSE;
 
       if (bDefault && iIndex == GetDefaultSelectedItem())
         return FALSE;
 
       if (bNotify && !NotifyBeforeSelectionChange(value))
         return FALSE;
@@ skipping 67 matching lines @@
     if (!pArray || index < 0)
       return -1;
 
     CPDF_Object* elementValue = pArray->GetDirectObjectAt(index);
     sel_value =
         elementValue ? elementValue->GetUnicodeText() : CFX_WideString();
   }
   if (index < CountSelectedOptions()) {
     int iOptIndex = GetSelectedOptionIndex(index);
     CFX_WideString csOpt = GetOptionValue(iOptIndex);
-    if (csOpt == sel_value) {
+    if (csOpt == sel_value)
       return iOptIndex;
-    }
   }
   for (int i = 0; i < CountOptions(); i++) {
     if (sel_value == GetOptionValue(i))
       return i;
   }
   return -1;
 }
 
 FX_BOOL CPDF_FormField::ClearSelection(FX_BOOL bNotify) {
   if (bNotify && m_pForm->m_pFormNotify) {
     CFX_WideString csValue;
     int iIndex = GetSelectedIndex(0);
     if (iIndex >= 0)
       csValue = GetOptionLabel(iIndex);
 
     if (!NotifyListOrComboBoxBeforeChange(csValue))
       return FALSE;
   }
   m_pDict->RemoveAt("V");
   m_pDict->RemoveAt("I");
   if (bNotify)
     NotifyListOrComboBoxAfterChange();
   return TRUE;
 }
 
 FX_BOOL CPDF_FormField::IsItemSelected(int index) const {
   ASSERT(GetType() == ComboBox || GetType() == ListBox);
-  if (index < 0 || index >= CountOptions()) {
+  if (index < 0 || index >= CountOptions())
     return FALSE;
-  }
-  if (IsOptionSelected(index)) {
+  if (IsOptionSelected(index))
     return TRUE;
-  }
+
   CFX_WideString opt_value = GetOptionValue(index);
   CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "V");
   if (!pValue) {
     pValue = FPDF_GetFieldAttr(m_pDict, "I");
-    if (!pValue) {
+    if (!pValue)
       return FALSE;
-    }
   }
 
   if (pValue->IsString())
     return pValue->GetUnicodeText() == opt_value;
 
   if (pValue->IsNumber()) {
     if (pValue->GetString().IsEmpty())
       return FALSE;
     return (pValue->GetInteger() == index);
   }
@@ skipping 116 matching lines @@
 
   CPDF_Object* pOption = pArray->GetDirectObjectAt(index);
   if (!pOption)
     return CFX_WideString();
   if (CPDF_Array* pOptionArray = pOption->AsArray())
     pOption = pOptionArray->GetDirectObjectAt(sub_index);
 
   CPDF_String* pString = ToString(pOption);
   return pString ? pString->GetUnicodeText() : CFX_WideString();
 }
+
 CFX_WideString CPDF_FormField::GetOptionLabel(int index) const {
   return GetOptionText(index, 1);
 }
+
 CFX_WideString CPDF_FormField::GetOptionValue(int index) const {
   return GetOptionText(index, 0);
 }
 
 int CPDF_FormField::FindOption(CFX_WideString csOptLabel) const {
   for (int i = 0; i < CountOptions(); i++) {
     if (GetOptionValue(i) == csOptLabel)
       return i;
   }
   return -1;
@@ skipping 61 matching lines @@
 
   return TRUE;
 }
 #endif  // PDF_ENABLE_XFA
 
 FX_BOOL CPDF_FormField::CheckControl(int iControlIndex,
                                      bool bChecked,
                                      bool bNotify) {
   ASSERT(GetType() == CheckBox || GetType() == RadioButton);
   CPDF_FormControl* pControl = GetControl(iControlIndex);
-  if (!pControl) {
+  if (!pControl)
     return FALSE;
-  }
-  if (!bChecked && pControl->IsChecked() == bChecked) {
+  if (!bChecked && pControl->IsChecked() == bChecked)
     return FALSE;
-  }
+
   CFX_WideString csWExport = pControl->GetExportValue();
   CFX_ByteString csBExport = PDF_EncodeText(csWExport);
   int iCount = CountControls();
-  bool bUnison = PDF_FormField_IsUnison(this);
+  bool bUnison = IsUnison(this);
   for (int i = 0; i < iCount; i++) {
     CPDF_FormControl* pCtrl = GetControl(i);
     if (bUnison) {
       CFX_WideString csEValue = pCtrl->GetExportValue();
       if (csEValue == csWExport) {
-        if (pCtrl->GetOnStateName() == pControl->GetOnStateName()) {
+        if (pCtrl->GetOnStateName() == pControl->GetOnStateName())
           pCtrl->CheckControl(bChecked);
-        } else if (bChecked) {
+        else if (bChecked)
           pCtrl->CheckControl(FALSE);
-        }
       } else if (bChecked) {
         pCtrl->CheckControl(FALSE);
       }
     } else {
-      if (i == iControlIndex) {
+      if (i == iControlIndex)
         pCtrl->CheckControl(bChecked);
-      } else if (bChecked) {
+      else if (bChecked)
         pCtrl->CheckControl(FALSE);
-      }
     }
   }
+
   CPDF_Object* pOpt = FPDF_GetFieldAttr(m_pDict, "Opt");
   if (!ToArray(pOpt)) {
     if (bChecked) {
       m_pDict->SetAtName("V", csBExport);
     } else {
       CFX_ByteString csV;
       CPDF_Object* pV = FPDF_GetFieldAttr(m_pDict, "V");
-      if (pV) {
+      if (pV)
         csV = pV->GetString();
-      }
-      if (csV == csBExport) {
+      if (csV == csBExport)
         m_pDict->SetAtName("V", "Off");
-      }
     }
   } else if (bChecked) {
     CFX_ByteString csIndex;
     csIndex.Format("%d", iControlIndex);
     m_pDict->SetAtName("V", csIndex);
   }
   if (bNotify && m_pForm->m_pFormNotify)
     m_pForm->m_pFormNotify->AfterCheckedStatusChange(this);
   return TRUE;
 }
@@ skipping 214 matching lines @@
     case ListBox:
       NotifyAfterSelectionChange();
       break;
     case ComboBox:
       NotifyAfterValueChange();
       break;
     default:
       break;
   }
 }