Merge to XFA: Use stdint.h types throughout PDFium.

fpdfsdk/src/pdfwindow/PWL_Wnd.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/pdfwindow/PDFWindow.h"
 #include "../../include/pdfwindow/PWL_Wnd.h"
 #include "../../include/pdfwindow/PWL_Utils.h"
 #include "../../include/pdfwindow/PWL_ScrollBar.h"
 
 /* -------------------------- CPWL_Timer -------------------------- */
 
-static CFX_MapPtrTemplate<FX_INT32, CPWL_Timer*>& GetPWLTimeMap()
+static CFX_MapPtrTemplate<int32_t, CPWL_Timer*>& GetPWLTimeMap()
 {
   // Leak the object at shutdown.
-  static auto timeMap = new CFX_MapPtrTemplate<FX_INT32, CPWL_Timer*>;
+  static auto timeMap = new CFX_MapPtrTemplate<int32_t, CPWL_Timer*>;
   return *timeMap;
 }
 
 CPWL_Timer::CPWL_Timer(CPWL_TimerHandler* pAttached, IFX_SystemHandler* pSystemHandler) : 
         m_nTimerID(0),
         m_pAttached(pAttached),
         m_pSystemHandler(pSystemHandler)
 {
         ASSERT(m_pAttached != NULL);
         ASSERT(m_pSystemHandler != NULL);
 }
 
 CPWL_Timer::~CPWL_Timer()
 {
         KillPWLTimer();
 }
 
-FX_INT32 CPWL_Timer::SetPWLTimer(FX_INT32 nElapse)
+int32_t CPWL_Timer::SetPWLTimer(int32_t nElapse)
 {       
         if (m_nTimerID != 0) KillPWLTimer();
         m_nTimerID = m_pSystemHandler->SetTimer(nElapse, TimerProc);
         GetPWLTimeMap().SetAt(m_nTimerID, this);
         return m_nTimerID;
 }
 
 void CPWL_Timer::KillPWLTimer()
 {
         if (m_nTimerID != 0)
         {
                 m_pSystemHandler->KillTimer(m_nTimerID);
                 GetPWLTimeMap().RemoveKey(m_nTimerID);
                 m_nTimerID = 0;
         }
 }
 
-void CPWL_Timer::TimerProc(FX_INT32 idEvent)
+void CPWL_Timer::TimerProc(int32_t idEvent)
 {
         CPWL_Timer* pTimer = NULL;
         if (GetPWLTimeMap().Lookup(idEvent, pTimer))
         {
                 if (pTimer)
                 {                       
                         if (pTimer->m_pAttached) 
                                 pTimer->m_pAttached->TimerProc();
                 }
         }
 }
 
 /* -------------------------- CPWL_TimerHandler -------------------------- */
 
 CPWL_TimerHandler::CPWL_TimerHandler() : m_pTimer(NULL)
 {
 }
 
 CPWL_TimerHandler::~CPWL_TimerHandler()
 {
         if (m_pTimer) delete m_pTimer;
 }
 
