diff --git a/xfa/fwl/cfwl_checkbox.cpp b/xfa/fwl/cfwl_checkbox.cpp
index ee8c71b..09cf136 100644
--- a/xfa/fwl/cfwl_checkbox.cpp
+++ b/xfa/fwl/cfwl_checkbox.cpp
@@ -75,14 +75,14 @@
   param.m_dwStates = dwStates;
   param.m_pGraphics = pGraphics;
   param.m_matrix.Concat(matrix);
-  param.m_PartRect = m_rtClient;
+  param.m_PartRect = m_ClientRect;
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused)
 
-    param.m_pRtData = &m_rtFocus;
+    param.m_pRtData = &m_FocusRect;
   pTheme->DrawBackground(param);
 
   param.m_iPart = CFWL_Part::CheckBox;
-  param.m_PartRect = m_rtBox;
+  param.m_PartRect = m_BoxRect;
   pTheme->DrawBackground(param);
 
   CFWL_ThemeText textParam;
@@ -91,7 +91,7 @@
   textParam.m_dwStates = dwStates;
   textParam.m_pGraphics = pGraphics;
   textParam.m_matrix.Concat(matrix);
-  textParam.m_PartRect = m_rtCaption;
+  textParam.m_PartRect = m_CaptionRect;
   textParam.m_wsText = L"Check box";
   textParam.m_dwTTOStyles = m_TTOStyles;
   textParam.m_iTTOAlign = m_iTTOAlign;
@@ -111,30 +111,31 @@
     default:
       break;
   }
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_CheckBox::Layout() {
-  m_pProperties->m_rtWidget.width =
-      FXSYS_roundf(m_pProperties->m_rtWidget.width);
-  m_pProperties->m_rtWidget.height =
-      FXSYS_roundf(m_pProperties->m_rtWidget.height);
-  m_rtClient = GetClientRect();
+  m_pProperties->m_WidgetRect.width =
+      FXSYS_roundf(m_pProperties->m_WidgetRect.width);
+  m_pProperties->m_WidgetRect.height =
+      FXSYS_roundf(m_pProperties->m_WidgetRect.height);
+  m_ClientRect = GetClientRect();
 
-  float fTextLeft = m_rtClient.left + m_fBoxHeight;
-  m_rtBox = CFX_RectF(m_rtClient.TopLeft(), m_fBoxHeight, m_fBoxHeight);
-  m_rtCaption = CFX_RectF(fTextLeft, m_rtClient.top,
-                          m_rtClient.right() - fTextLeft, m_rtClient.height);
-  m_rtCaption.Inflate(-kCaptionMargin, -kCaptionMargin);
+  float fTextLeft = m_ClientRect.left + m_fBoxHeight;
+  m_BoxRect = CFX_RectF(m_ClientRect.TopLeft(), m_fBoxHeight, m_fBoxHeight);
+  m_CaptionRect =
+      CFX_RectF(fTextLeft, m_ClientRect.top, m_ClientRect.right() - fTextLeft,
+                m_ClientRect.height);
+  m_CaptionRect.Inflate(-kCaptionMargin, -kCaptionMargin);
 
-  CFX_RectF rtFocus = m_rtCaption;
+  CFX_RectF rtFocus = m_CaptionRect;
   CalcTextRect(L"Check box", m_pProperties->m_pThemeProvider.Get(), m_TTOStyles,
                m_iTTOAlign, &rtFocus);
 
-  m_rtFocus = CFX_RectF(m_rtCaption.TopLeft(),
-                        std::max(m_rtCaption.width, rtFocus.width),
-                        std::min(m_rtCaption.height, rtFocus.height));
-  m_rtFocus.Inflate(1, 1);
+  m_FocusRect = CFX_RectF(m_CaptionRect.TopLeft(),
+                          std::max(m_CaptionRect.width, rtFocus.width),
+                          std::min(m_CaptionRect.height, rtFocus.height));
+  m_FocusRect.Inflate(1, 1);
 }
 
 uint32_t CFWL_CheckBox::GetPartStates() const {
@@ -189,7 +190,7 @@
     }
   }
 
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
   if (dwFirststate == m_pProperties->m_dwStates)
     return;
 
