Remove FX_BOOL from core

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/cpdf_formfield.h"
 
 #include <set>
 
@@ skipping 143 matching lines @@
     LoadDA();
   } else if (type_name == "Sig") {
     m_Type = Sign;
   }
 }
 
 CFX_WideString CPDF_FormField::GetFullName() const {
   return FPDF_GetFullName(m_pDict);
 }
 
-FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify) {
+bool CPDF_FormField::ResetField(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 (IsUnison(this)) {
           for (int i = 0; i < iCount; i++)
-            CheckControl(i, GetControl(i)->IsDefaultChecked(), FALSE);
+            CheckControl(i, GetControl(i)->IsDefaultChecked(), false);
         } else {
           for (int i = 0; i < iCount; i++)
-            CheckControl(i, GetControl(i)->IsDefaultChecked(), FALSE);
+            CheckControl(i, GetControl(i)->IsDefaultChecked(), false);
         }
       }
       if (bNotify && m_pForm->m_pFormNotify)
         m_pForm->m_pFormNotify->AfterCheckedStatusChange(this);
       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;
+        return false;
 
-      SetItemSelection(iIndex, TRUE);
+      SetItemSelection(iIndex, true);
       if (bNotify)
         NotifyListOrComboBoxAfterChange();
       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");
       CFX_WideString csValue;
       if (pV)
         csValue = pV->GetUnicodeText();
 
       CPDF_Object* pRV = FPDF_GetFieldAttr(m_pDict, "RV");
       if (!pRV && (csDValue == csValue))
-        return FALSE;
+        return false;
 
       if (bNotify && !NotifyBeforeValueChange(csDValue))
-        return FALSE;
+        return false;
 
       if (pDV) {
         CPDF_Object* pClone = pDV->Clone();
         if (!pClone)
-          return FALSE;
+          return false;
 
         m_pDict->SetFor("V", pClone);
         if (pRV) {
           CPDF_Object* pCloneR = pDV->Clone();
           m_pDict->SetFor("RV", pCloneR);
         }
       } else {
         m_pDict->RemoveFor("V");
         m_pDict->RemoveFor("RV");
       }
       if (bNotify)
         NotifyAfterValueChange();
       break;
     }
   }
-  return TRUE;
+  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)
       return i;
   }
@@ skipping 47 matching lines @@
 CFX_ByteString CPDF_FormField::GetDefaultStyle() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "DS");
   return pObj ? pObj->GetString() : "";
 }
 
 CFX_WideString CPDF_FormField::GetRichTextString() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "RV");
   return pObj ? pObj->GetUnicodeText() : L"";
 }
 
-CFX_WideString CPDF_FormField::GetValue(FX_BOOL bDefault) const {
+CFX_WideString CPDF_FormField::GetValue(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)
         pValue = FPDF_GetFieldAttr(m_pDict, "V");
       if (!pValue && m_Type != Text)
         pValue = FPDF_GetFieldAttr(m_pDict, "DV");
@@ skipping 11 matching lines @@
       if (pValue)
         return pValue->GetUnicodeText();
       break;
     default:
       break;
   }
   return CFX_WideString();
 }
 
 CFX_WideString CPDF_FormField::GetValue() const {
-  return GetValue(FALSE);
+  return GetValue(false);
 }
 
 CFX_WideString CPDF_FormField::GetDefaultValue() const {
-  return GetValue(TRUE);
+  return GetValue(true);
 }
 