-void CPWL_TimerHandler::BeginTimer(FX_INT32 nElapse)
+void CPWL_TimerHandler::BeginTimer(int32_t nElapse)
 {
         if (!m_pTimer)
                 m_pTimer = new CPWL_Timer(this, GetSystemHandler());
 
         if (m_pTimer)
                 m_pTimer->SetPWLTimer(nElapse);
 }
 
 void CPWL_TimerHandler::EndTimer()
 {
@@ skipping 39 matching lines @@
         }
 
         FX_BOOL IsMainCaptureMouse(const CPWL_Wnd * pWnd) const
         {
                 return pWnd == m_pMainMouseWnd;
         }
 
         FX_BOOL IsWndCaptureMouse(const CPWL_Wnd * pWnd) const
         {
                 if (pWnd)
-                        for( FX_INT32 i=0,sz=m_aMousePath.GetSize(); i<sz; i++)
+                        for( int32_t i=0,sz=m_aMousePath.GetSize(); i<sz; i++)
                                 if (m_aMousePath.GetAt(i) == pWnd)
                                         return TRUE;
 
                 return FALSE;
         }
 
         FX_BOOL IsMainCaptureKeyboard(const CPWL_Wnd * pWnd) const
         {
                 return pWnd == m_pMainKeyboardWnd;
         }
 
 
         FX_BOOL IsWndCaptureKeyboard(const CPWL_Wnd * pWnd) const
         {
                 if (pWnd)
-                        for( FX_INT32 i=0,sz=m_aKeyboardPath.GetSize(); i<sz; i++)
+                        for( int32_t i=0,sz=m_aKeyboardPath.GetSize(); i<sz; i++)
                                 if (m_aKeyboardPath.GetAt(i) == pWnd)
                                         return TRUE;
                 
                 return FALSE;
         }
 
         void SetFocus(CPWL_Wnd * pWnd)
         {
                 m_aKeyboardPath.RemoveAll();
 
@@ skipping 123 matching lines @@
 }
 
 void CPWL_Wnd::Destroy()
 {
         KillFocus();
 
         OnDestroy();
 
         if (m_bCreated)
         {
-                for (FX_INT32 i = m_aChildren.GetSize()-1; i >= 0; i --)
+                for (int32_t i = m_aChildren.GetSize()-1; i >= 0; i --)
                 {
                         if (CPWL_Wnd * pChild = m_aChildren[i])
                         {
                                 pChild->Destroy();
                                 delete pChild;
                                 pChild = NULL;
                         }
                 }
 
                 if (m_sPrivateParam.pParentWnd)
@@ skipping 40 matching lines @@
 {
         CPDF_Rect rcUnion = rcOld;
         rcUnion.Union(rcNew);
 
         InvalidateRect(&rcUnion);
 
         /*
         CPDF_Rect SubArray[4]; 
 
         rcOld.Substract4(rcNew,SubArray);
-        for (FX_INT32 i=0;i<4;i++)
+        for (int32_t i=0;i<4;i++)
         {
                 if (SubArray[i].left == 0 &&
                         SubArray[i].right == 0 &&
                         SubArray[i].top == 0 &&
                         SubArray[i].bottom == 0)continue;
 
                 InvalidateRect(&CPWL_Utils::InflateRect(SubArray[i],2));
         }
 
         rcNew.Substract4(rcOld,SubArray);
-        for (FX_INT32 j=0;j<4;j++)
+        for (int32_t j=0;j<4;j++)
         {
                 if (SubArray[j].left == 0 &&
                         SubArray[j].right == 0 &&
                         SubArray[j].top == 0 &&
                         SubArray[j].bottom == 0)continue;
 
                 InvalidateRect(&CPWL_Utils::InflateRect(SubArray[j],2));
         }
         */
 }
@@ skipping 36 matching lines @@
                                                                         this->GetBorderRightBottomColor(this->GetBorderStyle()),
                                                                         this->GetBorderStyle(),
                                                                         this->GetBorderDash());
 
                 sAppStream << sThis;
         }
 }
 
 void CPWL_Wnd::GetChildAppearanceStream(CFX_ByteTextBuf & sAppStream)
 {
-        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)
         {
                 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))
                 {
                         pChild->GetAppearanceStream(sAppStream);
                 }
         }
 }
 
 void CPWL_Wnd::DrawAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)
 {
@@ skipping 24 matching lines @@
                                                                 this->GetBorderLeftTopColor(this->GetBorderStyle()),
                                                                 this->GetBorderRightBottomColor(this->GetBorderStyle()),
                                                                 this->GetBorderStyle(),
                                                                 this->GetBorderDash(),
                                                                 GetTransparency());                                                             
         }
 }
 
 void CPWL_Wnd::DrawChildAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)
 {
-        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)
         {
                 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))
                 {
                         CPDF_Matrix mt = pChild->GetChildMatrix();
                         if (mt.IsIdentity())
                         {
                                 pChild->DrawAppearance(pDevice,pUser2Device);
                         }
                         else
                         {
@@ skipping 35 matching lines @@
         }
 }
 
 #define PWL_IMPLEMENT_KEY_METHOD(key_method_name)\
 FX_BOOL CPWL_Wnd::key_method_name(FX_WORD nChar, FX_DWORD nFlag)\
 {\
         if (IsValid() && IsVisible() && IsEnabled())\
         {\
                 if (IsWndCaptureKeyboard(this))\
                 {\
-                        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
+                        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
                         {\
                                 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\
                                 {\
                                         if (IsWndCaptureKeyboard(pChild))\
                                         {\
                                                 return pChild->key_method_name(nChar,nFlag);\
                                         }\
                                 }\
                         }\
                 }\
         }\
         return FALSE;\
 }
 
 #define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name)\
 FX_BOOL CPWL_Wnd::mouse_method_name(const CPDF_Point & point, FX_DWORD nFlag)\
 {\
         if (IsValid() && IsVisible() && IsEnabled())\
         {\
                 if (IsWndCaptureMouse(this))\
                 {\
-                        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
+                        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
                         {\
                                 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\
                                 {\
                                         if (IsWndCaptureMouse(pChild))\
                                         {\
                                                 return pChild->mouse_method_name(pChild->ParentToChild(point),nFlag);\
                                         }\
                                 }\
                         }\
                         SetCursor();\
                 }\
                 else\
                 {\
-                        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
+                        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
                         {\
                                 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\
                                 {\
                                         if (pChild->WndHitTest(pChild->ParentToChild(point)))\
                                         {\
                                                 return pChild->mouse_method_name(pChild->ParentToChild(point),nFlag);\
                                         }\
                                 }\
                         }\
                         if (this->WndHitTest(point))\
@@ skipping 18 matching lines @@
 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMouseMove)
 
 FX_BOOL CPWL_Wnd::OnMouseWheel(short zDelta, const CPDF_Point & point, FX_DWORD nFlag)
 {
         if (IsValid() && IsVisible() && IsEnabled())
         {
                 SetCursor();
                 if (IsWndCaptureKeyboard(this))
                 {
-                        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
+                        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)
                         {
                                 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))
                                 {
                                         if (IsWndCaptureKeyboard(pChild))
                                         {
                                                 return pChild->OnMouseWheel(zDelta,pChild->ParentToChild(point), nFlag);
                                         }
                                 }
                         }
                 }
         }
         return FALSE;
 }
 
 void CPWL_Wnd::AddChild(CPWL_Wnd * pWnd)
 {
         m_aChildren.Add(pWnd);
 }
 
 void CPWL_Wnd::RemoveChild(CPWL_Wnd * pWnd)
 {
-        for (FX_INT32 i = m_aChildren.GetSize()-1; i >= 0; i --)
+        for (int32_t i = m_aChildren.GetSize()-1; i >= 0; i --)
         {
                 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
                 {
                         if (pChild == pWnd)
                         {
                                 m_aChildren.RemoveAt(i);
                                 break;
                         }
                 }
         }
 }
 
