Use stdint.h types throughout PDFium.

fpdfsdk/src/fxedit/fxet_list.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../include/fxedit/fxet_stub.h"
 #include "../../include/fxedit/fxet_edit.h"
 #include "../../include/fxedit/fxet_list.h"
 
@@ skipping 112 matching lines @@
 {
 }
 
 CFX_List::~CFX_List()
 {
         Empty();
 }
 
 void CFX_List::Empty()
 {
-        for (FX_INT32 i=0,sz=m_aListItems.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aListItems.GetSize(); i<sz; i++)
                 delete m_aListItems.GetAt(i);
 
         m_aListItems.RemoveAll();
 }
 
 void CFX_List::SetFontMap(IFX_Edit_FontMap * pFontMap)
 {
         m_pFontMap = pFontMap;
 }
 
 void CFX_List::SetFontSize(FX_FLOAT fFontSize)
 {
         m_fFontSize = fFontSize;
 }
 
 void CFX_List::AddItem(FX_LPCWSTR str)
 {       
         if (CFX_ListItem * pListItem = new CFX_ListItem())
         {
                 pListItem->SetFontMap(m_pFontMap);
                 pListItem->SetFontSize(m_fFontSize);
                 pListItem->SetText(str);
                 m_aListItems.Add(pListItem);
         }
 }
 
-void CFX_List::ReArrange(FX_INT32 nItemIndex)
+void CFX_List::ReArrange(int32_t nItemIndex)
 {
         FX_FLOAT fPosY = 0.0f;
 
         if (CFX_ListItem * pPrevItem = m_aListItems.GetAt(nItemIndex - 1))
                 fPosY = pPrevItem->GetRect().bottom;
         
-        for (FX_INT32 i=nItemIndex,sz=m_aListItems.GetSize(); i<sz; i++)
+        for (int32_t i=nItemIndex,sz=m_aListItems.GetSize(); i<sz; i++)
         {
                 if (CFX_ListItem * pListItem = m_aListItems.GetAt(i))
                 {
                         FX_FLOAT fListItemHeight = pListItem->GetItemHeight();
                         pListItem->SetRect(CLST_Rect(0.0f,fPosY,0.0f,fPosY + fListItemHeight));
                         fPosY += fListItemHeight;                       
                 }
         }
 
         SetContentRect(CLST_Rect(0.0f,0.0f,0.0f,fPosY));        
 }
 
-IFX_Edit * CFX_List::GetItemEdit(FX_INT32 nIndex) const
+IFX_Edit * CFX_List::GetItemEdit(int32_t nIndex) const
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nIndex))
         {
                 return pListItem->GetEdit();
         }
 
         return NULL;
 }
 
-FX_INT32 CFX_List::GetCount() const
+int32_t CFX_List::GetCount() const
 {
         return m_aListItems.GetSize();
 }
 
 CPDF_Rect CFX_List::GetPlateRect() const
 {
         return CFX_ListContainer::GetPlateRect();
 }
 
 CPDF_Rect CFX_List::GetContentRect() const
 {
         return InnerToOuter(CFX_ListContainer::GetContentRect());
 }
 
 FX_FLOAT CFX_List::GetFontSize() const
 {
         return m_fFontSize;
 }
 