@@ -253,7 +254,7 @@
   else
     m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
 
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_CheckBox::OnLButtonDown() {
@@ -263,7 +264,7 @@
   m_bBtnDown = true;
   m_pProperties->m_dwStates &= ~FWL_STATE_CKB_Hovered;
   m_pProperties->m_dwStates |= FWL_STATE_CKB_Pressed;
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_CheckBox::OnLButtonUp(CFWL_MessageMouse* pMsg) {
@@ -271,7 +272,7 @@
     return;
 
   m_bBtnDown = false;
-  if (!m_rtClient.Contains(pMsg->m_pos))
+  if (!m_ClientRect.Contains(pMsg->m_pos))
     return;
 
   m_pProperties->m_dwStates |= FWL_STATE_CKB_Hovered;
@@ -285,7 +286,7 @@
 
   bool bRepaint = false;
   if (m_bBtnDown) {
-    if (m_rtClient.Contains(pMsg->m_pos)) {
+    if (m_ClientRect.Contains(pMsg->m_pos)) {
       if ((m_pProperties->m_dwStates & FWL_STATE_CKB_Pressed) == 0) {
         bRepaint = true;
         m_pProperties->m_dwStates |= FWL_STATE_CKB_Pressed;
@@ -305,7 +306,7 @@
       }
     }
   } else {
-    if (m_rtClient.Contains(pMsg->m_pos)) {
+    if (m_ClientRect.Contains(pMsg->m_pos)) {
       if ((m_pProperties->m_dwStates & FWL_STATE_CKB_Hovered) == 0) {
         bRepaint = true;
         m_pProperties->m_dwStates |= FWL_STATE_CKB_Hovered;
@@ -313,7 +314,7 @@
     }
   }
   if (bRepaint)
-    RepaintRect(m_rtBox);
+    RepaintRect(m_BoxRect);
 }
 
 void CFWL_CheckBox::OnMouseLeave() {
@@ -322,7 +323,7 @@
   else
     m_pProperties->m_dwStates &= ~FWL_STATE_CKB_Hovered;
 
-  RepaintRect(m_rtBox);
+  RepaintRect(m_BoxRect);
 }
 
 void CFWL_CheckBox::OnKeyDown(CFWL_MessageKey* pMsg) {
diff --git a/xfa/fwl/cfwl_checkbox.h b/xfa/fwl/cfwl_checkbox.h
index 0fa0236..04ae7ef 100644
--- a/xfa/fwl/cfwl_checkbox.h
+++ b/xfa/fwl/cfwl_checkbox.h
@@ -60,10 +60,10 @@
   void OnMouseLeave();
   void OnKeyDown(CFWL_MessageKey* pMsg);
 
-  CFX_RectF m_rtClient;
-  CFX_RectF m_rtBox;
-  CFX_RectF m_rtCaption;
-  CFX_RectF m_rtFocus;
+  CFX_RectF m_ClientRect;
+  CFX_RectF m_BoxRect;
+  CFX_RectF m_CaptionRect;
+  CFX_RectF m_FocusRect;
   FDE_TextStyle m_TTOStyles;
   FDE_TextAlignment m_iTTOAlign = FDE_TextAlignment::kCenter;
   bool m_bBtnDown = false;
diff --git a/xfa/fwl/cfwl_combobox.cpp b/xfa/fwl/cfwl_combobox.cpp
index 0886ebe..34bdf08 100644
--- a/xfa/fwl/cfwl_combobox.cpp
+++ b/xfa/fwl/cfwl_combobox.cpp
@@ -81,11 +81,11 @@
 }
 
 FWL_WidgetHit CFWL_ComboBox::HitTest(const CFX_PointF& point) {
-  CFX_RectF rect(0, 0, m_pProperties->m_rtWidget.width - m_rtBtn.width,
-                 m_pProperties->m_rtWidget.height);
+  CFX_RectF rect(0, 0, m_pProperties->m_WidgetRect.width - m_BtnRect.width,
+                 m_pProperties->m_WidgetRect.height);
   if (rect.Contains(point))
     return FWL_WidgetHit::Edit;
-  if (m_rtBtn.Contains(point))
+  if (m_BtnRect.Contains(point))
     return FWL_WidgetHit::Client;
   if (IsDropListVisible()) {
     rect = m_pListBox->GetWidgetRect();
@@ -100,13 +100,13 @@
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider.Get();
   pGraphics->SaveGraphState();
   pGraphics->ConcatMatrix(&matrix);
-  if (!m_rtBtn.IsEmpty(0.1f)) {
+  if (!m_BtnRect.IsEmpty(0.1f)) {
     CFWL_ThemeBackground param;
     param.m_pWidget = this;
     param.m_iPart = CFWL_Part::DropDownButton;
     param.m_dwStates = m_iBtnState;
     param.m_pGraphics = pGraphics;
-    param.m_PartRect = m_rtBtn;
+    param.m_PartRect = m_BtnRect;
     pTheme->DrawBackground(param);
   }
   pGraphics->RestoreGraphState();
@@ -196,7 +196,7 @@
 }
 
 CFX_RectF CFWL_ComboBox::GetBBox() const {
-  CFX_RectF rect = m_pProperties->m_rtWidget;
+  CFX_RectF rect = m_pProperties->m_WidgetRect;
   if (!m_pListBox || !IsDropListVisible())
     return rect;
 
@@ -237,8 +237,9 @@
       fPopupMin = fItemHeight * 3 + fBorder * 2;
 
     float fPopupMax = fItemHeight * iItems + fBorder * 2;
-    CFX_RectF rtList(m_rtClient.left, 0, m_pProperties->m_rtWidget.width, 0);
-    GetPopupPos(fPopupMin, fPopupMax, m_pProperties->m_rtWidget, &rtList);
+    CFX_RectF rtList(m_ClientRect.left, 0, m_pProperties->m_WidgetRect.width,
+                     0);
+    GetPopupPos(fPopupMin, fPopupMax, m_pProperties->m_WidgetRect, &rtList);
 
     m_pListBox->SetWidgetRect(rtList);
     m_pListBox->Update();
@@ -278,8 +279,8 @@
 }
 
 void CFWL_ComboBox::Layout() {
-  m_rtClient = GetClientRect();
-  m_rtContent = m_rtClient;
+  m_ClientRect = GetClientRect();
+  m_ContentRect = m_ClientRect;
   IFWL_ThemeProvider* theme = GetAvailableTheme();
   if (!theme)
     return;
@@ -287,22 +288,22 @@
   float borderWidth = 1;
   float fBtn = theme->GetScrollBarWidth();
   if (!(GetStylesEx() & FWL_STYLEEXT_CMB_ReadOnly)) {
-    m_rtBtn =
-        CFX_RectF(m_rtClient.right() - fBtn, m_rtClient.top + borderWidth,
-                  fBtn - borderWidth, m_rtClient.height - 2 * borderWidth);
+    m_BtnRect =
+        CFX_RectF(m_ClientRect.right() - fBtn, m_ClientRect.top + borderWidth,
+                  fBtn - borderWidth, m_ClientRect.height - 2 * borderWidth);
   }
 
   CFWL_ThemePart part;
   part.m_pWidget = this;
   CFX_RectF pUIMargin = theme->GetUIMargin(part);
-  m_rtContent.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
-                      pUIMargin.height);
+  m_ContentRect.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
+                        pUIMargin.height);
 
   if (!IsDropDownStyle() || !m_pEdit)
     return;
 
-  CFX_RectF rtEdit(m_rtContent.left, m_rtContent.top, m_rtContent.width - fBtn,
-                   m_rtContent.height);
+  CFX_RectF rtEdit(m_ContentRect.left, m_ContentRect.top,
+                   m_ContentRect.width - fBtn, m_ContentRect.height);
   m_pEdit->SetWidgetRect(rtEdit);
 
   if (m_iCurSel >= 0) {
@@ -382,7 +383,7 @@
 void CFWL_ComboBox::ProcessSelChanged(bool bLButtonUp) {
   m_iCurSel = m_pListBox->GetItemIndex(this, m_pListBox->GetSelItem(0));
   if (!IsDropDownStyle()) {
-    RepaintRect(m_rtClient);
+    RepaintRect(m_ClientRect);
     return;
   }
 
@@ -503,17 +504,17 @@
 }
 
 void CFWL_ComboBox::OnLButtonUp(CFWL_MessageMouse* pMsg) {
-  if (m_rtBtn.Contains(pMsg->m_pos))
+  if (m_BtnRect.Contains(pMsg->m_pos))
     m_iBtnState = CFWL_PartState_Hovered;
   else
     m_iBtnState = CFWL_PartState_Normal;
 
-  RepaintRect(m_rtBtn);
+  RepaintRect(m_BtnRect);
 }
 
 void CFWL_ComboBox::OnLButtonDown(CFWL_MessageMouse* pMsg) {
   bool bDropDown = IsDropListVisible();
-  CFX_RectF& rtBtn = bDropDown ? m_rtBtn : m_rtClient;
+  CFX_RectF& rtBtn = bDropDown ? m_BtnRect : m_ClientRect;
   if (!rtBtn.Contains(pMsg->m_pos))
     return;
 
diff --git a/xfa/fwl/cfwl_combobox.h b/xfa/fwl/cfwl_combobox.h
index 39c952c..5b82dd3 100644
--- a/xfa/fwl/cfwl_combobox.h
+++ b/xfa/fwl/cfwl_combobox.h
@@ -118,9 +118,9 @@
   void OnFocusChanged(CFWL_Message* pMsg, bool bSet);
   void OnKey(CFWL_MessageKey* pMsg);
 
-  CFX_RectF m_rtClient;
-  CFX_RectF m_rtContent;
-  CFX_RectF m_rtBtn;
+  CFX_RectF m_ClientRect;
+  CFX_RectF m_ContentRect;
+  CFX_RectF m_BtnRect;
   std::unique_ptr<CFWL_ComboEdit> m_pEdit;
   std::unique_ptr<CFWL_ComboList> m_pListBox;
   int32_t m_iCurSel = -1;
diff --git a/xfa/fwl/cfwl_combolist.cpp b/xfa/fwl/cfwl_combolist.cpp
index d25f312..01163c3 100644
--- a/xfa/fwl/cfwl_combolist.cpp
+++ b/xfa/fwl/cfwl_combolist.cpp
@@ -64,8 +64,8 @@
 }
 
 CFX_PointF CFWL_ComboList::ClientToOuter(const CFX_PointF& point) {
-  CFX_PointF ret = point + CFX_PointF(m_pProperties->m_rtWidget.left,
-                                      m_pProperties->m_rtWidget.top);
+  CFX_PointF ret = point + CFX_PointF(m_pProperties->m_WidgetRect.left,
+                                      m_pProperties->m_WidgetRect.top);
   CFWL_Widget* pOwner = GetOwner();
   return pOwner ? pOwner->TransformTo(m_pOuter, ret) : ret;
 }
@@ -230,8 +230,8 @@
 
       SetSelection(hItem, hItem, true);
       ScrollToVisible(hItem);
-      CFX_RectF rtInvalidate(0, 0, m_pProperties->m_rtWidget.width,
-                             m_pProperties->m_rtWidget.height);
+      CFX_RectF rtInvalidate(0, 0, m_pProperties->m_WidgetRect.width,
+                             m_pProperties->m_WidgetRect.height);
       RepaintRect(rtInvalidate);
       break;
     }
diff --git a/xfa/fwl/cfwl_datetimepicker.cpp b/xfa/fwl/cfwl_datetimepicker.cpp
index 1193966..48d857b 100644
--- a/xfa/fwl/cfwl_datetimepicker.cpp
+++ b/xfa/fwl/cfwl_datetimepicker.cpp
@@ -64,8 +64,8 @@
   if (!m_pProperties->m_pThemeProvider)
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
   m_pEdit->SetThemeProvider(m_pProperties->m_pThemeProvider.Get());
-  m_rtClient = GetClientRect();
-  m_pEdit->SetWidgetRect(m_rtClient);
+  m_ClientRect = GetClientRect();
+  m_pEdit->SetWidgetRect(m_ClientRect);
   ResetEditAlignment();
   m_pEdit->Update();
   if (!m_pMonthCal->GetThemeProvider())
@@ -84,8 +84,8 @@
 }
 
 FWL_WidgetHit CFWL_DateTimePicker::HitTest(const CFX_PointF& point) {
-  CFX_RectF rect(0, 0, m_pProperties->m_rtWidget.width,
-                 m_pProperties->m_rtWidget.height);
+  CFX_RectF rect(0, 0, m_pProperties->m_WidgetRect.width,
+                 m_pProperties->m_WidgetRect.height);
   if (rect.Contains(point))
     return FWL_WidgetHit::Edit;
   if (NeedsToShowButton())
@@ -110,7 +110,7 @@
 
   if (HasBorder())
     DrawBorder(pGraphics, CFWL_Part::Border, pTheme, matrix);
-  if (!m_rtBtn.IsEmpty())
+  if (!m_BtnRect.IsEmpty())
     DrawDropDownButton(pGraphics, pTheme, &matrix);
 
   if (m_pEdit) {
@@ -167,7 +167,7 @@
   if (!watched)
     return;
 
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 
   CFWL_Event ev(CFWL_Event::Type::EditChanged);
   DispatchEvent(&ev);
@@ -182,14 +182,15 @@
 }
 
 CFX_RectF CFWL_DateTimePicker::GetBBox() const {
-  CFX_RectF rect = m_pProperties->m_rtWidget;
+  CFX_RectF rect = m_pProperties->m_WidgetRect;
   if (NeedsToShowButton())
     rect.width += m_fBtn;
   if (!IsMonthCalendarVisible())
     return rect;
 
   CFX_RectF rtMonth = m_pMonthCal->GetWidgetRect();
-  rtMonth.Offset(m_pProperties->m_rtWidget.left, m_pProperties->m_rtWidget.top);
+  rtMonth.Offset(m_pProperties->m_WidgetRect.left,
+                 m_pProperties->m_WidgetRect.top);
   rect.Union(rtMonth);
   return rect;
 }
@@ -207,7 +208,7 @@
   param.m_iPart = CFWL_Part::DropDownButton;
   param.m_dwStates = m_iBtnState;
   param.m_pGraphics = pGraphics;
-  param.m_PartRect = m_rtBtn;
+  param.m_PartRect = m_BtnRect;
   if (pMatrix)
     param.m_matrix.Concat(*pMatrix);
   pTheme->DrawBackground(param);
@@ -230,9 +231,9 @@
     CFX_RectF rtMonthCal = m_pMonthCal->GetAutosizedWidgetRect();
     float fPopupMin = rtMonthCal.height;
     float fPopupMax = rtMonthCal.height;
-    CFX_RectF rtAnchor(m_pProperties->m_rtWidget);
+    CFX_RectF rtAnchor(m_pProperties->m_WidgetRect);
     rtAnchor.width = rtMonthCal.width;
-    rtMonthCal.left = m_rtClient.left;
+    rtMonthCal.left = m_ClientRect.left;
     rtMonthCal.top = rtAnchor.Height();
     GetPopupPos(fPopupMin, fPopupMax, rtAnchor, &rtMonthCal);
     m_pMonthCal->SetWidgetRect(rtMonthCal);
@@ -250,8 +251,8 @@
     m_pEdit->GetDelegate()->OnProcessMessage(&msg);
   }
 
-  CFX_RectF rtInvalidate(0, 0, m_pProperties->m_rtWidget.width,
-                         m_pProperties->m_rtWidget.height);
+  CFX_RectF rtInvalidate(0, 0, m_pProperties->m_WidgetRect.width,
+                         m_pProperties->m_WidgetRect.height);
 
   CFX_RectF rtCal = m_pMonthCal->GetWidgetRect();
   rtInvalidate.Union(rtCal);
@@ -318,7 +319,7 @@
     return;
 
   m_pEdit->Update();
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 
   CFWL_EventSelectChanged ev(this);
   ev.iYear = m_iYear;
@@ -388,19 +389,19 @@
   if (!pMsg)
     return;
 
-  CFX_RectF rtInvalidate(m_rtBtn);
+  CFX_RectF rtInvalidate(m_BtnRect);
   if (bSet) {
     m_pProperties->m_dwStates |= FWL_WGTSTATE_Focused;
     if (m_pEdit && !(m_pEdit->GetStylesEx() & FWL_STYLEEXT_EDT_ReadOnly)) {
-      m_rtBtn = CFX_RectF(m_pProperties->m_rtWidget.width, 0, m_fBtn,
-                          m_pProperties->m_rtWidget.height - 1);
+      m_BtnRect = CFX_RectF(m_pProperties->m_WidgetRect.width, 0, m_fBtn,
+                            m_pProperties->m_WidgetRect.height - 1);
     }
-    rtInvalidate = m_rtBtn;
+    rtInvalidate = m_BtnRect;
     pMsg->SetDstTarget(m_pEdit.get());
     m_pEdit->GetDelegate()->OnProcessMessage(pMsg);
   } else {
     m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
-    m_rtBtn = CFX_RectF();
+    m_BtnRect = CFX_RectF();
     if (IsMonthCalendarVisible())
       ShowMonthCalendar(false);
     if (m_pEdit->GetStates() & FWL_WGTSTATE_Focused) {
@@ -415,7 +416,7 @@
 void CFWL_DateTimePicker::OnLButtonDown(CFWL_MessageMouse* pMsg) {
   if (!pMsg)
     return;
-  if (!m_rtBtn.Contains(pMsg->m_pos))
+  if (!m_BtnRect.Contains(pMsg->m_pos))
     return;
 
   if (IsMonthCalendarVisible()) {
@@ -425,7 +426,7 @@
   ShowMonthCalendar(true);
 
   m_bLBtnDown = true;
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_DateTimePicker::OnLButtonUp(CFWL_MessageMouse* pMsg) {
@@ -433,24 +434,24 @@
     return;
 
   m_bLBtnDown = false;
-  if (m_rtBtn.Contains(pMsg->m_pos))
+  if (m_BtnRect.Contains(pMsg->m_pos))
     m_iBtnState = CFWL_PartState_Hovered;
   else
     m_iBtnState = CFWL_PartState_Normal;
-  RepaintRect(m_rtBtn);
+  RepaintRect(m_BtnRect);
 }
 
 void CFWL_DateTimePicker::OnMouseMove(CFWL_MessageMouse* pMsg) {
-  if (!m_rtBtn.Contains(pMsg->m_pos))
+  if (!m_BtnRect.Contains(pMsg->m_pos))
     m_iBtnState = CFWL_PartState_Normal;
-  RepaintRect(m_rtBtn);
+  RepaintRect(m_BtnRect);
 }
 
 void CFWL_DateTimePicker::OnMouseLeave(CFWL_MessageMouse* pMsg) {
   if (!pMsg)
     return;
   m_iBtnState = CFWL_PartState_Normal;
-  RepaintRect(m_rtBtn);
+  RepaintRect(m_BtnRect);
 }
 
 void CFWL_DateTimePicker::GetPopupPos(float fMinHeight,
diff --git a/xfa/fwl/cfwl_datetimepicker.h b/xfa/fwl/cfwl_datetimepicker.h
index 69520eb..734dd07 100644
--- a/xfa/fwl/cfwl_datetimepicker.h
+++ b/xfa/fwl/cfwl_datetimepicker.h
@@ -99,8 +99,8 @@
   int32_t m_iMonth = -1;
   int32_t m_iDay = -1;
   float m_fBtn = 0.0f;
-  CFX_RectF m_rtBtn;
-  CFX_RectF m_rtClient;
+  CFX_RectF m_BtnRect;
+  CFX_RectF m_ClientRect;
   std::unique_ptr<CFWL_DateTimeEdit> m_pEdit;
   std::unique_ptr<CFWL_MonthCalendar> m_pMonthCal;
 };
diff --git a/xfa/fwl/cfwl_edit.cpp b/xfa/fwl/cfwl_edit.cpp
index cb9cb24..ec3b699 100644
--- a/xfa/fwl/cfwl_edit.cpp
+++ b/xfa/fwl/cfwl_edit.cpp
@@ -64,7 +64,7 @@
 }
 
 CFX_RectF CFWL_Edit::GetWidgetRect() {
-  CFX_RectF rect = m_pProperties->m_rtWidget;
+  CFX_RectF rect = m_pProperties->m_WidgetRect;
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
     IFWL_ThemeProvider* theme = GetAvailableTheme();
     float scrollbarWidth = theme ? theme->GetScrollBarWidth() : 0.0f;
@@ -109,7 +109,7 @@
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
 
   Layout();
-  if (m_rtClient.IsEmpty())
+  if (m_ClientRect.IsEmpty())
     return;
 
   UpdateEditEngine();
@@ -129,7 +129,7 @@
         return FWL_WidgetHit::HScrollBar;
     }
   }
-  if (m_rtClient.Contains(point))
+  if (m_ClientRect.Contains(point))
     return FWL_WidgetHit::Edit;
   return FWL_WidgetHit::Unknown;
 }
@@ -138,7 +138,7 @@
   if (!pGraphics)
     return;
 
-  if (m_rtClient.IsEmpty())
+  if (m_ClientRect.IsEmpty())
     return;
 
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider.Get();
@@ -272,7 +272,7 @@
 }
 
 void CFWL_Edit::OnCaretChanged() {
-  if (m_rtEngine.IsEmpty())
+  if (m_EngineRect.IsEmpty())
     return;
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) == 0)
     return;
@@ -290,7 +290,7 @@
   }
   if (bRepaintContent || bRepaintScroll) {
     if (bRepaintContent)
-      rtInvalid.Union(m_rtEngine);
+      rtInvalid.Union(m_EngineRect);
     RepaintRect(rtInvalid);
   }
 }
@@ -350,7 +350,7 @@
     param.m_dwStates = CFWL_PartState_Disabled;
   param.m_pGraphics = pGraphics;
   param.m_matrix = *pMatrix;
-  param.m_PartRect = m_rtClient;
+  param.m_PartRect = m_ClientRect;
   pTheme->DrawBackground(param);
 
   if (!IsShowScrollBar(true) || !IsShowScrollBar(false))
@@ -358,8 +358,8 @@
 
   CFX_RectF rtScroll = m_pHorzScrollBar->GetWidgetRect();
 
-  CFX_RectF rtStatic(m_rtClient.right() - rtScroll.height,
-                     m_rtClient.bottom() - rtScroll.height, rtScroll.height,
+  CFX_RectF rtStatic(m_ClientRect.right() - rtScroll.height,
+                     m_ClientRect.bottom() - rtScroll.height, rtScroll.height,
                      rtScroll.height);
   param.m_bStaticBackground = true;
   param.m_bMaximize = true;
@@ -375,9 +375,9 @@
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_CombText)
     pGraphics->SaveGraphState();
 
-  CFX_RectF rtClip = m_rtEngine;
-  float fOffSetX = m_rtEngine.left - m_fScrollOffsetX;
-  float fOffSetY = m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset;
+  CFX_RectF rtClip = m_EngineRect;
+  float fOffSetX = m_EngineRect.left - m_fScrollOffsetX;
+  float fOffSetY = m_EngineRect.top - m_fScrollOffsetY + m_fVAlignOffset;
 
   CFX_Matrix mt(1, 0, 0, 1, fOffSetX, fOffSetY);
   if (pMatrix) {
@@ -418,12 +418,12 @@
 
     CXFA_GEPath path;
     int32_t iLimit = m_nLimit > 0 ? m_nLimit : 1;
-    float fStep = m_rtEngine.width / iLimit;
-    float fLeft = m_rtEngine.left + 1;
+    float fStep = m_EngineRect.width / iLimit;
+    float fLeft = m_EngineRect.left + 1;
     for (int32_t i = 1; i < iLimit; i++) {
       fLeft += fStep;
-      path.AddLine(CFX_PointF(fLeft, m_rtClient.top),
-                   CFX_PointF(fLeft, m_rtClient.bottom()));
+      path.AddLine(CFX_PointF(fLeft, m_ClientRect.top),
+                   CFX_PointF(fLeft, m_ClientRect.bottom()));
     }
 
     CFWL_ThemeBackground param;
@@ -477,7 +477,7 @@
 }
 
 void CFWL_Edit::UpdateEditParams() {
-  m_pEditEngine->SetAvailableWidth(m_rtEngine.width);
+  m_pEditEngine->SetAvailableWidth(m_EngineRect.width);
   m_pEditEngine->SetCombText(
       !!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_CombText));
 
@@ -547,7 +547,7 @@
   m_pEditEngine->SetFontSize(m_fFontSize);
   m_pEditEngine->SetLineSpace(theme->GetLineHeight(part));
   m_pEditEngine->SetTabWidth(m_fFontSize);
-  m_pEditEngine->SetVisibleLineCount(m_rtEngine.height /
+  m_pEditEngine->SetVisibleLineCount(m_EngineRect.height /
                                      theme->GetLineHeight(part));
 }
 
@@ -556,13 +556,13 @@
 }
 
 bool CFWL_Edit::UpdateOffset() {
-  CFX_RectF rtCaret = m_rtCaret;
+  CFX_RectF rtCaret = m_CaretRect;
 
-  float fOffSetX = m_rtEngine.left - m_fScrollOffsetX;
-  float fOffSetY = m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset;
+  float fOffSetX = m_EngineRect.left - m_fScrollOffsetX;
+  float fOffSetY = m_EngineRect.top - m_fScrollOffsetY + m_fVAlignOffset;
   rtCaret.Offset(fOffSetX, fOffSetY);
 
-  const CFX_RectF& edit_bounds = m_rtEngine;
+  const CFX_RectF& edit_bounds = m_EngineRect;
   if (edit_bounds.Contains(rtCaret)) {
     CFX_RectF contents_bounds = m_pEditEngine->GetContentsBoundingBox();
     contents_bounds.Offset(fOffSetX, fOffSetY);
@@ -591,7 +591,7 @@
 
   m_fScrollOffsetX += offsetX;
   m_fScrollOffsetY += offsetY;
-  if (m_fFontSize > m_rtEngine.height)
+  if (m_fFontSize > m_EngineRect.height)
     m_fScrollOffsetY = 0;
 
   return true;
@@ -621,14 +621,14 @@
   float fOffsetY = 0.0f;
   CFX_RectF contents_bounds = m_pEditEngine->GetContentsBoundingBox();
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VCenter) {
-    fOffsetY = (m_rtEngine.height - contents_bounds.height) / 2.0f;
+    fOffsetY = (m_EngineRect.height - contents_bounds.height) / 2.0f;
     if (fOffsetY < (fSpaceAbove + fSpaceBelow) / 2.0f &&
         fSpaceAbove < fSpaceBelow) {
       return;
     }
     fOffsetY += (fSpaceAbove - fSpaceBelow) / 2.0f;
   } else if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VFar) {
-    fOffsetY = (m_rtEngine.height - contents_bounds.height);
+    fOffsetY = (m_EngineRect.height - contents_bounds.height);
     fOffsetY -= fSpaceBelow;
   } else {
     fOffsetY += fSpaceAbove;
@@ -637,9 +637,9 @@
 }
 
 void CFWL_Edit::UpdateCaret() {
-  CFX_RectF rtCaret = m_rtCaret;
-  rtCaret.Offset(m_rtEngine.left - m_fScrollOffsetX,
-                 m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset);
+  CFX_RectF rtCaret = m_CaretRect;
+  rtCaret.Offset(m_EngineRect.left - m_fScrollOffsetX,
+                 m_EngineRect.top - m_fScrollOffsetY + m_fVAlignOffset);
 
   CFX_RectF rtClient = GetClientRect();
   rtCaret.Intersect(rtClient);
@@ -698,7 +698,7 @@
         ScopedUpdateLock update_lock(m_pHorzScrollBar.get());
         float fStep = m_pEditEngine->GetLineSpace();
         float fRange =
-            std::max(contents_bounds.height - m_rtEngine.height, fStep);
+            std::max(contents_bounds.height - m_EngineRect.height, fStep);
 
         m_pVertScrollBar->SetRange(0.0f, fRange);
         float fPos = pdfium::clamp(m_fScrollOffsetY, 0.0f, fRange);
@@ -738,12 +738,12 @@
 
 bool CFWL_Edit::IsContentHeightOverflow() {
   return m_pEditEngine->GetContentsBoundingBox().height >
-         m_rtEngine.height + 1.0f;
+         m_EngineRect.height + 1.0f;
 }
 
 void CFWL_Edit::Layout() {
-  m_rtClient = GetClientRect();
-  m_rtEngine = m_rtClient;
+  m_ClientRect = GetClientRect();
+  m_EngineRect = m_ClientRect;
   IFWL_ThemeProvider* theme = GetAvailableTheme();
   if (!theme)
     return;
@@ -753,13 +753,13 @@
   if (!m_pOuter) {
     part.m_pWidget = this;
     CFX_RectF pUIMargin = theme->GetUIMargin(part);
-    m_rtEngine.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
-                       pUIMargin.height);
+    m_EngineRect.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
+                         pUIMargin.height);
   } else if (m_pOuter->GetClassID() == FWL_Type::DateTimePicker) {
     part.m_pWidget = m_pOuter;
     CFX_RectF pUIMargin = theme->GetUIMargin(part);
-    m_rtEngine.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
-                       pUIMargin.height);
+    m_EngineRect.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
+                         pUIMargin.height);
   }
 
   bool bShowVertScrollbar = IsShowScrollBar(true);