-void CPWL_Wnd::OnNotify(CPWL_Wnd* pWnd, FX_DWORD msg, FX_INTPTR wParam, FX_INTPTR lParam)
+void CPWL_Wnd::OnNotify(CPWL_Wnd* pWnd, FX_DWORD msg, intptr_t wParam, intptr_t lParam)
 {
         switch (msg)
         {
         case PNM_ADDCHILD:
                 this->AddChild(pWnd);
                 break;
         case PNM_REMOVECHILD:
                 this->RemoveChild(pWnd);
                 break;
         default:
@@ skipping 98 matching lines @@
 CPWL_Color CPWL_Wnd::GetTextColor() const
 {
         return m_sPrivateParam.sTextColor;
 }
 
 CPWL_Color CPWL_Wnd::GetTextStrokeColor() const
 {
         return m_sPrivateParam.sTextStrokeColor;
 }
 
-FX_INT32 CPWL_Wnd::GetBorderStyle() const
+int32_t CPWL_Wnd::GetBorderStyle() const
 {
         return m_sPrivateParam.nBorderStyle;
 }
 
-void CPWL_Wnd::SetBorderStyle(FX_INT32 nBorderStyle)
+void CPWL_Wnd::SetBorderStyle(int32_t nBorderStyle)
 {
         if (HasFlag(PWS_BORDER))
                 m_sPrivateParam.nBorderStyle = nBorderStyle;
 }
 
-FX_INT32 CPWL_Wnd::GetBorderWidth() const
+int32_t CPWL_Wnd::GetBorderWidth() const
 {
         if (HasFlag(PWS_BORDER))
                 return m_sPrivateParam.dwBorderWidth;
 
         return 0;
 }
 
-FX_INT32 CPWL_Wnd::GetInnerBorderWidth() const
+int32_t CPWL_Wnd::GetInnerBorderWidth() const
 {
         /*
         switch (GetBorderStyle())
         {
         case PBS_BEVELED:
         case PBS_INSET:
                 return GetBorderWidth() / 2;
         }
         */
         return 0;
 }
 
-void CPWL_Wnd::SetBorderWidth(FX_INT32 nBorderWidth)
+void CPWL_Wnd::SetBorderWidth(int32_t nBorderWidth)
 {
         if (HasFlag(PWS_BORDER))
                 m_sPrivateParam.dwBorderWidth = nBorderWidth;
 }
 
 CPWL_Color CPWL_Wnd::GetBorderColor() const
 {
         if (HasFlag(PWS_BORDER))
                 return m_sPrivateParam.sBorderColor;
 
@@ skipping 55 matching lines @@
 }
 
 void CPWL_Wnd::SetCapture()
 {
         if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
                 pMsgCtrl->SetCapture(this);
 }
 
 void CPWL_Wnd::ReleaseCapture()
 {
-        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)
                 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
                         pChild->ReleaseCapture();
 
         if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
                 pMsgCtrl->ReleaseCapture();
 }
 
 void CPWL_Wnd::SetFocus()
 {
         if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
@@ skipping 36 matching lines @@
         if (m_sPrivateParam.pParentWnd)
                 return m_sPrivateParam.pParentWnd->GetRootWnd();
         else
                 return this;
 }
 
 void CPWL_Wnd::SetVisible(FX_BOOL bVisible)
 {
         if (IsValid())
         {
-                for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
+                for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)
                 {
                         if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
                         {
                                 pChild->SetVisible(bVisible);
                         }
                 }
 
                 if (bVisible != m_bVisible)
                 {
                         m_bVisible = bVisible;
@@ skipping 36 matching lines @@
 void CPWL_Wnd::CreateChildWnd(const PWL_CREATEPARAM & cp)
 {
 }
 
 void CPWL_Wnd::SetCursor()
 {
         if (IsValid()) 
         {
                 if (IFX_SystemHandler* pSH = GetSystemHandler())
                 {
-                        FX_INT32 nCursorType = this->GetCreationParam().eCursorType;
+                        int32_t nCursorType = this->GetCreationParam().eCursorType;
                         pSH->SetCursor(nCursorType);
                 }
         }
 }
 
 void CPWL_Wnd::CreateMsgControl()
 {
         if (!m_sPrivateParam.pMsgControl)
                 m_sPrivateParam.pMsgControl = new CPWL_MsgControl(this);
 }
@@ skipping 67 matching lines @@
 IPWL_Provider* CPWL_Wnd::GetProvider() const
 {
         return m_sPrivateParam.pProvider;
 }
 
 IFX_Edit_FontMap* CPWL_Wnd::GetFontMap() const
 {
         return m_sPrivateParam.pFontMap;
 }
 
-CPWL_Color CPWL_Wnd::GetBorderLeftTopColor(FX_INT32 nBorderStyle) const
+CPWL_Color CPWL_Wnd::GetBorderLeftTopColor(int32_t nBorderStyle) const
 {
         CPWL_Color color;
 
         switch (nBorderStyle)
         {
                 case PBS_SOLID:
                         break;
                 case PBS_DASH:
                         break;
                 case PBS_BEVELED:
                         color = CPWL_Color(COLORTYPE_GRAY,1);
                         break;
                 case PBS_INSET:
                         color = CPWL_Color(COLORTYPE_GRAY,0.5f);
                         break;
                 case PBS_UNDERLINED:
                         break;
         }
 
         return color;
 }
 
-CPWL_Color CPWL_Wnd::GetBorderRightBottomColor(FX_INT32 nBorderStyle) const
+CPWL_Color CPWL_Wnd::GetBorderRightBottomColor(int32_t nBorderStyle) const
 {
         CPWL_Color color;
 
         switch (nBorderStyle)
         {
                 case PBS_SOLID:
                         break;
                 case PBS_DASH:
                         break;
                 case PBS_BEVELED:
                         color = CPWL_Utils::DevideColor(GetBackgroundColor(),2);
                         break;
                 case PBS_INSET:
                         color = CPWL_Color(COLORTYPE_GRAY,0.75f);
                         break;
                 case PBS_UNDERLINED:
                         break;
         }
 
         return color;
 }
 
 /* ----------------------------------------------------------------- */
 
-FX_INT32 CPWL_Wnd::GetTransparency()
+int32_t CPWL_Wnd::GetTransparency()
 {
         return m_sPrivateParam.nTransparency;
 }
 
-void CPWL_Wnd::SetTransparency(FX_INT32 nTransparency)
+void CPWL_Wnd::SetTransparency(int32_t nTransparency)
 {
-        for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
+        for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)
         {
                 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
                 {
                         pChild->SetTransparency(nTransparency);
                 }
         }
 
         m_sPrivateParam.nTransparency = nTransparency;
 }
 
@@ skipping 16 matching lines @@
                                 pDocView->GetCurrentMatrix(mtPageView);
                                 mt.Concat(mtPageView);
                                 return mt;
                         }               
                         
 */
 
         return mt;
 }
 