-FX_INT32 CFX_List::GetItemIndex(const CPDF_Point & point) const
+int32_t CFX_List::GetItemIndex(const CPDF_Point & point) const
 {
         CPDF_Point pt = OuterToInner(point);
 
         FX_BOOL bFirst = TRUE;
         FX_BOOL bLast = TRUE;
 
-        for (FX_INT32 i=0,sz=m_aListItems.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aListItems.GetSize(); i<sz; i++)
         {
                 if (CFX_ListItem * pListItem = m_aListItems.GetAt(i))
                 {
                         CLST_Rect rcListItem = pListItem->GetRect();
 
                         if (FX_EDIT_IsFloatBigger(pt.y, rcListItem.top))
                         {                       
                                 bFirst = FALSE;
                         }
 
@@ skipping 18 matching lines @@
 FX_FLOAT CFX_List::GetFirstHeight() const
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(0))
         {
                 return pListItem->GetItemHeight();
         }
 
         return 1.0f;
 }
 
-FX_INT32 CFX_List::GetFirstSelected() const
+int32_t CFX_List::GetFirstSelected() const
 {
-        for (FX_INT32 i=0,sz=m_aListItems.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aListItems.GetSize(); i<sz; i++)
         {
                 if (CFX_ListItem * pListItem = m_aListItems.GetAt(i))
                 {
                         if (pListItem->IsSelected())
                                 return i;
                 }
         }
         return -1;
 }
 
-FX_INT32 CFX_List::GetLastSelected() const
+int32_t CFX_List::GetLastSelected() const
 {
-        for (FX_INT32 i=m_aListItems.GetSize()-1; i>=0; i--)
+        for (int32_t i=m_aListItems.GetSize()-1; i>=0; i--)
         {
                 if (CFX_ListItem * pListItem = m_aListItems.GetAt(i))
                 {
                         if (pListItem->IsSelected())
                                 return i;
                 }
         }
         return -1;
 }
 
 FX_WCHAR CFX_List::Toupper(FX_WCHAR c) const
 {
         if ( (c >= 'a') && (c <= 'z') )
                 c = c - ('a' - 'A');
         return c;
 }
 
-FX_INT32 CFX_List::FindNext(FX_INT32 nIndex,FX_WCHAR nChar) const
+int32_t CFX_List::FindNext(int32_t nIndex,FX_WCHAR nChar) const
 {
-        FX_INT32 nCircleIndex = nIndex;
+        int32_t nCircleIndex = nIndex;
 
-        for (FX_INT32 i=0,sz=m_aListItems.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aListItems.GetSize(); i<sz; i++)
         {
                 nCircleIndex ++;
                 if (nCircleIndex >= sz) nCircleIndex = 0;
 
                 if (CFX_ListItem * pListItem = m_aListItems.GetAt(nCircleIndex))
                 {
                         if (Toupper(pListItem->GetFirstChar()) == Toupper(nChar))
                                 return nCircleIndex;
                 }
         }
 
         return nCircleIndex;
 }
 
-CPDF_Rect CFX_List::GetItemRect(FX_INT32 nIndex) const
+CPDF_Rect CFX_List::GetItemRect(int32_t nIndex) const
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nIndex))
         {
                 CPDF_Rect rcItem = pListItem->GetRect();
                 rcItem.left = 0.0f;
                 rcItem.right = GetPlateRect().Width();
                 return InnerToOuter(rcItem);
         }
 
         return CPDF_Rect();
 }
 
-FX_BOOL CFX_List::IsItemSelected(FX_INT32 nIndex) const
+FX_BOOL CFX_List::IsItemSelected(int32_t nIndex) const
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nIndex))
         {
                 return pListItem->IsSelected();
         }
 
         return FALSE;
 }
 
-void CFX_List::SetItemSelect(FX_INT32 nItemIndex, FX_BOOL bSelected)
+void CFX_List::SetItemSelect(int32_t nItemIndex, FX_BOOL bSelected)
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nItemIndex))
         {
                 pListItem->SetSelect(bSelected);
         }
 }
 
-void CFX_List::SetItemCaret(FX_INT32 nItemIndex, FX_BOOL bCaret)
+void CFX_List::SetItemCaret(int32_t nItemIndex, FX_BOOL bCaret)
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nItemIndex))
         {
                 pListItem->SetCaret(bCaret);            
         }
 }
 
 void CFX_List::SetMultipleSel(FX_BOOL bMultiple)
 {
         m_bMultiple = bMultiple;
 }
 
 FX_BOOL CFX_List::IsMultipleSel() const
 {
         return m_bMultiple;
 }
 
-FX_BOOL CFX_List::IsValid(FX_INT32 nItemIndex) const
+FX_BOOL CFX_List::IsValid(int32_t nItemIndex) const
 {
         return nItemIndex >= 0 && nItemIndex < m_aListItems.GetSize();
 }
 
-CFX_WideString CFX_List::GetItemText(FX_INT32 nIndex) const
+CFX_WideString CFX_List::GetItemText(int32_t nIndex) const
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nIndex))
         {
                 return pListItem->GetText();
         }
 
         return L"";
 }
 
 /* ------------------------------------ CPLST_Select ---------------------------------- */
 
 CPLST_Select::CPLST_Select()
 {
 }
 
 CPLST_Select::~CPLST_Select()
 {
-        for (FX_INT32 i=0,sz=m_aItems.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aItems.GetSize(); i<sz; i++)
                 delete m_aItems.GetAt(i);
 
         m_aItems.RemoveAll();
 }
 