@@ -769,14 +769,14 @@
 
     CFX_RectF rtVertScr;
     if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
-      rtVertScr = CFX_RectF(m_rtClient.right() + kEditMargin, m_rtClient.top,
-                            fWidth, m_rtClient.height);
+      rtVertScr = CFX_RectF(m_ClientRect.right() + kEditMargin,
+                            m_ClientRect.top, fWidth, m_ClientRect.height);
     } else {
-      rtVertScr = CFX_RectF(m_rtClient.right() - fWidth, m_rtClient.top, fWidth,
-                            m_rtClient.height);
+      rtVertScr = CFX_RectF(m_ClientRect.right() - fWidth, m_ClientRect.top,
+                            fWidth, m_ClientRect.height);
       if (bShowHorzScrollbar)
         rtVertScr.height -= fWidth;
-      m_rtEngine.width -= fWidth;
+      m_EngineRect.width -= fWidth;
     }
 
     m_pVertScrollBar->SetWidgetRect(rtVertScr);
@@ -791,14 +791,15 @@
 
     CFX_RectF rtHoriScr;
     if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
-      rtHoriScr = CFX_RectF(m_rtClient.left, m_rtClient.bottom() + kEditMargin,
-                            m_rtClient.width, fWidth);
+      rtHoriScr =
+          CFX_RectF(m_ClientRect.left, m_ClientRect.bottom() + kEditMargin,
+                    m_ClientRect.width, fWidth);
     } else {
-      rtHoriScr = CFX_RectF(m_rtClient.left, m_rtClient.bottom() - fWidth,
-                            m_rtClient.width, fWidth);
+      rtHoriScr = CFX_RectF(m_ClientRect.left, m_ClientRect.bottom() - fWidth,
+                            m_ClientRect.width, fWidth);
       if (bShowVertScrollbar)
         rtHoriScr.width -= fWidth;
-      m_rtEngine.height -= fWidth;
+      m_EngineRect.height -= fWidth;
     }
     m_pHorzScrollBar->SetWidgetRect(rtHoriScr);
     m_pHorzScrollBar->RemoveStates(FWL_WGTSTATE_Invisible);
@@ -824,11 +825,11 @@
       InitVerticalScrollBar();
       CFX_RectF rtVertScr;
       if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
-        rtVertScr = CFX_RectF(m_rtClient.right() + kEditMargin, m_rtClient.top,
-                              fWidth, m_rtClient.height);
+        rtVertScr = CFX_RectF(m_ClientRect.right() + kEditMargin,
+                              m_ClientRect.top, fWidth, m_ClientRect.height);
       } else {
-        rtVertScr = CFX_RectF(m_rtClient.right() - fWidth, m_rtClient.top,
-                              fWidth, m_rtClient.height);
+        rtVertScr = CFX_RectF(m_ClientRect.right() - fWidth, m_ClientRect.top,
+                              fWidth, m_ClientRect.height);
         if (bShowHorzScrollbar)
           rtVertScr.height -= fWidth;
       }
@@ -846,11 +847,11 @@
       CFX_RectF rtHoriScr;
       if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
         rtHoriScr =
-            CFX_RectF(m_rtClient.left, m_rtClient.bottom() + kEditMargin,
-                      m_rtClient.width, fWidth);
+            CFX_RectF(m_ClientRect.left, m_ClientRect.bottom() + kEditMargin,
+                      m_ClientRect.width, fWidth);
       } else {
-        rtHoriScr = CFX_RectF(m_rtClient.left, m_rtClient.bottom() - fWidth,
-                              m_rtClient.width, fWidth);
+        rtHoriScr = CFX_RectF(m_ClientRect.left, m_ClientRect.bottom() - fWidth,
+                              m_ClientRect.width, fWidth);
         if (bShowVertScrollbar)
           rtHoriScr.width -= (fWidth);
       }
@@ -866,8 +867,8 @@
 }
 
 CFX_PointF CFWL_Edit::DeviceToEngine(const CFX_PointF& pt) {
-  return pt + CFX_PointF(m_fScrollOffsetX - m_rtEngine.left,
-                         m_fScrollOffsetY - m_rtEngine.top - m_fVAlignOffset);
+  return pt + CFX_PointF(m_fScrollOffsetX - m_EngineRect.left,
+                         m_fScrollOffsetY - m_EngineRect.top - m_fVAlignOffset);
 }
 
 void CFWL_Edit::InitVerticalScrollBar() {
@@ -901,12 +902,13 @@
     m_pCaret->ShowCaret();
     if (!pRect->IsEmpty())
       m_pCaret->SetWidgetRect(*pRect);
-    RepaintRect(m_rtEngine);
+    RepaintRect(m_EngineRect);
     return;
   }
 
   CFWL_Widget* pOuter = this;
-  pRect->Offset(m_pProperties->m_rtWidget.left, m_pProperties->m_rtWidget.top);
+  pRect->Offset(m_pProperties->m_WidgetRect.left,
+                m_pProperties->m_WidgetRect.top);
   while (pOuter->GetOuter()) {
     pOuter = pOuter->GetOuter();
 
@@ -925,7 +927,7 @@
 void CFWL_Edit::HideCaret(CFX_RectF* pRect) {
   if (m_pCaret) {
     m_pCaret->HideCaret();
-    RepaintRect(m_rtEngine);
+    RepaintRect(m_EngineRect);
     return;
   }
 
@@ -974,21 +976,21 @@
 void CFWL_Edit::UpdateCursorRect() {
   int32_t bidi_level;
   if (m_pEditEngine->GetLength() > 0) {
-    std::tie(bidi_level, m_rtCaret) =
+    std::tie(bidi_level, m_CaretRect) =
         m_pEditEngine->GetCharacterInfo(m_CursorPosition);
   } else {
     bidi_level = 0;
-    m_rtCaret = CFX_RectF();
+    m_CaretRect = CFX_RectF();
   }
 
   // TODO(dsinclair): This should handle bidi level  ...
 
-  m_rtCaret.width = 1.0f;
+  m_CaretRect.width = 1.0f;
 
   // TODO(hnakashima): Handle correctly edits with empty text instead of using
   // these defaults.
-  if (m_rtCaret.height == 0)
-    m_rtCaret.height = 8.0f;
+  if (m_CaretRect.height == 0)
+    m_CaretRect.height = 8.0f;
 }
 
 void CFWL_Edit::SetCursorPosition(size_t position) {
@@ -1096,8 +1098,8 @@
   if (!bRepaint)
     return;
 
-  CFX_RectF rtInvalidate(0, 0, m_pProperties->m_rtWidget.width,
-                         m_pProperties->m_rtWidget.height);
+  CFX_RectF rtInvalidate(0, 0, m_pProperties->m_WidgetRect.width,
+                         m_pProperties->m_WidgetRect.height);
   RepaintRect(rtInvalidate);
 }
 
@@ -1129,7 +1131,7 @@
   }
 
   if (bRepaint)
-    RepaintRect(m_rtEngine);
+    RepaintRect(m_EngineRect);
 }
 
 void CFWL_Edit::OnLButtonUp(CFWL_MessageMouse* pMsg) {
@@ -1146,7 +1148,7 @@
 
   m_pEditEngine->SetSelection(start_idx, count);
   m_CursorPosition = start_idx + count;
-  RepaintRect(m_rtEngine);
+  RepaintRect(m_EngineRect);
 }
 
 void CFWL_Edit::OnMouseMove(CFWL_MessageMouse* pMsg) {
@@ -1231,7 +1233,7 @@
   if (bShift && sel_start != m_CursorPosition) {
     m_pEditEngine->SetSelection(std::min(sel_start, m_CursorPosition),
                                 std::max(sel_start, m_CursorPosition));
-    RepaintRect(m_rtEngine);
+    RepaintRect(m_EngineRect);
   }
 }
 
diff --git a/xfa/fwl/cfwl_edit.h b/xfa/fwl/cfwl_edit.h
index 0242e5c..c991163 100644
--- a/xfa/fwl/cfwl_edit.h
+++ b/xfa/fwl/cfwl_edit.h
@@ -102,7 +102,7 @@
  protected:
   void ShowCaret(CFX_RectF* pRect);
   void HideCaret(CFX_RectF* pRect);
-  const CFX_RectF& GetRTClient() const { return m_rtClient; }
+  const CFX_RectF& GetRTClient() const { return m_ClientRect; }
   CFDE_TextEditEngine* GetTxtEdtEngine() { return m_pEditEngine.get(); }
 
  private:
@@ -149,10 +149,10 @@
                 CFWL_EventScroll::Code dwCode,
                 float fPos);
 
-  CFX_RectF m_rtClient;
-  CFX_RectF m_rtEngine;
-  CFX_RectF m_rtStatic;
-  CFX_RectF m_rtCaret;
+  CFX_RectF m_ClientRect;
+  CFX_RectF m_EngineRect;
+  CFX_RectF m_StaticRect;
+  CFX_RectF m_CaretRect;
   bool m_bLButtonDown = false;
   bool m_bSetRange = false;
   int32_t m_nLimit = -1;
diff --git a/xfa/fwl/cfwl_listbox.cpp b/xfa/fwl/cfwl_listbox.cpp
index a2fad92..4ff3d5e 100644
--- a/xfa/fwl/cfwl_listbox.cpp
+++ b/xfa/fwl/cfwl_listbox.cpp
@@ -77,7 +77,7 @@
     if (rect.Contains(point))
       return FWL_WidgetHit::VScrollBar;
   }
-  if (m_rtClient.Contains(point))
+  if (m_ClientRect.Contains(point))
     return FWL_WidgetHit::Client;
   return FWL_WidgetHit::Unknown;
 }
@@ -95,7 +95,7 @@
   if (HasBorder())
     DrawBorder(pGraphics, CFWL_Part::Border, pTheme, matrix);
 
-  CFX_RectF rtClip(m_rtConent);
+  CFX_RectF rtClip(m_ContentRect);
   if (IsShowScrollBar(false))
     rtClip.height -= m_fScorllBarWidth;
   if (IsShowScrollBar(true))
@@ -295,7 +295,7 @@
 }
 
 CFWL_ListItem* CFWL_ListBox::GetItemAtPoint(const CFX_PointF& point) {
-  CFX_PointF pos = point - m_rtConent.TopLeft();
+  CFX_PointF pos = point - m_ContentRect.TopLeft();
   float fPosX = 0.0f;
   if (m_pHorzScrollBar)
     fPosX = m_pHorzScrollBar->GetPos();
@@ -325,12 +325,12 @@
   CFX_RectF rtItem = pItem ? pItem->GetRect() : CFX_RectF();
   bool bScroll = false;
   float fPosY = m_pVertScrollBar->GetPos();
-  rtItem.Offset(0, -fPosY + m_rtConent.top);
-  if (rtItem.top < m_rtConent.top) {
-    fPosY += rtItem.top - m_rtConent.top;
+  rtItem.Offset(0, -fPosY + m_ContentRect.top);
+  if (rtItem.top < m_ContentRect.top) {
+    fPosY += rtItem.top - m_ContentRect.top;
     bScroll = true;
-  } else if (rtItem.bottom() > m_rtConent.bottom()) {
-    fPosY += rtItem.bottom() - m_rtConent.bottom();
+  } else if (rtItem.bottom() > m_ContentRect.bottom()) {
+    fPosY += rtItem.bottom() - m_ContentRect.bottom();
     bScroll = true;
   }
   if (!bScroll)
@@ -338,7 +338,7 @@
 
   m_pVertScrollBar->SetPos(fPosY);
   m_pVertScrollBar->SetTrackPos(fPosY);
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
   return true;
 }
 
@@ -356,9 +356,9 @@
   param.m_dwStates = 0;
   param.m_pGraphics = pGraphics;
   param.m_matrix.Concat(*pMatrix);
-  param.m_PartRect = m_rtClient;
+  param.m_PartRect = m_ClientRect;
   if (IsShowScrollBar(false) && IsShowScrollBar(true))
-    param.m_pRtData = &m_rtStatic;
+    param.m_pRtData = &m_StaticRect;
   if (!IsEnabled())
     param.m_dwStates = CFWL_PartState_Disabled;
 
@@ -376,7 +376,7 @@
   if (m_pVertScrollBar)
     fPosY = m_pVertScrollBar->GetPos();
 
-  CFX_RectF rtView(m_rtConent);
+  CFX_RectF rtView(m_ContentRect);
   if (m_pHorzScrollBar)
     rtView.height -= m_fScorllBarWidth;
   if (m_pVertScrollBar)
@@ -389,10 +389,10 @@
       continue;
 
     CFX_RectF rtItem = pItem->GetRect();
-    rtItem.Offset(m_rtConent.left - fPosX, m_rtConent.top - fPosY);
-    if (rtItem.bottom() < m_rtConent.top)
+    rtItem.Offset(m_ContentRect.left - fPosX, m_ContentRect.top - fPosY);
+    if (rtItem.bottom() < m_ContentRect.top)
       continue;
-    if (rtItem.top >= m_rtConent.bottom())
+    if (rtItem.top >= m_ContentRect.bottom())
       break;
     DrawItem(pGraphics, pTheme, pItem, i, rtItem, pMatrix);
   }
@@ -462,22 +462,23 @@
   if (!m_pProperties->m_pThemeProvider)
     return CFX_SizeF();
 