-FX_BOOL CPDF_FormField::SetValue(const CFX_WideString& value,
-                                 FX_BOOL bDefault,
-                                 FX_BOOL bNotify) {
+bool CPDF_FormField::SetValue(const CFX_WideString& value,
+                              bool bDefault,
+                              bool bNotify) {
   switch (m_Type) {
     case CheckBox:
     case RadioButton: {
       SetCheckValue(value, bDefault, bNotify);
-      return TRUE;
+      return true;
     }
     case File:
     case RichText:
     case Text:
     case ComboBox: {
       CFX_WideString csValue = value;
       if (bNotify && !NotifyBeforeValueChange(csValue))
-        return FALSE;
+        return false;
 
       int iIndex = FindOptionValue(csValue);
       if (iIndex < 0) {
         CFX_ByteString bsEncodeText = PDF_EncodeText(csValue);
         m_pDict->SetStringFor(bDefault ? "DV" : "V", bsEncodeText);
         if (m_Type == RichText && !bDefault)
           m_pDict->SetStringFor("RV", bsEncodeText);
         m_pDict->RemoveFor("I");
       } else {
         m_pDict->SetStringFor(bDefault ? "DV" : "V", PDF_EncodeText(csValue));
         if (!bDefault) {
           ClearSelection();
-          SetItemSelection(iIndex, TRUE);
+          SetItemSelection(iIndex, true);
         }
       }
       if (bNotify)
         NotifyAfterValueChange();
       break;
     }
     case ListBox: {
       int iIndex = FindOptionValue(value);
       if (iIndex < 0)
-        return FALSE;
+        return false;
 
       if (bDefault && iIndex == GetDefaultSelectedItem())
-        return FALSE;
+        return false;
 
       if (bNotify && !NotifyBeforeSelectionChange(value))
-        return FALSE;
+        return false;
 
       if (!bDefault) {
         ClearSelection();
-        SetItemSelection(iIndex, TRUE);
+        SetItemSelection(iIndex, true);
       }
       if (bNotify)
         NotifyAfterSelectionChange();
       break;
     }
     default:
       break;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_FormField::SetValue(const CFX_WideString& value, FX_BOOL bNotify) {
-  return SetValue(value, FALSE, bNotify);
+bool CPDF_FormField::SetValue(const CFX_WideString& value, bool bNotify) {
+  return SetValue(value, false, bNotify);
 }
 
 int CPDF_FormField::GetMaxLen() const {
   if (CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "MaxLen"))
     return pObj->GetInteger();
 
   for (int i = 0; i < m_ControlList.GetSize(); i++) {
     CPDF_FormControl* pControl = m_ControlList.GetAt(i);
     if (!pControl)
       continue;
@@ skipping 50 matching lines @@
     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) {
+bool CPDF_FormField::ClearSelection(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;
+      return false;
   }
   m_pDict->RemoveFor("V");
   m_pDict->RemoveFor("I");
   if (bNotify)
     NotifyListOrComboBoxAfterChange();
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_FormField::IsItemSelected(int index) const {
+bool CPDF_FormField::IsItemSelected(int index) const {
   ASSERT(GetType() == ComboBox || GetType() == ListBox);
   if (index < 0 || index >= CountOptions())
-    return FALSE;
+    return false;
   if (IsOptionSelected(index))
-    return TRUE;
+    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)
-      return FALSE;
+      return false;
   }
 
   if (pValue->IsString())
     return pValue->GetUnicodeText() == opt_value;
 
   if (pValue->IsNumber()) {
     if (pValue->GetString().IsEmpty())
-      return FALSE;
+      return false;
     return (pValue->GetInteger() == index);
   }
 
   CPDF_Array* pArray = pValue->AsArray();
   if (!pArray)
-    return FALSE;
+    return false;
 
   int iPos = -1;
   for (int j = 0; j < CountSelectedOptions(); j++) {
     if (GetSelectedOptionIndex(j) == index) {
       iPos = j;
       break;
     }
   }
   for (int i = 0; i < static_cast<int>(pArray->GetCount()); i++)
     if (pArray->GetDirectObjectAt(i)->GetUnicodeText() == opt_value &&
         i == iPos) {
-      return TRUE;
+      return true;
     }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_FormField::SetItemSelection(int index,
-                                         FX_BOOL bSelected,
-                                         FX_BOOL bNotify) {
+bool CPDF_FormField::SetItemSelection(int index, bool bSelected, bool bNotify) {
   ASSERT(GetType() == ComboBox || GetType() == ListBox);
   if (index < 0 || index >= CountOptions())
-    return FALSE;
+    return false;
 
   CFX_WideString opt_value = GetOptionValue(index);
   if (bNotify && !NotifyListOrComboBoxBeforeChange(opt_value))
-    return FALSE;
+    return false;
 
   if (bSelected) {
     if (GetType() == ListBox) {
-      SelectOption(index, TRUE);
+      SelectOption(index, true);
       if (!(m_Flags & kFormListMultiSelect)) {
         m_pDict->SetStringFor("V", PDF_EncodeText(opt_value));
       } else {
         CPDF_Array* pArray = new CPDF_Array;
         for (int i = 0; i < CountOptions(); i++) {
           if (i == index || IsItemSelected(i)) {
             opt_value = GetOptionValue(i);
             pArray->AddString(PDF_EncodeText(opt_value));
           }
         }
         m_pDict->SetFor("V", pArray);
       }
     } else {
       m_pDict->SetStringFor("V", PDF_EncodeText(opt_value));
       CPDF_Array* pI = new CPDF_Array;
       pI->AddInteger(index);
       m_pDict->SetFor("I", pI);
     }
   } else {
     CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "V");
     if (pValue) {
       if (GetType() == ListBox) {
-        SelectOption(index, FALSE);
+        SelectOption(index, false);
         if (pValue->IsString()) {
           if (pValue->GetUnicodeText() == opt_value)
             m_pDict->RemoveFor("V");
         } else if (pValue->IsArray()) {
           std::unique_ptr<CPDF_Array, ReleaseDeleter<CPDF_Array>> pArray(
               new CPDF_Array);
           for (int i = 0; i < CountOptions(); i++) {
             if (i != index && IsItemSelected(i)) {
               opt_value = GetOptionValue(i);
               pArray->AddString(PDF_EncodeText(opt_value));
             }
           }
           if (pArray->GetCount() > 0)
             m_pDict->SetFor("V", pArray.release());  // std::move someday
         }
       } else {
         m_pDict->RemoveFor("V");
         m_pDict->RemoveFor("I");
       }
     }
   }
   if (bNotify)
     NotifyListOrComboBoxAfterChange();
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_FormField::IsItemDefaultSelected(int index) const {
+bool CPDF_FormField::IsItemDefaultSelected(int index) const {
   ASSERT(GetType() == ComboBox || GetType() == ListBox);
   if (index < 0 || index >= CountOptions())
-    return FALSE;
+    return false;
   int iDVIndex = GetDefaultSelectedItem();
   return iDVIndex >= 0 && iDVIndex == index;
 }
 
 int CPDF_FormField::GetDefaultSelectedItem() const {
   ASSERT(GetType() == ComboBox || GetType() == ListBox);
   CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "DV");
   if (!pValue)
     return -1;
   CFX_WideString csDV = pValue->GetUnicodeText();
@@ skipping 46 matching lines @@
   for (int i = 0; i < CountOptions(); i++) {
     if (GetOptionValue(i) == csOptValue)
       return i;
   }
   return -1;
 }
 
 #ifdef PDF_ENABLE_XFA
 int CPDF_FormField::InsertOption(CFX_WideString csOptLabel,
                                  int index,
-                                 FX_BOOL bNotify) {
+                                 bool bNotify) {
   if (csOptLabel.IsEmpty())
     return -1;
 
   if (bNotify && !NotifyListOrComboBoxBeforeChange(csOptLabel))
     return -1;
 
   CFX_ByteString csStr =
       PDF_EncodeText(csOptLabel.c_str(), csOptLabel.GetLength());
   CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "Opt");
   CPDF_Array* pOpt = ToArray(pValue);
   if (!pOpt) {
     pOpt = new CPDF_Array;
     m_pDict->SetFor("Opt", pOpt);
   }
 
   int iCount = pdfium::base::checked_cast<int, size_t>(pOpt->GetCount());
   if (index >= iCount) {
     pOpt->AddString(csStr);
     index = iCount;
   } else {
-    CPDF_String* pString = new CPDF_String(csStr, FALSE);
+    CPDF_String* pString = new CPDF_String(csStr, false);
     pOpt->InsertAt(index, pString);
   }
 
   if (bNotify)
     NotifyListOrComboBoxAfterChange();
   return index;
 }
 
-FX_BOOL CPDF_FormField::ClearOptions(FX_BOOL bNotify) {
+bool CPDF_FormField::ClearOptions(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;
+      return false;
   }
 
   m_pDict->RemoveFor("Opt");
   m_pDict->RemoveFor("V");
   m_pDict->RemoveFor("DV");
   m_pDict->RemoveFor("I");
   m_pDict->RemoveFor("TI");
 
   if (bNotify)
     NotifyListOrComboBoxAfterChange();
 
-  return TRUE;
+  return true;
 }
 #endif  // PDF_ENABLE_XFA
 
-FX_BOOL CPDF_FormField::CheckControl(int iControlIndex,
-                                     bool bChecked,
-                                     bool bNotify) {
+bool CPDF_FormField::CheckControl(int iControlIndex,
+                                  bool bChecked,
+                                  bool bNotify) {
   ASSERT(GetType() == CheckBox || GetType() == RadioButton);
   CPDF_FormControl* pControl = GetControl(iControlIndex);
   if (!pControl)
-    return FALSE;
+    return false;
   if (!bChecked && pControl->IsChecked() == bChecked)
-    return FALSE;
+    return false;
 
   CFX_WideString csWExport = pControl->GetExportValue();
   CFX_ByteString csBExport = PDF_EncodeText(csWExport);
   int iCount = CountControls();
   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())
           pCtrl->CheckControl(bChecked);
         else if (bChecked)
-          pCtrl->CheckControl(FALSE);
+          pCtrl->CheckControl(false);
       } else if (bChecked) {
-        pCtrl->CheckControl(FALSE);
+        pCtrl->CheckControl(false);
       }
     } else {
       if (i == iControlIndex)
         pCtrl->CheckControl(bChecked);
       else if (bChecked)
-        pCtrl->CheckControl(FALSE);
+        pCtrl->CheckControl(false);
     }
   }
 
   CPDF_Object* pOpt = FPDF_GetFieldAttr(m_pDict, "Opt");
   if (!ToArray(pOpt)) {
     if (bChecked) {
       m_pDict->SetNameFor("V", csBExport);
     } else {
       CFX_ByteString csV;
       CPDF_Object* pV = FPDF_GetFieldAttr(m_pDict, "V");
       if (pV)
         csV = pV->GetString();
       if (csV == csBExport)
         m_pDict->SetNameFor("V", "Off");
     }
   } else if (bChecked) {
     CFX_ByteString csIndex;
     csIndex.Format("%d", iControlIndex);
     m_pDict->SetNameFor("V", csIndex);
   }
   if (bNotify && m_pForm->m_pFormNotify)
     m_pForm->m_pFormNotify->AfterCheckedStatusChange(this);
-  return TRUE;
+  return true;
 }
 
-CFX_WideString CPDF_FormField::GetCheckValue(FX_BOOL bDefault) const {
+CFX_WideString CPDF_FormField::GetCheckValue(bool bDefault) const {
   ASSERT(GetType() == CheckBox || GetType() == RadioButton);
   CFX_WideString csExport = L"Off";
   int iCount = CountControls();
   for (int i = 0; i < iCount; i++) {
     CPDF_FormControl* pControl = GetControl(i);
-    FX_BOOL bChecked =
+    bool bChecked =
         bDefault ? pControl->IsDefaultChecked() : pControl->IsChecked();
     if (bChecked) {
       csExport = pControl->GetExportValue();
       break;
     }
   }
   return csExport;
 }
 
-FX_BOOL CPDF_FormField::SetCheckValue(const CFX_WideString& value,
-                                      FX_BOOL bDefault,
-                                      FX_BOOL bNotify) {
+bool CPDF_FormField::SetCheckValue(const CFX_WideString& value,
+                                   bool bDefault,
+                                   bool bNotify) {
   ASSERT(GetType() == CheckBox || GetType() == RadioButton);
   int iCount = CountControls();
   for (int i = 0; i < iCount; i++) {
     CPDF_FormControl* pControl = GetControl(i);
     CFX_WideString csExport = pControl->GetExportValue();
     bool val = csExport == value;
     if (!bDefault)
       CheckControl(GetControlIndex(pControl), val);
     if (val)
       break;
   }
   if (bNotify && m_pForm->m_pFormNotify)
     m_pForm->m_pFormNotify->AfterCheckedStatusChange(this);
-  return TRUE;
+  return true;
 }
 
 int CPDF_FormField::GetTopVisibleIndex() const {
   CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "TI");
   return pObj ? pObj->GetInteger() : 0;
 }
 
 int CPDF_FormField::CountSelectedOptions() const {
   CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "I"));
   return pArray ? pArray->GetCount() : 0;
 }
 
 int CPDF_FormField::GetSelectedOptionIndex(int index) const {
   CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "I"));
   if (!pArray)
     return -1;
 
   int iCount = pArray->GetCount();
   if (iCount < 0 || index >= iCount)
     return -1;
   return pArray->GetIntegerAt(index);
 }
 