-void CPLST_Select::Add(FX_INT32 nItemIndex)
+void CPLST_Select::Add(int32_t nItemIndex)
 {
-        FX_INT32 nIndex = Find(nItemIndex);
+        int32_t nIndex = Find(nItemIndex);
 
         if (nIndex < 0) 
                 m_aItems.Add(new CPLST_Select_Item(nItemIndex,1));
         else
         {
                 if (CPLST_Select_Item * pItem = m_aItems.GetAt(nIndex))
                 {
                         pItem->nState = 1;
                 }
         }
 }
 
-void CPLST_Select::Add(FX_INT32 nBeginIndex, FX_INT32 nEndIndex)
+void CPLST_Select::Add(int32_t nBeginIndex, int32_t nEndIndex)
 {
         if (nBeginIndex > nEndIndex)
         {
-                FX_INT32 nTemp = nEndIndex;
+                int32_t nTemp = nEndIndex;
                 nEndIndex = nBeginIndex;
                 nBeginIndex = nTemp;
         }
 
-        for (FX_INT32 i=nBeginIndex; i<=nEndIndex; i++) Add(i);
+        for (int32_t i=nBeginIndex; i<=nEndIndex; i++)  Add(i);
 }
 
-void CPLST_Select::Sub(FX_INT32 nItemIndex)
+void CPLST_Select::Sub(int32_t nItemIndex)
 {
-        for (FX_INT32 i=m_aItems.GetSize()-1; i>=0; i--)
+        for (int32_t i=m_aItems.GetSize()-1; i>=0; i--)
         {
                 if (CPLST_Select_Item * pItem = m_aItems.GetAt(i))
                         if (pItem->nItemIndex == nItemIndex)
                                 pItem->nState = -1;
         }
 }
 
-void CPLST_Select::Sub(FX_INT32 nBeginIndex, FX_INT32 nEndIndex)
+void CPLST_Select::Sub(int32_t nBeginIndex, int32_t nEndIndex)
 {
         if (nBeginIndex > nEndIndex)
         {
-                FX_INT32 nTemp = nEndIndex;
+                int32_t nTemp = nEndIndex;
                 nEndIndex = nBeginIndex;
                 nBeginIndex = nTemp;
         }
 
-        for (FX_INT32 i=nBeginIndex; i<=nEndIndex; i++) Sub(i);
+        for (int32_t i=nBeginIndex; i<=nEndIndex; i++)  Sub(i);
 }
 
-FX_INT32 CPLST_Select::Find(FX_INT32 nItemIndex) const
+int32_t CPLST_Select::Find(int32_t nItemIndex) const
 {
-        for (FX_INT32 i=0,sz=m_aItems.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aItems.GetSize(); i<sz; i++)
         {
                 if (CPLST_Select_Item * pItem = m_aItems.GetAt(i))
                 {
                         if (pItem->nItemIndex == nItemIndex)
                                 return i;
                 }
         }
 
         return -1;
 }
 
-FX_BOOL CPLST_Select::IsExist(FX_INT32 nItemIndex) const
+FX_BOOL CPLST_Select::IsExist(int32_t nItemIndex) const
 {
         return Find(nItemIndex) >= 0;
 }
 
-FX_INT32 CPLST_Select::GetCount() const
+int32_t CPLST_Select::GetCount() const
 {
         return m_aItems.GetSize();
 }
 
-FX_INT32 CPLST_Select::GetItemIndex(FX_INT32 nIndex) const
+int32_t CPLST_Select::GetItemIndex(int32_t nIndex) const
 {
         if (nIndex >= 0 && nIndex < m_aItems.GetSize())
                 if (CPLST_Select_Item * pItem = m_aItems.GetAt(nIndex))
                         return pItem->nItemIndex;
 
         return -1;
 }
 