-  m_rtClient = GetClientRect();
-  m_rtConent = m_rtClient;
+  m_ClientRect = GetClientRect();
+  m_ContentRect = m_ClientRect;
   CFX_RectF rtUIMargin;
   if (!m_pOuter) {
     CFWL_ThemePart part;
     part.m_pWidget = this;
     IFWL_ThemeProvider* theme = GetAvailableTheme();
     CFX_RectF pUIMargin = theme ? theme->GetUIMargin(part) : CFX_RectF();
-    m_rtConent.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
-                       pUIMargin.height);
+    m_ContentRect.Deflate(pUIMargin.left, pUIMargin.top, pUIMargin.width,
+                          pUIMargin.height);
   }
 
   float fWidth = GetMaxTextWidth();
   fWidth += 2 * kItemTextMargin;
   if (!bAutoSize) {
-    float fActualWidth = m_rtClient.width - rtUIMargin.left - rtUIMargin.width;
+    float fActualWidth =
+        m_ClientRect.width - rtUIMargin.left - rtUIMargin.width;
     fWidth = std::max(fWidth, fActualWidth);
   }
   m_fItemHeight = CalcItemHeight();
@@ -491,7 +492,7 @@
   if (bAutoSize)
     return fs;
 
-  float iHeight = m_rtClient.height;
+  float iHeight = m_ClientRect.height;
   bool bShowVertScr = false;
   bool bShowHorzScr = false;
   if (!bShowVertScr && (m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll))
@@ -502,15 +503,15 @@
     if (!m_pVertScrollBar)
       InitVerticalScrollBar();
 
-    CFX_RectF rtScrollBar(m_rtClient.right() - m_fScorllBarWidth,
-                          m_rtClient.top, m_fScorllBarWidth,
-                          m_rtClient.height - 1);
+    CFX_RectF rtScrollBar(m_ClientRect.right() - m_fScorllBarWidth,
+                          m_ClientRect.top, m_fScorllBarWidth,
+                          m_ClientRect.height - 1);
     if (bShowHorzScr)
       rtScrollBar.height -= m_fScorllBarWidth;
 
     m_pVertScrollBar->SetWidgetRect(rtScrollBar);
     szRange.width = 0;
-    szRange.height = std::max(fs.height - m_rtConent.height, m_fItemHeight);
+    szRange.height = std::max(fs.height - m_ContentRect.height, m_fItemHeight);
 
     m_pVertScrollBar->SetRange(szRange.width, szRange.height);
     m_pVertScrollBar->SetPageSize(rtScrollBar.height * 9 / 10);
@@ -535,9 +536,9 @@
     if (!m_pHorzScrollBar)
       InitHorizontalScrollBar();
 
-    CFX_RectF rtScrollBar(m_rtClient.left,
-                          m_rtClient.bottom() - m_fScorllBarWidth,
-                          m_rtClient.width, m_fScorllBarWidth);
+    CFX_RectF rtScrollBar(m_ClientRect.left,
+                          m_ClientRect.bottom() - m_fScorllBarWidth,
+                          m_ClientRect.width, m_fScorllBarWidth);
     if (bShowVertScr)
       rtScrollBar.width -= m_fScorllBarWidth;
 
@@ -564,9 +565,9 @@
     m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
   if (bShowVertScr && bShowHorzScr) {
-    m_rtStatic = CFX_RectF(m_rtClient.right() - m_fScorllBarWidth,
-                           m_rtClient.bottom() - m_fScorllBarWidth,
-                           m_fScorllBarWidth, m_fScorllBarWidth);
+    m_StaticRect = CFX_RectF(m_ClientRect.right() - m_fScorllBarWidth,
+                             m_ClientRect.bottom() - m_fScorllBarWidth,
+                             m_fScorllBarWidth, m_fScorllBarWidth);
   }
   return fs;
 }
@@ -732,7 +733,7 @@
   else
     m_pProperties->m_dwStates &= ~(FWL_WGTSTATE_Focused);
 
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_ListBox::OnLButtonDown(CFWL_MessageMouse* pMsg) {
@@ -763,7 +764,7 @@
   SetFocusItem(pItem);
   ScrollToVisible(pItem);
   SetGrab(true);
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_ListBox::OnLButtonUp(CFWL_MessageMouse* pMsg) {
@@ -822,8 +823,8 @@
   SetFocusItem(pItem);
   ScrollToVisible(pItem);
 
-  RepaintRect(CFX_RectF(0, 0, m_pProperties->m_rtWidget.width,
-                        m_pProperties->m_rtWidget.height));
+  RepaintRect(CFX_RectF(0, 0, m_pProperties->m_WidgetRect.width,
+                        m_pProperties->m_WidgetRect.height));
 }
 
 bool CFWL_ListBox::OnScroll(CFWL_ScrollBar* pScrollBar,
@@ -876,7 +877,7 @@
   if (iCurPos != fPos) {
     pScrollBar->SetPos(fPos);
     pScrollBar->SetTrackPos(fPos);
-    RepaintRect(m_rtClient);
+    RepaintRect(m_ClientRect);
   }
   return true;
 }
diff --git a/xfa/fwl/cfwl_listbox.h b/xfa/fwl/cfwl_listbox.h
index 178e49a..df99c0b 100644
--- a/xfa/fwl/cfwl_listbox.h
+++ b/xfa/fwl/cfwl_listbox.h
@@ -75,7 +75,7 @@
   void InitHorizontalScrollBar();
   bool IsShowScrollBar(bool bVert);
   CFWL_ScrollBar* GetVertScrollBar() const { return m_pVertScrollBar.get(); }
-  const CFX_RectF& GetRTClient() const { return m_rtClient; }
+  const CFX_RectF& GetRTClient() const { return m_ClientRect; }
 
  private:
   void SetSelectionDirect(CFWL_ListItem* hItem, bool bSelect);
@@ -117,9 +117,9 @@
                 CFWL_EventScroll::Code dwCode,
                 float fPos);
 
-  CFX_RectF m_rtClient;
-  CFX_RectF m_rtStatic;
-  CFX_RectF m_rtConent;
+  CFX_RectF m_ClientRect;
+  CFX_RectF m_StaticRect;
+  CFX_RectF m_ContentRect;
   std::unique_ptr<CFWL_ScrollBar> m_pHorzScrollBar;
   std::unique_ptr<CFWL_ScrollBar> m_pVertScrollBar;
   FDE_TextStyle m_TTOStyles;
diff --git a/xfa/fwl/cfwl_listitem.h b/xfa/fwl/cfwl_listitem.h
index a6afb22..bb91d6e 100644
--- a/xfa/fwl/cfwl_listitem.h
+++ b/xfa/fwl/cfwl_listitem.h
@@ -15,8 +15,8 @@
   explicit CFWL_ListItem(const WideString& text);
   ~CFWL_ListItem();
 
-  CFX_RectF GetRect() const { return m_rtItem; }
-  void SetRect(const CFX_RectF& rect) { m_rtItem = rect; }
+  CFX_RectF GetRect() const { return m_ItemRect; }
+  void SetRect(const CFX_RectF& rect) { m_ItemRect = rect; }
 
   uint32_t GetStates() const { return m_dwStates; }
   void SetStates(uint32_t dwStates) { m_dwStates = dwStates; }
@@ -25,7 +25,7 @@
 
  private:
   uint32_t m_dwStates = 0;
-  CFX_RectF m_rtItem;
+  CFX_RectF m_ItemRect;
   WideString m_wsText;
 };
 
diff --git a/xfa/fwl/cfwl_monthcalendar.cpp b/xfa/fwl/cfwl_monthcalendar.cpp
index b15a799..084ee0c 100644
--- a/xfa/fwl/cfwl_monthcalendar.cpp
+++ b/xfa/fwl/cfwl_monthcalendar.cpp
@@ -163,7 +163,7 @@
   params.m_iPart = CFWL_Part::Background;
   params.m_pGraphics = pGraphics;
   params.m_dwStates = CFWL_PartState_Normal;
-  params.m_PartRect = m_rtClient;
+  params.m_PartRect = m_ClientRect;
   if (pMatrix)
     params.m_matrix.Concat(*pMatrix);
   pTheme->DrawBackground(params);
@@ -177,7 +177,7 @@
   params.m_iPart = CFWL_Part::Header;
   params.m_pGraphics = pGraphics;
   params.m_dwStates = CFWL_PartState_Normal;
-  params.m_PartRect = m_rtHead;
+  params.m_PartRect = m_HeadRect;
   if (pMatrix)
     params.m_matrix.Concat(*pMatrix);
   pTheme->DrawBackground(params);
@@ -191,7 +191,7 @@
   params.m_iPart = CFWL_Part::LBtn;
   params.m_pGraphics = pGraphics;
   params.m_dwStates = m_iLBtnPartStates;
-  params.m_PartRect = m_rtLBtn;
+  params.m_PartRect = m_LBtnRect;
   if (pMatrix)
     params.m_matrix.Concat(*pMatrix);
   pTheme->DrawBackground(params);
@@ -205,7 +205,7 @@
   params.m_iPart = CFWL_Part::RBtn;
   params.m_pGraphics = pGraphics;
   params.m_dwStates = m_iRBtnPartStates;
-  params.m_PartRect = m_rtRBtn;
+  params.m_PartRect = m_RBtnRect;
   if (pMatrix)
     params.m_matrix.Concat(*pMatrix);
   pTheme->DrawBackground(params);
@@ -223,7 +223,7 @@
   m_szHead = CalcTextSize(textParam.m_wsText,
                           m_pProperties->m_pThemeProvider.Get(), false);
   CalcHeadSize();
-  textParam.m_PartRect = m_rtHeadText;
+  textParam.m_PartRect = m_HeadTextRect;
   textParam.m_dwTTOStyles.single_line_ = true;
   textParam.m_iTTOAlign = FDE_TextAlignment::kCenter;
   if (pMatrix)
@@ -239,7 +239,7 @@
   params.m_iPart = CFWL_Part::HSeparator;
   params.m_pGraphics = pGraphics;
   params.m_dwStates = CFWL_PartState_Normal;
-  params.m_PartRect = m_rtHSep;
+  params.m_PartRect = m_HSepRect;
   if (pMatrix)
     params.m_matrix.Concat(*pMatrix);
   pTheme->DrawBackground(params);