-void CPWL_Wnd::PWLtoWnd(const CPDF_Point& point, FX_INT32& x, FX_INT32& y) const
+void CPWL_Wnd::PWLtoWnd(const CPDF_Point& point, int32_t& x, int32_t& y) const
 {
         CPDF_Matrix mt = GetWindowMatrix();
         CPDF_Point pt = point;
         mt.Transform(pt.x,pt.y);
-        x = (FX_INT32)(pt.x+0.5);
-        y = (FX_INT32)(pt.y+0.5);
+        x = (int32_t)(pt.x+0.5);
+        y = (int32_t)(pt.y+0.5);
 }
 
 FX_RECT CPWL_Wnd::PWLtoWnd(const CPDF_Rect & rect) const
 {
         CPDF_Rect rcTemp = rect;
         CPDF_Matrix mt = GetWindowMatrix();
         mt.TransformRect(rcTemp);       
-        return FX_RECT((FX_INT32)(rcTemp.left+0.5), (FX_INT32)(rcTemp.bottom+0.5), (FX_INT32)(rcTemp.right+0.5), (FX_INT32)(rcTemp.top+0.5));
+        return FX_RECT((int32_t)(rcTemp.left+0.5), (int32_t)(rcTemp.bottom+0.5), (int32_t)(rcTemp.right+0.5), (int32_t)(rcTemp.top+0.5));
 }
 
 FX_HWND CPWL_Wnd::GetAttachedHWnd() const
 {
         return m_sPrivateParam.hAttachedWnd;
 }
 
 CPDF_Point CPWL_Wnd::ChildToParent(const CPDF_Point& point) const
 {
         CPDF_Matrix mt = GetChildMatrix();
@@ skipping 85 matching lines @@
                 return pMsgCtrl->m_pMainKeyboardWnd;
         }
 
         return NULL;
 }
 
 void CPWL_Wnd::EnableWindow(FX_BOOL bEnable)
 {
         if (m_bEnabled != bEnable)
         {
-                for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
+                for (int32_t i=0,sz=m_aChildren.GetSize(); i<sz; i++)
                 {
                         if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
                         {
                                 pChild->EnableWindow(bEnable);
                         }
                 }
 
                 this->m_bEnabled = bEnable;
 
                 if (bEnable)
@@ skipping 49 matching lines @@
 FX_BOOL CPWL_Wnd::IsINSERTpressed(FX_DWORD nFlag) const
 {
         if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
         {
                 return pSystemHandler->IsINSERTKeyDown(nFlag);
         }
 
         return FALSE;
 }