-FX_BOOL CPDF_FormField::IsOptionSelected(int iOptIndex) const {
+bool CPDF_FormField::IsOptionSelected(int iOptIndex) const {
   CPDF_Array* pArray = ToArray(FPDF_GetFieldAttr(m_pDict, "I"));
   if (!pArray)
-    return FALSE;
+    return false;
 
   for (CPDF_Object* pObj : *pArray) {
     if (pObj->GetInteger() == iOptIndex)
-      return TRUE;
+      return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_FormField::SelectOption(int iOptIndex,
-                                     FX_BOOL bSelected,
-                                     FX_BOOL bNotify) {
+bool CPDF_FormField::SelectOption(int iOptIndex, bool bSelected, bool bNotify) {
   CPDF_Array* pArray = m_pDict->GetArrayFor("I");
   if (!pArray) {
     if (!bSelected)
-      return TRUE;
+      return true;
 
     pArray = new CPDF_Array;
     m_pDict->SetFor("I", pArray);
   }
 
-  FX_BOOL bReturn = FALSE;
+  bool bReturn = false;
   for (size_t i = 0; i < pArray->GetCount(); i++) {
     int iFind = pArray->GetIntegerAt(i);
     if (iFind == iOptIndex) {
       if (bSelected)
-        return TRUE;
+        return true;
 
       if (bNotify && m_pForm->m_pFormNotify) {
         CFX_WideString csValue = GetOptionLabel(iOptIndex);
         if (!NotifyListOrComboBoxBeforeChange(csValue))
-          return FALSE;
+          return false;
       }
       pArray->RemoveAt(i);
-      bReturn = TRUE;
+      bReturn = true;
       break;
     }
 
     if (iFind > iOptIndex) {
       if (!bSelected)
         continue;
 
       if (bNotify && m_pForm->m_pFormNotify) {
         CFX_WideString csValue = GetOptionLabel(iOptIndex);
         if (!NotifyListOrComboBoxBeforeChange(csValue))
-          return FALSE;
+          return false;
       }
       pArray->InsertAt(i, new CPDF_Number(iOptIndex));
-      bReturn = TRUE;
+      bReturn = true;
       break;
     }
   }
   if (!bReturn) {
     if (bSelected)
       pArray->AddInteger(iOptIndex);
 
     if (pArray->IsEmpty())
       m_pDict->RemoveFor("I");
   }
   if (bNotify)
     NotifyListOrComboBoxAfterChange();
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_FormField::ClearSelectedOptions(FX_BOOL bNotify) {
+bool CPDF_FormField::ClearSelectedOptions(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;
+      return false;
   }
   m_pDict->RemoveFor("I");
   if (bNotify)
     NotifyListOrComboBoxAfterChange();
 
-  return TRUE;
+  return true;
 }
 
 void CPDF_FormField::LoadDA() {
   CPDF_Dictionary* pFormDict = m_pForm->m_pFormDict;
   if (!pFormDict)
     return;
 
   CFX_ByteString DA;
   if (CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "DA"))
     DA = pObj->GetString();
@@ skipping 64 matching lines @@
     case ListBox:
       NotifyAfterSelectionChange();
       break;
     case ComboBox:
       NotifyAfterValueChange();
       break;
     default:
       break;
   }
 }