@@ -292,8 +292,8 @@
 
   for (int32_t i = 0; i < 7; ++i) {
     rtDayOfWeek =
-        CFX_RectF(m_rtWeek.left + i * (m_szCell.width + MONTHCAL_HMARGIN * 2),
-                  m_rtWeek.top, m_szCell);
+        CFX_RectF(m_WeekRect.left + i * (m_szCell.width + MONTHCAL_HMARGIN * 2),
+                  m_WeekRect.top, m_szCell);
 
     params.m_PartRect = rtDayOfWeek;
     params.m_wsText = GetAbbreviatedDayOfWeek(i);
@@ -315,7 +315,7 @@
   m_szToday = CalcTextSize(params.m_wsText,
                            m_pProperties->m_pThemeProvider.Get(), false);
   CalcTodaySize();
-  params.m_PartRect = m_rtToday;
+  params.m_PartRect = m_TodayRect;
   params.m_dwTTOStyles.single_line_ = true;
 
   if (pMatrix)
@@ -443,54 +443,54 @@
 }
 
 void CFWL_MonthCalendar::CalcHeadSize() {
-  float fHeadHMargin = (m_rtClient.width - m_szHead.width) / 2;
+  float fHeadHMargin = (m_ClientRect.width - m_szHead.width) / 2;
   float fHeadVMargin = (m_szCell.width - m_szHead.height) / 2;
-  m_rtHeadText = CFX_RectF(m_rtClient.left + fHeadHMargin,
-                           m_rtClient.top + MONTHCAL_HEADER_BTN_VMARGIN +
-                               MONTHCAL_VMARGIN + fHeadVMargin,
-                           m_szHead);
+  m_HeadTextRect = CFX_RectF(m_ClientRect.left + fHeadHMargin,
+                             m_ClientRect.top + MONTHCAL_HEADER_BTN_VMARGIN +
+                                 MONTHCAL_VMARGIN + fHeadVMargin,
+                             m_szHead);
 }
 
 void CFWL_MonthCalendar::CalcTodaySize() {
-  m_rtTodayFlag = CFX_RectF(
-      m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN,
-      m_rtDates.bottom() + MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN,
+  m_TodayFlagRect = CFX_RectF(
+      m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN,
+      m_DatesRect.bottom() + MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN,
       m_szCell.width, m_szToday.height);
-  m_rtToday = CFX_RectF(
-      m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN + m_szCell.width +
+  m_TodayRect = CFX_RectF(
+      m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN + m_szCell.width +
           MONTHCAL_HMARGIN * 2,
-      m_rtDates.bottom() + MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN,
+      m_DatesRect.bottom() + MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN,
       m_szToday);
 }
 
 void CFWL_MonthCalendar::Layout() {
-  m_rtClient = GetClientRect();
+  m_ClientRect = GetClientRect();
 
-  m_rtHead = CFX_RectF(
-      m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN, m_rtClient.top,
-      m_rtClient.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
+  m_HeadRect = CFX_RectF(
+      m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN, m_ClientRect.top,
+      m_ClientRect.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
       m_szCell.width + (MONTHCAL_HEADER_BTN_VMARGIN + MONTHCAL_VMARGIN) * 2);
-  m_rtWeek = CFX_RectF(m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN,
-                       m_rtHead.bottom(),
-                       m_rtClient.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
-                       m_szCell.height + MONTHCAL_VMARGIN * 2);
-  m_rtLBtn = CFX_RectF(m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN,
-                       m_rtClient.top + MONTHCAL_HEADER_BTN_VMARGIN,
-                       m_szCell.width, m_szCell.width);
-  m_rtRBtn = CFX_RectF(m_rtClient.left + m_rtClient.width -
-                           MONTHCAL_HEADER_BTN_HMARGIN - m_szCell.width,
-                       m_rtClient.top + MONTHCAL_HEADER_BTN_VMARGIN,
-                       m_szCell.width, m_szCell.width);
-  m_rtHSep = CFX_RectF(
-      m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN,
-      m_rtWeek.bottom() - MONTHCAL_VMARGIN,
-      m_rtClient.width - (MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN) * 2,
+  m_WeekRect = CFX_RectF(m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN,
+                         m_HeadRect.bottom(),
+                         m_ClientRect.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
+                         m_szCell.height + MONTHCAL_VMARGIN * 2);
+  m_LBtnRect = CFX_RectF(m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN,
+                         m_ClientRect.top + MONTHCAL_HEADER_BTN_VMARGIN,
+                         m_szCell.width, m_szCell.width);
+  m_RBtnRect = CFX_RectF(m_ClientRect.left + m_ClientRect.width -
+                             MONTHCAL_HEADER_BTN_HMARGIN - m_szCell.width,
+                         m_ClientRect.top + MONTHCAL_HEADER_BTN_VMARGIN,
+                         m_szCell.width, m_szCell.width);
+  m_HSepRect = CFX_RectF(
+      m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN,
+      m_WeekRect.bottom() - MONTHCAL_VMARGIN,
+      m_ClientRect.width - (MONTHCAL_HEADER_BTN_HMARGIN + MONTHCAL_HMARGIN) * 2,
       MONTHCAL_HSEP_HEIGHT);
-  m_rtDates = CFX_RectF(m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN,
-                        m_rtWeek.bottom(),
-                        m_rtClient.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
-                        m_szCell.height * (MONTHCAL_ROWS - 3) +
-                            MONTHCAL_VMARGIN * (MONTHCAL_ROWS - 3) * 2);
+  m_DatesRect = CFX_RectF(m_ClientRect.left + MONTHCAL_HEADER_BTN_HMARGIN,
+                          m_WeekRect.bottom(),
+                          m_ClientRect.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
+                          m_szCell.height * (MONTHCAL_ROWS - 3) +
+                              MONTHCAL_VMARGIN * (MONTHCAL_ROWS - 3) * 2);
 
   CalDateItem();
 }
@@ -498,8 +498,8 @@
 void CFWL_MonthCalendar::CalDateItem() {
   bool bNewWeek = false;
   int32_t iWeekOfMonth = 0;
-  float fLeft = m_rtDates.left;
-  float fTop = m_rtDates.top;
+  float fLeft = m_DatesRect.left;
+  float fTop = m_DatesRect.top;
   for (const auto& pDateInfo : m_arrDates) {
     if (bNewWeek) {
       iWeekOfMonth++;
@@ -721,32 +721,32 @@
 }
 
 void CFWL_MonthCalendar::OnLButtonDown(CFWL_MessageMouse* pMsg) {
-  if (m_rtLBtn.Contains(pMsg->m_pos)) {
+  if (m_LBtnRect.Contains(pMsg->m_pos)) {
     m_iLBtnPartStates = CFWL_PartState_Pressed;
     PrevMonth();
-    RepaintRect(m_rtClient);
-  } else if (m_rtRBtn.Contains(pMsg->m_pos)) {
+    RepaintRect(m_ClientRect);
+  } else if (m_RBtnRect.Contains(pMsg->m_pos)) {
     m_iRBtnPartStates |= CFWL_PartState_Pressed;
     NextMonth();
-    RepaintRect(m_rtClient);
-  } else if (m_rtToday.Contains(pMsg->m_pos)) {
+    RepaintRect(m_ClientRect);
+  } else if (m_TodayRect.Contains(pMsg->m_pos)) {
     JumpToToday();
-    RepaintRect(m_rtClient);
+    RepaintRect(m_ClientRect);
   }
 }
 
 void CFWL_MonthCalendar::OnLButtonUp(CFWL_MessageMouse* pMsg) {
-  if (m_rtLBtn.Contains(pMsg->m_pos)) {
+  if (m_LBtnRect.Contains(pMsg->m_pos)) {
     m_iLBtnPartStates = 0;
-    RepaintRect(m_rtLBtn);
+    RepaintRect(m_LBtnRect);
     return;
   }
-  if (m_rtRBtn.Contains(pMsg->m_pos)) {
+  if (m_RBtnRect.Contains(pMsg->m_pos)) {
     m_iRBtnPartStates = 0;
-    RepaintRect(m_rtRBtn);
+    RepaintRect(m_RBtnRect);
     return;
   }
-  if (m_rtToday.Contains(pMsg->m_pos))
+  if (m_TodayRect.Contains(pMsg->m_pos))
     return;
 
   int32_t iOldSel = 0;
@@ -772,7 +772,7 @@
 void CFWL_MonthCalendar::OnMouseMove(CFWL_MessageMouse* pMsg) {
   bool bRepaint = false;
   CFX_RectF rtInvalidate;
-  if (m_rtDates.Contains(pMsg->m_pos)) {
+  if (m_DatesRect.Contains(pMsg->m_pos)) {
     int32_t iHover = GetDayAtPoint(pMsg->m_pos);
     bRepaint = m_iHovered != iHover;
     if (bRepaint) {
diff --git a/xfa/fwl/cfwl_monthcalendar.h b/xfa/fwl/cfwl_monthcalendar.h
index a00ea0f..8abd6e6 100644
--- a/xfa/fwl/cfwl_monthcalendar.h
+++ b/xfa/fwl/cfwl_monthcalendar.h
@@ -149,15 +149,15 @@
   void OnMouseLeave(CFWL_MessageMouse* pMsg);
 
   bool m_bInitialized = false;
-  CFX_RectF m_rtHead;
-  CFX_RectF m_rtWeek;
-  CFX_RectF m_rtLBtn;
-  CFX_RectF m_rtRBtn;
-  CFX_RectF m_rtDates;
-  CFX_RectF m_rtHSep;
-  CFX_RectF m_rtHeadText;
-  CFX_RectF m_rtToday;
-  CFX_RectF m_rtTodayFlag;
+  CFX_RectF m_HeadRect;
+  CFX_RectF m_WeekRect;
+  CFX_RectF m_LBtnRect;
+  CFX_RectF m_RBtnRect;
+  CFX_RectF m_DatesRect;
+  CFX_RectF m_HSepRect;
+  CFX_RectF m_HeadTextRect;
+  CFX_RectF m_TodayRect;
+  CFX_RectF m_TodayFlagRect;
   WideString m_wsHead;
   WideString m_wsToday;
   std::vector<std::unique_ptr<DATEINFO>> m_arrDates;
@@ -175,7 +175,7 @@
   CFX_SizeF m_szCell;
   CFX_SizeF m_szToday;
   std::vector<int32_t> m_arrSelDays;
-  CFX_RectF m_rtClient;
+  CFX_RectF m_ClientRect;
 };
 
 #endif  // XFA_FWL_CFWL_MONTHCALENDAR_H_
diff --git a/xfa/fwl/cfwl_picturebox.cpp b/xfa/fwl/cfwl_picturebox.cpp
index 6e90765..287195c 100644
--- a/xfa/fwl/cfwl_picturebox.cpp
+++ b/xfa/fwl/cfwl_picturebox.cpp
@@ -26,7 +26,7 @@
   if (!m_pProperties->m_pThemeProvider)
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
 
-  m_rtClient = GetClientRect();
+  m_ClientRect = GetClientRect();
 }
 
 void CFWL_PictureBox::DrawWidget(CXFA_Graphics* pGraphics,
diff --git a/xfa/fwl/cfwl_picturebox.h b/xfa/fwl/cfwl_picturebox.h
index 11689d2..e7e0a05 100644
--- a/xfa/fwl/cfwl_picturebox.h
+++ b/xfa/fwl/cfwl_picturebox.h
@@ -26,8 +26,8 @@
                     const CFX_Matrix& matrix) override;
 
  private:
-  CFX_RectF m_rtClient;
-  CFX_RectF m_rtImage;
+  CFX_RectF m_ClientRect;
+  CFX_RectF m_ImageRect;
   CFX_Matrix m_matrix;
 };
 
diff --git a/xfa/fwl/cfwl_pushbutton.cpp b/xfa/fwl/cfwl_pushbutton.cpp
index b1ff8e0..2cde79c 100644
--- a/xfa/fwl/cfwl_pushbutton.cpp
+++ b/xfa/fwl/cfwl_pushbutton.cpp
@@ -44,8 +44,8 @@
   if (!m_pProperties->m_pThemeProvider)
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
 
-  m_rtClient = GetClientRect();
-  m_rtCaption = m_rtClient;
+  m_ClientRect = GetClientRect();
+  m_CaptionRect = m_ClientRect;
 }
 
 void CFWL_PushButton::DrawWidget(CXFA_Graphics* pGraphics,
@@ -72,9 +72,9 @@
   param.m_pGraphics = pGraphics;
   if (pMatrix)
     param.m_matrix.Concat(*pMatrix);
-  param.m_PartRect = m_rtClient;
+  param.m_PartRect = m_ClientRect;
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused)
-    param.m_pRtData = &m_rtCaption;
+    param.m_pRtData = &m_CaptionRect;
   pTheme->DrawBackground(param);
 }
 
@@ -149,36 +149,36 @@
   else
     m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
 
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_PushButton::OnLButtonDown(CFWL_MessageMouse* pMsg) {
   m_bBtnDown = true;
   m_pProperties->m_dwStates |= FWL_STATE_PSB_Hovered;
   m_pProperties->m_dwStates |= FWL_STATE_PSB_Pressed;
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_PushButton::OnLButtonUp(CFWL_MessageMouse* pMsg) {
   m_bBtnDown = false;
-  if (m_rtClient.Contains(pMsg->m_pos)) {
+  if (m_ClientRect.Contains(pMsg->m_pos)) {
     m_pProperties->m_dwStates &= ~FWL_STATE_PSB_Pressed;
     m_pProperties->m_dwStates |= FWL_STATE_PSB_Hovered;
   } else {
     m_pProperties->m_dwStates &= ~FWL_STATE_PSB_Hovered;
     m_pProperties->m_dwStates &= ~FWL_STATE_PSB_Pressed;
   }
-  if (m_rtClient.Contains(pMsg->m_pos)) {
+  if (m_ClientRect.Contains(pMsg->m_pos)) {
     CFWL_Event wmClick(CFWL_Event::Type::Click, this);
     DispatchEvent(&wmClick);
   }
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_PushButton::OnMouseMove(CFWL_MessageMouse* pMsg) {
   bool bRepaint = false;
   if (m_bBtnDown) {
-    if (m_rtClient.Contains(pMsg->m_pos)) {
+    if (m_ClientRect.Contains(pMsg->m_pos)) {
       if ((m_pProperties->m_dwStates & FWL_STATE_PSB_Pressed) == 0) {
         m_pProperties->m_dwStates |= FWL_STATE_PSB_Pressed;
         bRepaint = true;
@@ -198,7 +198,7 @@
       }
     }
   } else {
-    if (!m_rtClient.Contains(pMsg->m_pos))
+    if (!m_ClientRect.Contains(pMsg->m_pos))
       return;
     if ((m_pProperties->m_dwStates & FWL_STATE_PSB_Hovered) == 0) {
       m_pProperties->m_dwStates |= FWL_STATE_PSB_Hovered;
@@ -206,14 +206,14 @@
     }
   }
   if (bRepaint)
-    RepaintRect(m_rtClient);
+    RepaintRect(m_ClientRect);
 }
 
 void CFWL_PushButton::OnMouseLeave(CFWL_MessageMouse* pMsg) {
   m_bBtnDown = false;
   m_pProperties->m_dwStates &= ~FWL_STATE_PSB_Hovered;
   m_pProperties->m_dwStates &= ~FWL_STATE_PSB_Pressed;
-  RepaintRect(m_rtClient);
+  RepaintRect(m_ClientRect);
 }
 
 void CFWL_PushButton::OnKeyDown(CFWL_MessageKey* pMsg) {
diff --git a/xfa/fwl/cfwl_pushbutton.h b/xfa/fwl/cfwl_pushbutton.h
index 925dbb6..659217a 100644
--- a/xfa/fwl/cfwl_pushbutton.h
+++ b/xfa/fwl/cfwl_pushbutton.h
@@ -45,8 +45,8 @@
   void OnKeyDown(CFWL_MessageKey* pMsg);
 
   bool m_bBtnDown = false;
-  CFX_RectF m_rtClient;
-  CFX_RectF m_rtCaption;
+  CFX_RectF m_ClientRect;
+  CFX_RectF m_CaptionRect;
 };
 
 #endif  // XFA_FWL_CFWL_PUSHBUTTON_H_
diff --git a/xfa/fwl/cfwl_scrollbar.cpp b/xfa/fwl/cfwl_scrollbar.cpp
index 580bb31..e022e85 100644
--- a/xfa/fwl/cfwl_scrollbar.cpp
+++ b/xfa/fwl/cfwl_scrollbar.cpp
@@ -68,9 +68,9 @@
 
 void CFWL_ScrollBar::SetTrackPos(float fTrackPos) {
   m_fTrackPos = fTrackPos;
-  m_rtThumb = CalcThumbButtonRect(m_rtThumb);
-  m_rtMinTrack = CalcMinTrackRect(m_rtMinTrack);
-  m_rtMaxTrack = CalcMaxTrackRect(m_rtMaxTrack);
+  m_ThumbRect = CalcThumbButtonRect(m_ThumbRect);
+  m_MinTrackRect = CalcMinTrackRect(m_MinTrackRect);
+  m_MaxTrackRect = CalcMaxTrackRect(m_MaxTrackRect);
 }
 
 bool CFWL_ScrollBar::DoScroll(CFWL_EventScroll::Code dwCode, float fPos) {
@@ -91,7 +91,7 @@
                          : (bLower ? m_iMinTrackState : m_iMaxTrackState);
   param.m_pGraphics = pGraphics;
   param.m_matrix.Concat(*pMatrix);
-  param.m_PartRect = bLower ? m_rtMinTrack : m_rtMaxTrack;
+  param.m_PartRect = bLower ? m_MinTrackRect : m_MaxTrackRect;
   pTheme->DrawBackground(param);
 }
 
@@ -107,7 +107,7 @@
                          : (bMinBtn ? m_iMinButtonState : m_iMaxButtonState);
   param.m_pGraphics = pGraphics;
   param.m_matrix.Concat(*pMatrix);
-  param.m_PartRect = bMinBtn ? m_rtMinBtn : m_rtMaxBtn;
+  param.m_PartRect = bMinBtn ? m_MinBtnRect : m_MaxBtnRect;
   if (param.m_PartRect.height > 0 && param.m_PartRect.width > 0)
     pTheme->DrawBackground(param);
 }
@@ -123,24 +123,24 @@
                          : m_iThumbButtonState;
   param.m_pGraphics = pGraphics;
   param.m_matrix.Concat(*pMatrix);
-  param.m_PartRect = m_rtThumb;
+  param.m_PartRect = m_ThumbRect;
   pTheme->DrawBackground(param);
 }
 
 void CFWL_ScrollBar::Layout() {
-  m_rtClient = GetClientRect();
+  m_ClientRect = GetClientRect();
 
   CalcButtonLen();
-  m_rtMinBtn = CalcMinButtonRect();
-  m_rtMaxBtn = CalcMaxButtonRect();
-  m_rtThumb = CalcThumbButtonRect(m_rtThumb);
-  m_rtMinTrack = CalcMinTrackRect(m_rtMinTrack);
-  m_rtMaxTrack = CalcMaxTrackRect(m_rtMaxTrack);
+  m_MinBtnRect = CalcMinButtonRect();
+  m_MaxBtnRect = CalcMaxButtonRect();
+  m_ThumbRect = CalcThumbButtonRect(m_ThumbRect);
+  m_MinTrackRect = CalcMinTrackRect(m_MinTrackRect);
+  m_MaxTrackRect = CalcMaxTrackRect(m_MaxTrackRect);
 }
 
 void CFWL_ScrollBar::CalcButtonLen() {
-  m_fButtonLen = IsVertical() ? m_rtClient.width : m_rtClient.height;
-  float fLength = IsVertical() ? m_rtClient.height : m_rtClient.width;
+  m_fButtonLen = IsVertical() ? m_ClientRect.width : m_ClientRect.height;
+  float fLength = IsVertical() ? m_ClientRect.height : m_ClientRect.width;
   if (fLength < m_fButtonLen * 2) {
     m_fButtonLen = fLength / 2;
     m_bMinSize = true;
@@ -151,17 +151,17 @@
 
 CFX_RectF CFWL_ScrollBar::CalcMinButtonRect() {
   if (IsVertical())
-    return CFX_RectF(m_rtClient.TopLeft(), m_rtClient.width, m_fButtonLen);
-  return CFX_RectF(m_rtClient.TopLeft(), m_fButtonLen, m_rtClient.height);
+    return CFX_RectF(m_ClientRect.TopLeft(), m_ClientRect.width, m_fButtonLen);
+  return CFX_RectF(m_ClientRect.TopLeft(), m_fButtonLen, m_ClientRect.height);
 }
 
 CFX_RectF CFWL_ScrollBar::CalcMaxButtonRect() {
   if (IsVertical()) {
-    return CFX_RectF(m_rtClient.left, m_rtClient.bottom() - m_fButtonLen,
-                     m_rtClient.width, m_fButtonLen);
+    return CFX_RectF(m_ClientRect.left, m_ClientRect.bottom() - m_fButtonLen,
+                     m_ClientRect.width, m_fButtonLen);
   }
-  return CFX_RectF(m_rtClient.right() - m_fButtonLen, m_rtClient.top,
-                   m_fButtonLen, m_rtClient.height);
+  return CFX_RectF(m_ClientRect.right() - m_fButtonLen, m_ClientRect.top,
+                   m_fButtonLen, m_ClientRect.height);
 }
 
 CFX_RectF CFWL_ScrollBar::CalcThumbButtonRect(const CFX_RectF& rtThumb) {
@@ -178,13 +178,14 @@
   float fRange = m_fRangeMax - m_fRangeMin;
   if (fRange < 0) {
     if (IsVertical()) {
-      return CFX_RectF(m_rtClient.left, m_rtMaxBtn.bottom(), m_rtClient.width,
-                       0);
+      return CFX_RectF(m_ClientRect.left, m_MaxBtnRect.bottom(),
+                       m_ClientRect.width, 0);
     }
-    return CFX_RectF(m_rtMaxBtn.right(), m_rtClient.top, 0, m_rtClient.height);
+    return CFX_RectF(m_MaxBtnRect.right(), m_ClientRect.top, 0,
+                     m_ClientRect.height);
   }
 
-  CFX_RectF rtClient = m_rtClient;
+  CFX_RectF rtClient = m_ClientRect;
   float fLength = IsVertical() ? rtClient.height : rtClient.width;
   float fSize = m_fButtonLen;
   fLength -= fSize * 2.0f;
@@ -222,14 +223,14 @@
     return rect;
   }
 
-  rect.left = m_rtClient.left;
-  rect.top = m_rtClient.top;
+  rect.left = m_ClientRect.left;
+  rect.top = m_ClientRect.top;
   if (IsVertical()) {
-    rect.width = m_rtClient.width;
-    rect.height = (m_rtThumb.top + m_rtThumb.bottom()) / 2;
+    rect.width = m_ClientRect.width;
+    rect.height = (m_ThumbRect.top + m_ThumbRect.bottom()) / 2;
   } else {
-    rect.width = (m_rtThumb.left + m_rtThumb.right()) / 2;
-    rect.height = m_rtClient.height;
+    rect.width = (m_ThumbRect.left + m_ThumbRect.right()) / 2;
+    rect.height = m_ClientRect.height;
   }
   return rect;
 }
@@ -239,14 +240,14 @@
     return CFX_RectF(rtMaxRect.TopLeft(), 0, 0);
 
   if (IsVertical()) {
-    float iy = (m_rtThumb.top + m_rtThumb.bottom()) / 2;
-    return CFX_RectF(m_rtClient.left, iy, m_rtClient.width,
-                     m_rtClient.bottom() - iy);
+    float iy = (m_ThumbRect.top + m_ThumbRect.bottom()) / 2;
+    return CFX_RectF(m_ClientRect.left, iy, m_ClientRect.width,
+                     m_ClientRect.bottom() - iy);
   }
 
-  float ix = (m_rtThumb.left + m_rtThumb.right()) / 2;
-  return CFX_RectF(ix, m_rtClient.top, m_rtClient.height - ix,
-                   m_rtClient.height);
+  float ix = (m_ThumbRect.left + m_ThumbRect.right()) / 2;
+  return CFX_RectF(ix, m_ClientRect.top, m_ClientRect.height - ix,
+                   m_ClientRect.height);
 }
 
 float CFWL_ScrollBar::GetTrackPointPos(const CFX_PointF& point) {
@@ -256,10 +257,10 @@
 
   if (IsVertical()) {
     fPos = fRange * diff.y /
-           (m_rtMaxBtn.top - m_rtMinBtn.bottom() - m_rtThumb.height);
+           (m_MaxBtnRect.top - m_MinBtnRect.bottom() - m_ThumbRect.height);
   } else {
     fPos = fRange * diff.x /
-           (m_rtMaxBtn.left - m_rtMinBtn.right() - m_rtThumb.width);
+           (m_MaxBtnRect.left - m_MinBtnRect.right() - m_ThumbRect.width);
   }
 
   fPos += m_fLastTrackPos;
@@ -277,11 +278,11 @@
   }
   if (m_iMinTrackState == CFWL_PartState_Pressed) {
     DoScroll(CFWL_EventScroll::Code::PageBackward, m_fTrackPos);
-    return m_rtThumb.Contains(m_cpTrackPoint);
+    return m_ThumbRect.Contains(m_cpTrackPoint);
   }
   if (m_iMaxTrackState == CFWL_PartState_Pressed) {
     DoScroll(CFWL_EventScroll::Code::PageForward, m_fTrackPos);
-    return m_rtThumb.Contains(m_cpTrackPoint);
+    return m_ThumbRect.Contains(m_cpTrackPoint);
   }
   if (m_iMouseWheel) {
     CFWL_EventScroll::Code dwCode = m_iMouseWheel < 0
@@ -343,16 +344,16 @@
 
   m_cpTrackPoint = point;
   m_fLastTrackPos = m_fTrackPos;
-  if (m_rtMinBtn.Contains(point))
-    DoMouseDown(0, m_rtMinBtn, m_iMinButtonState, point);
-  else if (m_rtThumb.Contains(point))
-    DoMouseDown(1, m_rtThumb, m_iThumbButtonState, point);
-  else if (m_rtMaxBtn.Contains(point))
-    DoMouseDown(2, m_rtMaxBtn, m_iMaxButtonState, point);
-  else if (m_rtMinTrack.Contains(point))
-    DoMouseDown(3, m_rtMinTrack, m_iMinTrackState, point);
+  if (m_MinBtnRect.Contains(point))
+    DoMouseDown(0, m_MinBtnRect, m_iMinButtonState, point);
+  else if (m_ThumbRect.Contains(point))
+    DoMouseDown(1, m_ThumbRect, m_iThumbButtonState, point);
+  else if (m_MaxBtnRect.Contains(point))
+    DoMouseDown(2, m_MaxBtnRect, m_iMaxButtonState, point);
+  else if (m_MinTrackRect.Contains(point))
+    DoMouseDown(3, m_MinTrackRect, m_iMinTrackState, point);
   else
-    DoMouseDown(4, m_rtMaxTrack, m_iMaxTrackState, point);
+    DoMouseDown(4, m_MaxTrackRect, m_iMaxTrackState, point);
 
   if (!SendEvent()) {
     m_pTimer = pdfium::MakeUnique<CFX_Timer>(
@@ -364,28 +365,28 @@
 void CFWL_ScrollBar::OnLButtonUp(const CFX_PointF& point) {
   m_pTimer.reset();
   m_bMouseDown = false;
-  DoMouseUp(0, m_rtMinBtn, m_iMinButtonState, point);
-  DoMouseUp(1, m_rtThumb, m_iThumbButtonState, point);
-  DoMouseUp(2, m_rtMaxBtn, m_iMaxButtonState, point);
-  DoMouseUp(3, m_rtMinTrack, m_iMinTrackState, point);
-  DoMouseUp(4, m_rtMaxTrack, m_iMaxTrackState, point);
+  DoMouseUp(0, m_MinBtnRect, m_iMinButtonState, point);
+  DoMouseUp(1, m_ThumbRect, m_iThumbButtonState, point);
+  DoMouseUp(2, m_MaxBtnRect, m_iMaxButtonState, point);
+  DoMouseUp(3, m_MinTrackRect, m_iMinTrackState, point);
+  DoMouseUp(4, m_MaxTrackRect, m_iMaxTrackState, point);
   SetGrab(false);
 }
 
 void CFWL_ScrollBar::OnMouseMove(const CFX_PointF& point) {
-  DoMouseMove(0, m_rtMinBtn, m_iMinButtonState, point);
-  DoMouseMove(1, m_rtThumb, m_iThumbButtonState, point);
-  DoMouseMove(2, m_rtMaxBtn, m_iMaxButtonState, point);
-  DoMouseMove(3, m_rtMinTrack, m_iMinTrackState, point);
-  DoMouseMove(4, m_rtMaxTrack, m_iMaxTrackState, point);
+  DoMouseMove(0, m_MinBtnRect, m_iMinButtonState, point);
+  DoMouseMove(1, m_ThumbRect, m_iThumbButtonState, point);
+  DoMouseMove(2, m_MaxBtnRect, m_iMaxButtonState, point);
+  DoMouseMove(3, m_MinTrackRect, m_iMinTrackState, point);
+  DoMouseMove(4, m_MaxTrackRect, m_iMaxTrackState, point);
 }
 
 void CFWL_ScrollBar::OnMouseLeave() {
-  DoMouseLeave(0, m_rtMinBtn, m_iMinButtonState);
-  DoMouseLeave(1, m_rtThumb, m_iThumbButtonState);
-  DoMouseLeave(2, m_rtMaxBtn, m_iMaxButtonState);
-  DoMouseLeave(3, m_rtMinTrack, m_iMinTrackState);
-  DoMouseLeave(4, m_rtMaxTrack, m_iMaxTrackState);
+  DoMouseLeave(0, m_MinBtnRect, m_iMinButtonState);
+  DoMouseLeave(1, m_ThumbRect, m_iThumbButtonState);
+  DoMouseLeave(2, m_MaxBtnRect, m_iMaxButtonState);
+  DoMouseLeave(3, m_MinTrackRect, m_iMinTrackState);
+  DoMouseLeave(4, m_MaxTrackRect, m_iMaxTrackState);
 }
 
 void CFWL_ScrollBar::OnMouseWheel(const CFX_Vector& delta) {
diff --git a/xfa/fwl/cfwl_scrollbar.h b/xfa/fwl/cfwl_scrollbar.h
index 5657c90..42569b3 100644
--- a/xfa/fwl/cfwl_scrollbar.h
+++ b/xfa/fwl/cfwl_scrollbar.h
@@ -122,12 +122,12 @@
   float m_fButtonLen = 0.0f;
   bool m_bMouseDown = false;
   bool m_bMinSize = false;
-  CFX_RectF m_rtClient;
-  CFX_RectF m_rtThumb;
-  CFX_RectF m_rtMinBtn;
-  CFX_RectF m_rtMaxBtn;
-  CFX_RectF m_rtMinTrack;
-  CFX_RectF m_rtMaxTrack;
+  CFX_RectF m_ClientRect;
+  CFX_RectF m_ThumbRect;
+  CFX_RectF m_MinBtnRect;
+  CFX_RectF m_MaxBtnRect;
+  CFX_RectF m_MinTrackRect;
+  CFX_RectF m_MaxTrackRect;
   std::unique_ptr<CFX_Timer> m_pTimer;
 };
 
diff --git a/xfa/fwl/cfwl_widget.cpp b/xfa/fwl/cfwl_widget.cpp
index d5f5639..0507abd 100644
--- a/xfa/fwl/cfwl_widget.cpp
+++ b/xfa/fwl/cfwl_widget.cpp
@@ -59,7 +59,7 @@
 }
 
 CFX_RectF CFWL_Widget::GetWidgetRect() {
-  return m_pProperties->m_rtWidget;
+  return m_pProperties->m_WidgetRect;
 }
 
 void CFWL_Widget::InflateWidgetRect(CFX_RectF& rect) {
@@ -71,7 +71,7 @@
 }
 
 void CFWL_Widget::SetWidgetRect(const CFX_RectF& rect) {
-  m_pProperties->m_rtWidget = rect;
+  m_pProperties->m_WidgetRect = rect;
 }
 
 CFX_RectF CFWL_Widget::GetClientRect() {
@@ -209,8 +209,8 @@
 }
 
 CFX_RectF CFWL_Widget::GetEdgeRect() const {
-  CFX_RectF rtEdge(0, 0, m_pProperties->m_rtWidget.width,
-                   m_pProperties->m_rtWidget.height);
+  CFX_RectF rtEdge(0, 0, m_pProperties->m_WidgetRect.width,
+                   m_pProperties->m_WidgetRect.height);
   if (HasBorder())
     rtEdge.Deflate(GetCXBorderSize(), GetCYBorderSize());
   return rtEdge;
@@ -227,8 +227,8 @@
 }
 
 CFX_RectF CFWL_Widget::GetRelativeRect() const {
-  return CFX_RectF(0, 0, m_pProperties->m_rtWidget.width,
-                   m_pProperties->m_rtWidget.height);
+  return CFX_RectF(0, 0, m_pProperties->m_WidgetRect.width,
+                   m_pProperties->m_WidgetRect.height);
 }
 
 IFWL_ThemeProvider* CFWL_Widget::GetAvailableTheme() const {
@@ -347,8 +347,8 @@
     return CFX_SizeF();
 
   CFWL_WidgetMgr* pWidgetMgr = GetOwnerApp()->GetWidgetMgr();
-  CFX_SizeF szRet(m_pProperties->m_rtWidget.left,
-                  m_pProperties->m_rtWidget.top);
+  CFX_SizeF szRet(m_pProperties->m_WidgetRect.left,
+                  m_pProperties->m_WidgetRect.top);
 
   CFWL_Widget* pDstWidget = GetParent();
   while (pDstWidget && pDstWidget != pParent) {
diff --git a/xfa/fwl/cfwl_widgetproperties.h b/xfa/fwl/cfwl_widgetproperties.h
index 4148833..977f846 100644
--- a/xfa/fwl/cfwl_widgetproperties.h
+++ b/xfa/fwl/cfwl_widgetproperties.h
@@ -23,7 +23,7 @@
   uint32_t m_dwStyles = FWL_WGTSTYLE_Child;
   uint32_t m_dwStyleExes = 0;
   uint32_t m_dwStates = 0;
-  CFX_RectF m_rtWidget;
+  CFX_RectF m_WidgetRect;
   UnownedPtr<IFWL_ThemeProvider> m_pThemeProvider;
   CFWL_Widget* m_pParent = nullptr;  // Raw, this class owned by node in tree.
 };
diff --git a/xfa/fxfa/cxfa_ffbarcode.cpp b/xfa/fxfa/cxfa_ffbarcode.cpp
index 2cbe9d2..c6a940e 100644
--- a/xfa/fxfa/cxfa_ffbarcode.cpp
+++ b/xfa/fxfa/cxfa_ffbarcode.cpp
@@ -173,7 +173,7 @@
   mtRotate.Concat(matrix);
 
   CXFA_FFWidget::RenderWidget(pGS, mtRotate, highlight);
-  DrawBorder(pGS, m_pNode->GetUIBorder(), m_rtUI, mtRotate);
+  DrawBorder(pGS, m_pNode->GetUIBorder(), m_UIRect, mtRotate);
   RenderCaption(pGS, &mtRotate);
   CFX_RectF rtWidget = GetNormalWidget()->GetWidgetRect();
 
diff --git a/xfa/fxfa/cxfa_ffcheckbutton.cpp b/xfa/fxfa/cxfa_ffcheckbutton.cpp
index 5552cf0..64f2b1c 100644
--- a/xfa/fxfa/cxfa_ffcheckbutton.cpp
+++ b/xfa/fxfa/cxfa_ffcheckbutton.cpp
@@ -106,7 +106,7 @@
   float fCapReserve = 0;
   CXFA_Caption* caption = m_pNode->GetCaptionIfExists();
   if (caption && caption->IsVisible()) {
-    m_rtCaption = rtWidget;
+    m_CaptionRect = rtWidget;
     iCapPlacement = caption->GetPlacementType();
     fCapReserve = caption->GetReserve();
     if (fCapReserve <= 0) {
@@ -127,35 +127,35 @@
     iVertAlign = para->GetVerticalAlign();
   }
 
-  m_rtUI = rtWidget;
+  m_UIRect = rtWidget;
   CXFA_Margin* captionMargin = caption ? caption->GetMarginIfExists() : nullptr;
   switch (iCapPlacement) {
     case XFA_AttributeValue::Left: {
-      m_rtCaption.width = fCapReserve;
+      m_CaptionRect.width = fCapReserve;
       CapLeftRightPlacement(captionMargin);
-      m_rtUI.width -= fCapReserve;
-      m_rtUI.left += fCapReserve;
+      m_UIRect.width -= fCapReserve;
+      m_UIRect.left += fCapReserve;
       break;
     }
     case XFA_AttributeValue::Top: {
-      m_rtCaption.height = fCapReserve;
-      XFA_RectWithoutMargin(&m_rtCaption, captionMargin);
-      m_rtUI.height -= fCapReserve;
-      m_rtUI.top += fCapReserve;
+      m_CaptionRect.height = fCapReserve;
+      XFA_RectWithoutMargin(&m_CaptionRect, captionMargin);
+      m_UIRect.height -= fCapReserve;
+      m_UIRect.top += fCapReserve;
       break;
     }
     case XFA_AttributeValue::Right: {
-      m_rtCaption.left = m_rtCaption.right() - fCapReserve;
-      m_rtCaption.width = fCapReserve;
+      m_CaptionRect.left = m_CaptionRect.right() - fCapReserve;
+      m_CaptionRect.width = fCapReserve;
       CapLeftRightPlacement(captionMargin);
-      m_rtUI.width -= fCapReserve;
+      m_UIRect.width -= fCapReserve;
       break;
     }
     case XFA_AttributeValue::Bottom: {
-      m_rtCaption.top = m_rtCaption.bottom() - fCapReserve;
-      m_rtCaption.height = fCapReserve;
-      XFA_RectWithoutMargin(&m_rtCaption, captionMargin);
-      m_rtUI.height -= fCapReserve;
+      m_CaptionRect.top = m_CaptionRect.bottom() - fCapReserve;
+      m_CaptionRect.height = fCapReserve;
+      XFA_RectWithoutMargin(&m_CaptionRect, captionMargin);
+      m_UIRect.height -= fCapReserve;
       break;
     }
     case XFA_AttributeValue::Inline:
@@ -166,26 +166,26 @@
   }
 
   if (iHorzAlign == XFA_AttributeValue::Center)
-    m_rtUI.left += (m_rtUI.width - fCheckSize) / 2;
+    m_UIRect.left += (m_UIRect.width - fCheckSize) / 2;
   else if (iHorzAlign == XFA_AttributeValue::Right)
-    m_rtUI.left = m_rtUI.right() - fCheckSize;
+    m_UIRect.left = m_UIRect.right() - fCheckSize;
 
   if (iVertAlign == XFA_AttributeValue::Middle)
-    m_rtUI.top += (m_rtUI.height - fCheckSize) / 2;
+    m_UIRect.top += (m_UIRect.height - fCheckSize) / 2;
   else if (iVertAlign == XFA_AttributeValue::Bottom)
-    m_rtUI.top = m_rtUI.bottom() - fCheckSize;
+    m_UIRect.top = m_UIRect.bottom() - fCheckSize;
 
-  m_rtUI.width = fCheckSize;
-  m_rtUI.height = fCheckSize;
+  m_UIRect.width = fCheckSize;
+  m_UIRect.height = fCheckSize;
   AddUIMargin(iCapPlacement);
-  m_rtCheckBox = m_rtUI;
+  m_CheckBoxRect = m_UIRect;
   CXFA_Border* borderUI = m_pNode->GetUIBorder();
   if (borderUI) {
     CXFA_Margin* borderMargin = borderUI->GetMarginIfExists();
-    XFA_RectWithoutMargin(&m_rtUI, borderMargin);
+    XFA_RectWithoutMargin(&m_UIRect, borderMargin);
   }
 
-  m_rtUI.Normalize();
+  m_UIRect.Normalize();
   LayoutCaption();
   SetFWLRect();
   if (GetNormalWidget())
@@ -196,36 +196,36 @@
 
 void CXFA_FFCheckButton::CapLeftRightPlacement(
     const CXFA_Margin* captionMargin) {
-  XFA_RectWithoutMargin(&m_rtCaption, captionMargin);
-  if (m_rtCaption.height < 0)
-    m_rtCaption.top += m_rtCaption.height;
-  if (m_rtCaption.width < 0) {
-    m_rtCaption.left += m_rtCaption.width;
-    m_rtCaption.width = -m_rtCaption.width;
+  XFA_RectWithoutMargin(&m_CaptionRect, captionMargin);
+  if (m_CaptionRect.height < 0)
+    m_CaptionRect.top += m_CaptionRect.height;
+  if (m_CaptionRect.width < 0) {
+    m_CaptionRect.left += m_CaptionRect.width;
+    m_CaptionRect.width = -m_CaptionRect.width;
   }
 }
 
 void CXFA_FFCheckButton::AddUIMargin(XFA_AttributeValue iCapPlacement) {
   CFX_RectF rtUIMargin = m_pNode->GetUIMargin();
-  m_rtUI.top -= rtUIMargin.top / 2 - rtUIMargin.height / 2;
+  m_UIRect.top -= rtUIMargin.top / 2 - rtUIMargin.height / 2;
 
   float fLeftAddRight = rtUIMargin.left + rtUIMargin.width;
   float fTopAddBottom = rtUIMargin.top + rtUIMargin.height;
-  if (m_rtUI.width < fLeftAddRight) {
+  if (m_UIRect.width < fLeftAddRight) {
     if (iCapPlacement == XFA_AttributeValue::Right ||
         iCapPlacement == XFA_AttributeValue::Left) {
-      m_rtUI.left -= fLeftAddRight - m_rtUI.width;
+      m_UIRect.left -= fLeftAddRight - m_UIRect.width;
     } else {
-      m_rtUI.left -= 2 * (fLeftAddRight - m_rtUI.width);
+      m_UIRect.left -= 2 * (fLeftAddRight - m_UIRect.width);
     }
-    m_rtUI.width += 2 * (fLeftAddRight - m_rtUI.width);
+    m_UIRect.width += 2 * (fLeftAddRight - m_UIRect.width);
   }
-  if (m_rtUI.height < fTopAddBottom) {
+  if (m_UIRect.height < fTopAddBottom) {
     if (iCapPlacement == XFA_AttributeValue::Right)
-      m_rtUI.left -= fTopAddBottom - m_rtUI.height;
+      m_UIRect.left -= fTopAddBottom - m_UIRect.height;
 
-    m_rtUI.top -= fTopAddBottom - m_rtUI.height;
-    m_rtUI.height += 2 * (fTopAddBottom - m_rtUI.height);
+    m_UIRect.top -= fTopAddBottom - m_UIRect.height;
+    m_UIRect.height += 2 * (fTopAddBottom - m_UIRect.height);
   }
 }
 
@@ -239,12 +239,12 @@
   mtRotate.Concat(matrix);
 
   CXFA_FFWidget::RenderWidget(pGS, mtRotate, highlight);
-  DrawBorderWithFlag(pGS, m_pNode->GetUIBorder(), m_rtUI, mtRotate,
+  DrawBorderWithFlag(pGS, m_pNode->GetUIBorder(), m_UIRect, mtRotate,
                      button_->IsRound());
   RenderCaption(pGS, &mtRotate);
   DrawHighlight(pGS, &mtRotate, highlight,
                 button_->IsRound() ? kRoundShape : kSquareShape);
-  CFX_Matrix mt(1, 0, 0, 1, m_rtCheckBox.left, m_rtCheckBox.top);
+  CFX_Matrix mt(1, 0, 0, 1, m_CheckBoxRect.left, m_CheckBoxRect.top);
   mt.Concat(mtRotate);
   GetApp()->GetFWLWidgetMgr()->OnDrawWidget(GetNormalWidget(), pGS, mt);
 }
diff --git a/xfa/fxfa/cxfa_ffcheckbutton.h b/xfa/fxfa/cxfa_ffcheckbutton.h
index 3e5a723..30d59fa 100644
--- a/xfa/fxfa/cxfa_ffcheckbutton.h
+++ b/xfa/fxfa/cxfa_ffcheckbutton.h
@@ -45,7 +45,7 @@
   XFA_CHECKSTATE FWLState2XFAState();
 
   UnownedPtr<IFWL_WidgetDelegate> m_pOldDelegate;
-  CFX_RectF m_rtCheckBox;
+  CFX_RectF m_CheckBoxRect;
   UnownedPtr<CXFA_CheckButton> const button_;
 };
 
diff --git a/xfa/fxfa/cxfa_fffield.cpp b/xfa/fxfa/cxfa_fffield.cpp
index 1b7afeb..a90b9aa 100644
--- a/xfa/fxfa/cxfa_fffield.cpp
+++ b/xfa/fxfa/cxfa_fffield.cpp
@@ -60,7 +60,7 @@
     case XFA_FFWidgetType::kImageEdit:
     case XFA_FFWidgetType::kSignature:
     case XFA_FFWidgetType::kChoiceList:
-      return GetRotateMatrix().TransformRect(m_rtUI);
+      return GetRotateMatrix().TransformRect(m_UIRect);
     default:
       return CFX_RectF();
   }
@@ -76,7 +76,7 @@
   mtRotate.Concat(matrix);
 
   CXFA_FFWidget::RenderWidget(pGS, mtRotate, highlight);
-  DrawBorder(pGS, m_pNode->GetUIBorder(), m_rtUI, mtRotate);
+  DrawBorder(pGS, m_pNode->GetUIBorder(), m_UIRect, mtRotate);
   RenderCaption(pGS, &mtRotate);
   DrawHighlight(pGS, &mtRotate, highlight, kSquareShape);
 
@@ -93,7 +93,7 @@
   if (highlight == kNoHighlight)
     return;
 
-  if (m_rtUI.IsEmpty() || !GetDoc()->GetXFADoc()->IsInteractive() ||
+  if (m_UIRect.IsEmpty() || !GetDoc()->GetXFADoc()->IsInteractive() ||
       !m_pNode->IsOpenAccess()) {
     return;
   }
@@ -102,9 +102,10 @@
       CXFA_GEColor(pDoc->GetDocEnvironment()->GetHighlightColor(pDoc)));
   CXFA_GEPath path;
   if (shape == kRoundShape)
-    path.AddEllipse(m_rtUI);
+    path.AddEllipse(m_UIRect);
   else
-    path.AddRectangle(m_rtUI.left, m_rtUI.top, m_rtUI.width, m_rtUI.height);
+    path.AddRectangle(m_UIRect.left, m_UIRect.top, m_UIRect.width,
+                      m_UIRect.height);
 
   pGS->FillPath(&path, FXFILL_WINDING, pMatrix);
 }
@@ -120,7 +121,8 @@
   pGS->SetLineWidth(0);
 
   CXFA_GEPath path;
-  path.AddRectangle(m_rtUI.left, m_rtUI.top, m_rtUI.width, m_rtUI.height);
+  path.AddRectangle(m_UIRect.left, m_UIRect.top, m_UIRect.width,
+                    m_UIRect.height);
   pGS->StrokePath(&path, pMatrix);
 }
 
@@ -170,7 +172,7 @@
     fScrollOffset = -(m_pNode->GetUIMargin().top);
 
   while (pPrev) {
-    fScrollOffset += pPrev->m_rtUI.height;
+    fScrollOffset += pPrev->m_UIRect.height;
     pItem = pPrev->GetLayoutItem()->GetPrev();
     pPrev = pItem ? ToField(pItem->GetFFWidget()) : nullptr;
   }
@@ -218,7 +220,7 @@
          GetLayoutItem()->GetPrev()) ||
         (iCapPlacement == XFA_AttributeValue::Bottom &&
          GetLayoutItem()->GetNext())) {
-      m_rtCaption = CFX_RectF();
+      m_CaptionRect = CFX_RectF();
     } else {
       fCapReserve = caption->GetReserve();
       if (iCapPlacement == XFA_AttributeValue::Top ||
@@ -229,16 +231,16 @@
       }
       CXFA_ContentLayoutItem* pItem = GetLayoutItem();
       if (!pItem->GetPrev() && !pItem->GetNext()) {
-        m_rtCaption = rtWidget;
+        m_CaptionRect = rtWidget;
       } else {
         pItem = pItem->GetFirst();
-        m_rtCaption = pItem->GetRect(false);
+        m_CaptionRect = pItem->GetRect(false);
         pItem = pItem->GetNext();
         while (pItem) {
-          m_rtCaption.height += pItem->GetRect(false).Height();
+          m_CaptionRect.height += pItem->GetRect(false).Height();
           pItem = pItem->GetNext();
         }
-        XFA_RectWithoutMargin(&m_rtCaption, margin);
+        XFA_RectWithoutMargin(&m_CaptionRect, margin);
       }
 
       CXFA_TextLayout* pCapTextLayout = m_pNode->GetCaptionTextLayout();
@@ -256,35 +258,35 @@
     }
   }
 
-  m_rtUI = rtWidget;
+  m_UIRect = rtWidget;
   CXFA_Margin* capMargin = caption ? caption->GetMarginIfExists() : nullptr;
   switch (iCapPlacement) {
     case XFA_AttributeValue::Left: {
-      m_rtCaption.width = fCapReserve;
+      m_CaptionRect.width = fCapReserve;
       CapLeftRightPlacement(capMargin, rtWidget, iCapPlacement);
-      m_rtUI.width -= fCapReserve;
-      m_rtUI.left += fCapReserve;
+      m_UIRect.width -= fCapReserve;
+      m_UIRect.left += fCapReserve;
       break;
     }
     case XFA_AttributeValue::Top: {
-      m_rtCaption.height = fCapReserve;
+      m_CaptionRect.height = fCapReserve;
       CapTopBottomPlacement(capMargin, rtWidget, iCapPlacement);
-      m_rtUI.top += fCapReserve;
-      m_rtUI.height -= fCapReserve;
+      m_UIRect.top += fCapReserve;
+      m_UIRect.height -= fCapReserve;
       break;
     }
     case XFA_AttributeValue::Right: {
-      m_rtCaption.left = m_rtCaption.right() - fCapReserve;
-      m_rtCaption.width = fCapReserve;
+      m_CaptionRect.left = m_CaptionRect.right() - fCapReserve;
+      m_CaptionRect.width = fCapReserve;
       CapLeftRightPlacement(capMargin, rtWidget, iCapPlacement);
-      m_rtUI.width -= fCapReserve;
+      m_UIRect.width -= fCapReserve;
       break;
     }
     case XFA_AttributeValue::Bottom: {
-      m_rtCaption.top = m_rtCaption.bottom() - fCapReserve;
-      m_rtCaption.height = fCapReserve;
+      m_CaptionRect.top = m_CaptionRect.bottom() - fCapReserve;
+      m_CaptionRect.height = fCapReserve;
       CapTopBottomPlacement(capMargin, rtWidget, iCapPlacement);
-      m_rtUI.height -= fCapReserve;
+      m_UIRect.height -= fCapReserve;
       break;
     }
     case XFA_AttributeValue::Inline:
@@ -296,34 +298,34 @@
   CXFA_Border* borderUI = m_pNode->GetUIBorder();
   if (borderUI) {
     CXFA_Margin* borderMargin = borderUI->GetMarginIfExists();
-    XFA_RectWithoutMargin(&m_rtUI, borderMargin);
+    XFA_RectWithoutMargin(&m_UIRect, borderMargin);
   }
-  m_rtUI.Normalize();
+  m_UIRect.Normalize();
 }
 
 void CXFA_FFField::CapTopBottomPlacement(const CXFA_Margin* margin,
                                          const CFX_RectF& rtWidget,
                                          XFA_AttributeValue iCapPlacement) {
   CFX_RectF rtUIMargin = m_pNode->GetUIMargin();
-  m_rtCaption.left += rtUIMargin.left;
+  m_CaptionRect.left += rtUIMargin.left;
   if (margin) {
-    XFA_RectWithoutMargin(&m_rtCaption, margin);
-    if (m_rtCaption.height < 0)
-      m_rtCaption.top += m_rtCaption.height;
+    XFA_RectWithoutMargin(&m_CaptionRect, margin);
+    if (m_CaptionRect.height < 0)
+      m_CaptionRect.top += m_CaptionRect.height;
   }
 
   float fWidth = rtUIMargin.left + rtUIMargin.width;
-  float fHeight = m_rtCaption.height + rtUIMargin.top + rtUIMargin.height;
+  float fHeight = m_CaptionRect.height + rtUIMargin.top + rtUIMargin.height;
   if (fWidth > rtWidget.width)
-    m_rtUI.width += fWidth - rtWidget.width;
+    m_UIRect.width += fWidth - rtWidget.width;
 
-  if (fHeight == XFA_DEFAULTUI_HEIGHT && m_rtUI.height < XFA_MINUI_HEIGHT) {
-    m_rtUI.height = XFA_MINUI_HEIGHT;
-    m_rtCaption.top += rtUIMargin.top + rtUIMargin.height;
+  if (fHeight == XFA_DEFAULTUI_HEIGHT && m_UIRect.height < XFA_MINUI_HEIGHT) {
+    m_UIRect.height = XFA_MINUI_HEIGHT;
+    m_CaptionRect.top += rtUIMargin.top + rtUIMargin.height;
   } else if (fHeight > rtWidget.height) {
-    m_rtUI.height += fHeight - rtWidget.height;
+    m_UIRect.height += fHeight - rtWidget.height;
     if (iCapPlacement == XFA_AttributeValue::Bottom)
-      m_rtCaption.top += fHeight - rtWidget.height;
+      m_CaptionRect.top += fHeight - rtWidget.height;
   }
 }
 
@@ -331,27 +333,27 @@
                                          const CFX_RectF& rtWidget,
                                          XFA_AttributeValue iCapPlacement) {
   CFX_RectF rtUIMargin = m_pNode->GetUIMargin();
-  m_rtCaption.top += rtUIMargin.top;
-  m_rtCaption.height -= rtUIMargin.top;
+  m_CaptionRect.top += rtUIMargin.top;
+  m_CaptionRect.height -= rtUIMargin.top;
   if (margin) {
-    XFA_RectWithoutMargin(&m_rtCaption, margin);
-    if (m_rtCaption.height < 0)
-      m_rtCaption.top += m_rtCaption.height;
+    XFA_RectWithoutMargin(&m_CaptionRect, margin);
+    if (m_CaptionRect.height < 0)
+      m_CaptionRect.top += m_CaptionRect.height;
   }
 
-  float fWidth = m_rtCaption.width + rtUIMargin.left + rtUIMargin.width;
+  float fWidth = m_CaptionRect.width + rtUIMargin.left + rtUIMargin.width;
   float fHeight = rtUIMargin.top + rtUIMargin.height;
   if (fWidth > rtWidget.width) {
-    m_rtUI.width += fWidth - rtWidget.width;
+    m_UIRect.width += fWidth - rtWidget.width;
     if (iCapPlacement == XFA_AttributeValue::Right)
-      m_rtCaption.left += fWidth - rtWidget.width;
+      m_CaptionRect.left += fWidth - rtWidget.width;
   }
 
-  if (fHeight == XFA_DEFAULTUI_HEIGHT && m_rtUI.height < XFA_MINUI_HEIGHT) {
-    m_rtUI.height = XFA_MINUI_HEIGHT;
-    m_rtCaption.top += rtUIMargin.top + rtUIMargin.height;
+  if (fHeight == XFA_DEFAULTUI_HEIGHT && m_UIRect.height < XFA_MINUI_HEIGHT) {
+    m_UIRect.height = XFA_MINUI_HEIGHT;
+    m_CaptionRect.top += rtUIMargin.top + rtUIMargin.height;
   } else if (fHeight > rtWidget.height) {
-    m_rtUI.height += fHeight - rtWidget.height;
+    m_UIRect.height += fHeight - rtWidget.height;
   }
 }
 
@@ -371,7 +373,7 @@
   if (!GetNormalWidget())
     return;
 
-  CFX_RectF rtUi = m_rtUI;
+  CFX_RectF rtUi = m_UIRect;
   rtUi.width = std::max(rtUi.width, 1.0f);
   if (!GetDoc()->GetXFADoc()->IsInteractive()) {
     float fFontSize = m_pNode->GetFontSize();
@@ -622,7 +624,7 @@
     return FWL_WidgetHit::Client;
   if (!GetRectWithoutRotate().Contains(point))
     return FWL_WidgetHit::Unknown;
-  if (m_rtCaption.Contains(point))
+  if (m_CaptionRect.Contains(point))
     return FWL_WidgetHit::Titlebar;
   return FWL_WidgetHit::Border;
 }
@@ -637,8 +639,8 @@
   if (!pCapTextLayout)
     return;
 
-  float fHeight = pCapTextLayout->Layout(m_rtCaption.Size());
-  m_rtCaption.height = std::max(m_rtCaption.height, fHeight);
+  float fHeight = pCapTextLayout->Layout(m_CaptionRect.Size());
+  m_CaptionRect.height = std::max(m_CaptionRect.height, fHeight);
 }
 
 void CXFA_FFField::RenderCaption(CXFA_Graphics* pGS, CFX_Matrix* pMatrix) {
@@ -651,12 +653,12 @@
     return;
 
   if (!pCapTextLayout->IsLoaded())
-    pCapTextLayout->Layout(m_rtCaption.Size());
+    pCapTextLayout->Layout(m_CaptionRect.Size());
 
-  CFX_RectF rtClip = m_rtCaption;
+  CFX_RectF rtClip = m_CaptionRect;
   rtClip.Intersect(GetRectWithoutRotate());
   CFX_RenderDevice* pRenderDevice = pGS->GetRenderDevice();
-  CFX_Matrix mt(1, 0, 0, 1, m_rtCaption.left, m_rtCaption.top);
+  CFX_Matrix mt(1, 0, 0, 1, m_CaptionRect.left, m_CaptionRect.top);
   if (pMatrix) {
     rtClip = pMatrix->TransformRect(rtClip);
     mt.Concat(*pMatrix);
diff --git a/xfa/fxfa/cxfa_fffield.h b/xfa/fxfa/cxfa_fffield.h
index 59614e8..dbfd2ac 100644
--- a/xfa/fxfa/cxfa_fffield.h
+++ b/xfa/fxfa/cxfa_fffield.h
@@ -101,8 +101,8 @@
                              XFA_AttributeValue iCapPlacement);
   void SetEditScrollOffset();
 
-  CFX_RectF m_rtUI;
-  CFX_RectF m_rtCaption;
+  CFX_RectF m_UIRect;
+  CFX_RectF m_CaptionRect;
 
  private:
   std::unique_ptr<CFWL_Widget> m_pNormalWidget;
diff --git a/xfa/fxfa/cxfa_ffimageedit.cpp b/xfa/fxfa/cxfa_ffimageedit.cpp
index 06171bc..9d1615d 100644
--- a/xfa/fxfa/cxfa_ffimageedit.cpp
+++ b/xfa/fxfa/cxfa_ffimageedit.cpp
@@ -63,7 +63,7 @@
   mtRotate.Concat(matrix);
 
   CXFA_FFWidget::RenderWidget(pGS, mtRotate, highlight);
-  DrawBorder(pGS, m_pNode->GetUIBorder(), m_rtUI, mtRotate);
+  DrawBorder(pGS, m_pNode->GetUIBorder(), m_UIRect, mtRotate);
   RenderCaption(pGS, &mtRotate);
   RetainPtr<CFX_DIBitmap> pDIBitmap = m_pNode->GetImageEditImage();
   if (!pDIBitmap)
@@ -122,7 +122,7 @@
     return;
 
   CFX_RectF rtUIMargin = m_pNode->GetUIMargin();
-  CFX_RectF rtImage(m_rtUI);
+  CFX_RectF rtImage(m_UIRect);
   rtImage.Deflate(rtUIMargin.left, rtUIMargin.top, rtUIMargin.width,
                   rtUIMargin.height);
   GetNormalWidget()->SetWidgetRect(rtImage);
diff --git a/xfa/fxfa/cxfa_ffpushbutton.cpp b/xfa/fxfa/cxfa_ffpushbutton.cpp
index c803008..96eefc8 100644
--- a/xfa/fxfa/cxfa_ffpushbutton.cpp
+++ b/xfa/fxfa/cxfa_ffpushbutton.cpp
@@ -96,15 +96,15 @@
   CXFA_FFWidget::PerformLayout();
   CFX_RectF rtWidget = GetRectWithoutRotate();
 
-  m_rtUI = rtWidget;
+  m_UIRect = rtWidget;
   CXFA_Margin* margin = m_pNode->GetMarginIfExists();
   XFA_RectWithoutMargin(&rtWidget, margin);
 
-  m_rtCaption = rtWidget;
+  m_CaptionRect = rtWidget;
 
   CXFA_Caption* caption = m_pNode->GetCaptionIfExists();
   CXFA_Margin* captionMargin = caption ? caption->GetMarginIfExists() : nullptr;
-  XFA_RectWithoutMargin(&m_rtCaption, captionMargin);
+  XFA_RectWithoutMargin(&m_CaptionRect, captionMargin);
 
   LayoutHighlightCaption();
   SetFWLRect();
@@ -156,7 +156,7 @@
 }
 
 void CXFA_FFPushButton::LayoutHighlightCaption() {
-  CFX_SizeF sz(m_rtCaption.width, m_rtCaption.height);
+  CFX_SizeF sz(m_CaptionRect.width, m_CaptionRect.height);
   LayoutCaption();
   if (m_pRolloverTextLayout)
     m_pRolloverTextLayout->Layout(sz);
@@ -172,9 +172,9 @@
     return;
 
   CFX_RenderDevice* pRenderDevice = pGS->GetRenderDevice();
-  CFX_RectF rtClip = m_rtCaption;
+  CFX_RectF rtClip = m_CaptionRect;
   rtClip.Intersect(GetRectWithoutRotate());
-  CFX_Matrix mt(1, 0, 0, 1, m_rtCaption.left, m_rtCaption.top);
+  CFX_Matrix mt(1, 0, 0, 1, m_CaptionRect.left, m_CaptionRect.top);
   if (pMatrix) {
     rtClip = pMatrix->TransformRect(rtClip);
     mt.Concat(*pMatrix);
diff --git a/xfa/fxfa/cxfa_ffsignature.cpp b/xfa/fxfa/cxfa_ffsignature.cpp
index 058abc3..1f6dc10 100644
--- a/xfa/fxfa/cxfa_ffsignature.cpp
+++ b/xfa/fxfa/cxfa_ffsignature.cpp
@@ -36,7 +36,7 @@
 
   CXFA_FFWidget::RenderWidget(pGS, mtRotate, highlight);
 
-  DrawBorder(pGS, m_pNode->GetUIBorder(), m_rtUI, mtRotate);
+  DrawBorder(pGS, m_pNode->GetUIBorder(), m_UIRect, mtRotate);
   RenderCaption(pGS, &mtRotate);
   DrawHighlight(pGS, &mtRotate, highlight, kSquareShape);
 }
@@ -111,7 +111,7 @@
     return FWL_WidgetHit::Client;
   if (!GetRectWithoutRotate().Contains(point))
     return FWL_WidgetHit::Unknown;
-  if (m_rtCaption.Contains(point))
+  if (m_CaptionRect.Contains(point))
     return FWL_WidgetHit::Titlebar;
   return FWL_WidgetHit::Client;
 }
diff --git a/xfa/fxfa/cxfa_ffwidget.cpp b/xfa/fxfa/cxfa_ffwidget.cpp
index 2ee8962..13e7aa6 100644
--- a/xfa/fxfa/cxfa_ffwidget.cpp
+++ b/xfa/fxfa/cxfa_ffwidget.cpp
@@ -249,13 +249,13 @@
 const CFX_RectF& CXFA_FFWidget::GetWidgetRect() const {
   if (!GetLayoutItem()->TestStatusBits(XFA_WidgetStatus_RectCached))
     RecacheWidgetRect();
-  return m_rtWidget;
+  return m_WidgetRect;
 }
 
 const CFX_RectF& CXFA_FFWidget::RecacheWidgetRect() const {
   GetLayoutItem()->SetStatusBits(XFA_WidgetStatus_RectCached);
-  m_rtWidget = GetLayoutItem()->GetRect(false);
-  return m_rtWidget;
+  m_WidgetRect = GetLayoutItem()->GetRect(false);
+  return m_WidgetRect;
 }
 
 CFX_RectF CXFA_FFWidget::GetRectWithoutRotate() {
diff --git a/xfa/fxfa/cxfa_ffwidget.h b/xfa/fxfa/cxfa_ffwidget.h
index 9b27a91..6893c81 100644
--- a/xfa/fxfa/cxfa_ffwidget.h
+++ b/xfa/fxfa/cxfa_ffwidget.h
@@ -196,7 +196,7 @@
   UnownedPtr<CXFA_FFDocView> m_pDocView;
   ObservedPtr<CXFA_FFPageView> m_pPageView;
   UnownedPtr<CXFA_Node> const m_pNode;
-  mutable CFX_RectF m_rtWidget;
+  mutable CFX_RectF m_WidgetRect;
 };
 
 inline CXFA_FFField* ToField(CXFA_FFWidget* widget) {
diff --git a/xfa/fxfa/cxfa_rendercontext.cpp b/xfa/fxfa/cxfa_rendercontext.cpp
index 106fcbe..94eae6d 100644
--- a/xfa/fxfa/cxfa_rendercontext.cpp
+++ b/xfa/fxfa/cxfa_rendercontext.cpp
@@ -16,7 +16,7 @@
           XFA_WidgetStatus_Visible | XFA_WidgetStatus_Viewable)),
       m_pWidget(m_pWidgetIterator->MoveToNext()),
       m_matrix(matrix),
-      m_rtClipRect(clipRect) {}
+      m_ClipRect(clipRect) {}
 
 CXFA_RenderContext::~CXFA_RenderContext() = default;
 
@@ -25,7 +25,7 @@
     CFX_RectF rtWidgetBox = m_pWidget->GetBBox(CXFA_FFWidget::kDoNotDrawFocus);
     ++rtWidgetBox.width;
     ++rtWidgetBox.height;
-    if (rtWidgetBox.IntersectWith(m_rtClipRect))
+    if (rtWidgetBox.IntersectWith(m_ClipRect))
       m_pWidget->RenderWidget(gs, m_matrix, CXFA_FFWidget::kHighlight);
 
     m_pWidget = m_pWidgetIterator->MoveToNext();
diff --git a/xfa/fxfa/cxfa_rendercontext.h b/xfa/fxfa/cxfa_rendercontext.h
index 457c62f..bcf1618 100644
--- a/xfa/fxfa/cxfa_rendercontext.h
+++ b/xfa/fxfa/cxfa_rendercontext.h
@@ -30,7 +30,7 @@
   std::unique_ptr<IXFA_WidgetIterator> const m_pWidgetIterator;
   UnownedPtr<CXFA_FFWidget> m_pWidget;
   const CFX_Matrix m_matrix;
-  const CFX_RectF m_rtClipRect;
+  const CFX_RectF m_ClipRect;
 };
 
 #endif  // XFA_FXFA_CXFA_RENDERCONTEXT_H_