-FX_INT32 CPLST_Select::GetState(FX_INT32 nIndex) const
+int32_t CPLST_Select::GetState(int32_t nIndex) const
 {
         if (nIndex >= 0 && nIndex < m_aItems.GetSize())
                 if (CPLST_Select_Item * pItem = m_aItems.GetAt(nIndex))
                         return pItem->nState;
 
         return 0;
 }
 
 void CPLST_Select::DeselectAll()
 {
-        for (FX_INT32 i=0,sz=m_aItems.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aItems.GetSize(); i<sz; i++)
         {
                 if (CPLST_Select_Item * pItem = m_aItems.GetAt(i))
                 {
                         pItem->nState = -1;
                 }
         }
 }
 
 void CPLST_Select::Done()
 {
-        for (FX_INT32 i=m_aItems.GetSize()-1; i>=0; i--)
+        for (int32_t i=m_aItems.GetSize()-1; i>=0; i--)
         {       
                 if (CPLST_Select_Item * pItem = m_aItems.GetAt(i))
                 {
                         if (pItem->nState == -1)
                         {
                                 delete pItem;
                                 m_aItems.RemoveAt(i);
                         }
                         else
                         {
@@ skipping 51 matching lines @@
 CPDF_Rect CFX_ListCtrl::OutToIn(const CPDF_Rect & rect) const
 {
         CPDF_Point ptLeftBottom = OutToIn(CPDF_Point(rect.left,rect.bottom));
         CPDF_Point ptRightTop = OutToIn(CPDF_Point(rect.right,rect.top));
 
         return CPDF_Rect(ptLeftBottom.x,ptLeftBottom.y,ptRightTop.x,ptRightTop.y);
 }
 
 void CFX_ListCtrl::OnMouseDown(const CPDF_Point & point,FX_BOOL bShift,FX_BOOL bCtrl)
 {
-        FX_INT32 nHitIndex = this->GetItemIndex(point);
+        int32_t nHitIndex = this->GetItemIndex(point);
 
         if (IsMultipleSel())
         {
                 if (bCtrl)
                 {
                         if (IsItemSelected(nHitIndex))
                         {
                                 m_aSelItems.Sub(nHitIndex);
                                 SelectItems();
                                 m_bCtrlSel = FALSE;
@@ skipping 28 matching lines @@
         {
                 SetSingleSelect(nHitIndex);
         }
 
         if (!this->IsItemVisible(nHitIndex))
                 this->ScrollToListItem(nHitIndex);
 }
 
 void CFX_ListCtrl::OnMouseMove(const CPDF_Point & point,FX_BOOL bShift,FX_BOOL bCtrl)
 {
-        FX_INT32 nHitIndex = this->GetItemIndex(point);
+        int32_t nHitIndex = this->GetItemIndex(point);
 
         if (IsMultipleSel())
         {                       
                 if (bCtrl)
                 {
                         if (m_bCtrlSel)
                                 m_aSelItems.Add(m_nFootIndex,nHitIndex);
                         else
                                 m_aSelItems.Sub(m_nFootIndex,nHitIndex);                        
                         
@@ skipping 10 matching lines @@
         }
         else
         {
                 SetSingleSelect(nHitIndex);
         }
 
         if (!this->IsItemVisible(nHitIndex))
                 this->ScrollToListItem(nHitIndex);
 }
 
-void CFX_ListCtrl::OnVK(FX_INT32 nItemIndex,FX_BOOL bShift,FX_BOOL bCtrl)
+void CFX_ListCtrl::OnVK(int32_t nItemIndex,FX_BOOL bShift,FX_BOOL bCtrl)
 {
         if (IsMultipleSel())
         {
                 if (nItemIndex >= 0 && nItemIndex < GetCount())
                 {
                         if (bCtrl)
                         {
                         }
                         else if (bShift)
                         {
@@ skipping 46 matching lines @@
         OnVK(0, bShift, bCtrl);
 }
 
 void CFX_ListCtrl::OnVK_END(FX_BOOL bShift,FX_BOOL bCtrl)
 {
         OnVK(GetCount()-1, bShift, bCtrl);
 }
 
 FX_BOOL CFX_ListCtrl::OnChar(FX_WORD nChar,FX_BOOL bShift,FX_BOOL bCtrl)
 {
-        FX_INT32 nIndex = GetLastSelected();    
-        FX_INT32 nFindIndex = FindNext(nIndex,nChar);
+        int32_t nIndex = GetLastSelected();     
+        int32_t nFindIndex = FindNext(nIndex,nChar);
 
         if (nFindIndex != nIndex)
         {
                 OnVK(nFindIndex, bShift, bCtrl);
                 return TRUE;
         }
         return FALSE;
 }
 
 /* -------- inner methods ------- */
 
 void CFX_ListCtrl::SetPlateRect(const CPDF_Rect & rect)
 {
         CFX_ListContainer::SetPlateRect(rect);
         m_ptScrollPos.x = rect.left;
         SetScrollPos(CPDF_Point(rect.left,rect.top));   
         ReArrange(0);
         InvalidateItem(-1);
 }
 
-CPDF_Rect CFX_ListCtrl::GetItemRect(FX_INT32 nIndex) const
+CPDF_Rect CFX_ListCtrl::GetItemRect(int32_t nIndex) const
 {
         return InToOut(CFX_List::GetItemRect(nIndex));
 }
 
 void CFX_ListCtrl::AddString(FX_LPCWSTR string)
 {
         AddItem(string);
         ReArrange(GetCount() - 1);
 }
 
-void CFX_ListCtrl::SetMultipleSelect(FX_INT32 nItemIndex, FX_BOOL bSelected)
+void CFX_ListCtrl::SetMultipleSelect(int32_t nItemIndex, FX_BOOL bSelected)
 {
         if (!IsValid(nItemIndex)) return;
 
         if (bSelected != this->IsItemSelected(nItemIndex))
         {
                 if (bSelected)
                 {
                         SetItemSelect(nItemIndex,TRUE);
                         InvalidateItem(nItemIndex);
                 }
                 else
                 {
                         SetItemSelect(nItemIndex,FALSE);
                         InvalidateItem(nItemIndex);
                 }
         }
 }
 
-void CFX_ListCtrl::SetSingleSelect(FX_INT32 nItemIndex)
+void CFX_ListCtrl::SetSingleSelect(int32_t nItemIndex)
 {
         if (!IsValid(nItemIndex)) return;
 
         if (m_nSelItem != nItemIndex)
         {
                 if (m_nSelItem >= 0)
                 {
                         SetItemSelect(m_nSelItem,FALSE);
                         InvalidateItem(m_nSelItem);
                 }
                 
                 SetItemSelect(nItemIndex,TRUE);
                 InvalidateItem(nItemIndex);
                 m_nSelItem = nItemIndex;                
         }
 }
 
-void CFX_ListCtrl::SetCaret(FX_INT32 nItemIndex)
+void CFX_ListCtrl::SetCaret(int32_t nItemIndex)
 {
         if (!IsValid(nItemIndex)) return;
 
         if (this->IsMultipleSel())
         {               
-                FX_INT32 nOldIndex = m_nCaretIndex;
+                int32_t nOldIndex = m_nCaretIndex;
 
                 if (nOldIndex != nItemIndex)
                 {
                         m_nCaretIndex = nItemIndex;
 
                         SetItemCaret(nOldIndex, FALSE);
                         SetItemCaret(nItemIndex,TRUE);
 
                         InvalidateItem(nOldIndex);
                         InvalidateItem(nItemIndex);                     
                 }
         }
 }
 
-void CFX_ListCtrl::InvalidateItem(FX_INT32 nItemIndex)
+void CFX_ListCtrl::InvalidateItem(int32_t nItemIndex)
 {
         if (m_pNotify)
         {
                 if (nItemIndex == -1)
                 {
                         if (!m_bNotifyFlag)
                         {
                                 m_bNotifyFlag = TRUE;
                                 CPDF_Rect rcRefresh = GetPlateRect();
                                 m_pNotify->IOnInvalidateRect(&rcRefresh);
@@ skipping 13 matching lines @@
 
                                 m_pNotify->IOnInvalidateRect(&rcRefresh);
                                 m_bNotifyFlag = FALSE;
                         }
                 }
         }
 }
 
 void CFX_ListCtrl::SelectItems()
 {
-        for (FX_INT32 i=0,sz=m_aSelItems.GetCount(); i<sz; i++)
+        for (int32_t i=0,sz=m_aSelItems.GetCount(); i<sz; i++)
         {
-                FX_INT32 nItemIndex = m_aSelItems.GetItemIndex(i);
-                FX_INT32 nState = m_aSelItems.GetState(i);
+                int32_t nItemIndex = m_aSelItems.GetItemIndex(i);
+                int32_t nState = m_aSelItems.GetState(i);
 
                 switch(nState)
                 {
                 case 1:
                         SetMultipleSelect(nItemIndex, TRUE);                    
                         break;
                 case -1:
                         SetMultipleSelect(nItemIndex, FALSE);
                         break;
                 }
         }
 
         m_aSelItems.Done();
 }
 
-void CFX_ListCtrl::Select(FX_INT32 nItemIndex)
+void CFX_ListCtrl::Select(int32_t nItemIndex)
 {
         if (!IsValid(nItemIndex)) return;
 
         if (this->IsMultipleSel())
         {
                 m_aSelItems.Add(nItemIndex);
                 SelectItems();
         }
         else
                 SetSingleSelect(nItemIndex);
 }
 
-FX_BOOL CFX_ListCtrl::IsItemVisible(FX_INT32 nItemIndex) const
+FX_BOOL CFX_ListCtrl::IsItemVisible(int32_t nItemIndex) const
 {
         CPDF_Rect rcPlate = this->GetPlateRect();
         CPDF_Rect rcItem = this->GetItemRect(nItemIndex);
 
         return rcItem.bottom >= rcPlate.bottom && rcItem.top <= rcPlate.top;
 }
 
-void CFX_ListCtrl::ScrollToListItem(FX_INT32 nItemIndex)
+void CFX_ListCtrl::ScrollToListItem(int32_t nItemIndex)
 {
         if (!IsValid(nItemIndex)) return;
 
         CPDF_Rect rcPlate = this->GetPlateRect();
         CPDF_Rect rcItem = CFX_List::GetItemRect(nItemIndex);
         CPDF_Rect rcItemCtrl = GetItemRect(nItemIndex);
 
         if (FX_EDIT_IsFloatSmaller(rcItemCtrl.bottom, rcPlate.bottom))
         {
                 if (FX_EDIT_IsFloatSmaller(rcItemCtrl.top, rcPlate.top))
@@ skipping 68 matching lines @@
                         }
                 }
         }
 }
 
 CPDF_Rect CFX_ListCtrl::GetContentRect() const
 {
         return InToOut(CFX_List::GetContentRect());
 }
 
-void CFX_ListCtrl::ReArrange(FX_INT32 nItemIndex)
+void CFX_ListCtrl::ReArrange(int32_t nItemIndex)
 {
         CFX_List::ReArrange(nItemIndex);
         SetScrollInfo();
 }
 
-void CFX_ListCtrl::SetTopItem(FX_INT32 nIndex)
+void CFX_ListCtrl::SetTopItem(int32_t nIndex)
 {
         if (IsValid(nIndex))
         {
                 this->GetPlateRect();
                 CPDF_Rect rcItem = CFX_List::GetItemRect(nIndex);
                 SetScrollPosY(rcItem.top);
         }
 }
 
-FX_INT32 CFX_ListCtrl::GetTopItem() const
+int32_t CFX_ListCtrl::GetTopItem() const
 {
-        FX_INT32 nItemIndex = this->GetItemIndex(this->GetBTPoint());
+        int32_t nItemIndex = this->GetItemIndex(this->GetBTPoint());
 
         if (!IsItemVisible(nItemIndex) && IsItemVisible(nItemIndex + 1))
                         nItemIndex += 1;
 
         return nItemIndex;
 }
 
 void CFX_ListCtrl::Empty()
 {
         CFX_List::Empty();
         InvalidateItem(-1);
 }
 
 void CFX_ListCtrl::Cancel()
 {
         m_aSelItems.DeselectAll();
 }
 
-FX_INT32 CFX_ListCtrl::GetItemIndex(const CPDF_Point & point) const
+int32_t CFX_ListCtrl::GetItemIndex(const CPDF_Point & point) const
 {
         return CFX_List::GetItemIndex(OutToIn(point));
 }
 
 CFX_WideString CFX_ListCtrl::GetText() const
 {
         if (this->IsMultipleSel())
                 return this->GetItemText(this->m_nCaretIndex);  
         else
                 return this->GetItemText(this->m_nSelItem);
 }