FX_BOOL considered harmful, part 2.

fpdfsdk/src/fsdk_mgr.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 "../../public/fpdf_ext.h"
 #include "../../third_party/base/nonstd_unique_ptr.h"
 #include "../include/fsdk_define.h"
 #include "../include/fsdk_mgr.h"
 #include "../include/formfiller/FFL_FormFiller.h"
 #include "../include/javascript/IJavaScript.h"
 
 #if _FX_OS_ == _FX_ANDROID_
 #include "time.h"
 #else
 #include <ctime>
 #endif
 
 //extern CPDFDoc_Environment* g_pFormFillApp;
 class CFX_SystemHandler:public IFX_SystemHandler
 {
 public:
     CFX_SystemHandler(CPDFDoc_Environment* pEnv):m_pEnv(pEnv),m_nCharSet(-1) {}
 public:
     virtual void                InvalidateRect(FX_HWND hWnd, FX_RECT rect) ;
     virtual void                OutputSelectedRect(void* pFormFiller, CPDF_Rect& rect);
 
-    virtual FX_BOOL             IsSelectionImplemented();
+    virtual bool             IsSelectionImplemented();
 
     virtual CFX_WideString      GetClipboardText(FX_HWND hWnd){return L"";}
-    virtual FX_BOOL             SetClipboardText(FX_HWND hWnd, CFX_WideString string) {return FALSE;}
+    virtual bool             SetClipboardText(FX_HWND hWnd, CFX_WideString string) {return false;}
 
     virtual void                ClientToScreen(FX_HWND hWnd, int32_t& x, int32_t& y) {}
     virtual void                ScreenToClient(FX_HWND hWnd, int32_t& x, int32_t& y) {}
 
     /*cursor style
     FXCT_ARROW
     FXCT_NESW
     FXCT_NWSE
     FXCT_VBEAM
     FXCT_HBEAM
     FXCT_HAND
     */
     virtual void                SetCursor(int32_t nCursorType);
 
     virtual FX_HMENU            CreatePopupMenu() {return NULL;}
-    virtual FX_BOOL             AppendMenuItem(FX_HMENU hMenu, int32_t nIDNewItem, CFX_WideString string) {return FALSE;}
-    virtual FX_BOOL             EnableMenuItem(FX_HMENU hMenu, int32_t nIDItem, FX_BOOL bEnabled) {return FALSE;}
+    virtual bool             AppendMenuItem(FX_HMENU hMenu, int32_t nIDNewItem, CFX_WideString string) {return false;}
+    virtual bool             EnableMenuItem(FX_HMENU hMenu, int32_t nIDItem, bool bEnabled) {return false;}
     virtual int32_t         TrackPopupMenu(FX_HMENU hMenu, int32_t x, int32_t y, FX_HWND hParent) {return -1;}
     virtual void                DestroyMenu(FX_HMENU hMenu) {}
 
     virtual CFX_ByteString      GetNativeTrueTypeFont(int32_t nCharset);
-    virtual FX_BOOL             FindNativeTrueTypeFont(int32_t nCharset, CFX_ByteString sFontFaceName);
+    virtual bool             FindNativeTrueTypeFont(int32_t nCharset, CFX_ByteString sFontFaceName);
     virtual CPDF_Font*          AddNativeTrueTypeFontToPDF(CPDF_Document* pDoc, CFX_ByteString sFontFaceName, uint8_t nCharset);
 
     virtual int32_t         SetTimer(int32_t uElapse, TimerCallback lpTimerFunc) ;
     virtual void                KillTimer(int32_t nID) ;
 
 
-    virtual FX_BOOL             IsSHIFTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsSHIFTKeyDown(nFlag);}
-    virtual FX_BOOL             IsCTRLKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsCTRLKeyDown(nFlag);}
-    virtual FX_BOOL             IsALTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsALTKeyDown(nFlag);}
-    virtual FX_BOOL             IsINSERTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsINSERTKeyDown(nFlag);}
+    virtual bool             IsSHIFTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsSHIFTKeyDown(nFlag);}
+    virtual bool             IsCTRLKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsCTRLKeyDown(nFlag);}
+    virtual bool             IsALTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsALTKeyDown(nFlag);}
+    virtual bool             IsINSERTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsINSERTKeyDown(nFlag);}
 
     virtual FX_SYSTEMTIME       GetLocalTime();
 
     virtual int32_t         GetCharSet() {return m_nCharSet;}
     virtual void                SetCharSet(int32_t nCharSet) {m_nCharSet = nCharSet;}
 private:
     CPDFDoc_Environment* m_pEnv;
     int     m_nCharSet;
 };
 
@@ skipping 40 matching lines @@
 
         CPDFSDK_Annot* pAnnot  = pFFL->GetSDKAnnot();
         ASSERT(pAnnot);
         CPDF_Page* pPage = pAnnot->GetPDFPage();
         ASSERT(pPage);
         m_pEnv->FFI_OutputSelectedRect(pPage, ptA.x, ptB.y, ptB.x, ptA.y);
     }
 
 }
 
-FX_BOOL CFX_SystemHandler::IsSelectionImplemented()
+bool CFX_SystemHandler::IsSelectionImplemented()
 {
     if(m_pEnv)
     {
         FPDF_FORMFILLINFO* pInfo = m_pEnv->GetFormFillInfo();
         if(pInfo && pInfo->FFI_OutputSelectedRect)
-            return TRUE;
+            return true;
     }
-    return FALSE;
+    return false;
 }
 
 CFX_ByteString CFX_SystemHandler::GetNativeTrueTypeFont(int32_t nCharset)
 {
     return "";
 }
 
-FX_BOOL CFX_SystemHandler::FindNativeTrueTypeFont(int32_t nCharset, CFX_ByteString sFontFaceName)
+bool CFX_SystemHandler::FindNativeTrueTypeFont(int32_t nCharset, CFX_ByteString sFontFaceName)
 {
     CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
     if(pFontMgr)
     {
         CFX_FontMapper* pFontMapper = pFontMgr->m_pBuiltinMapper;
         if(pFontMapper)
         {
             int nSize = pFontMapper->m_InstalledTTFonts.GetSize();
             if(nSize ==0)
             {
                 pFontMapper->LoadInstalledFonts();
                 nSize = pFontMapper->m_InstalledTTFonts.GetSize();
             }
 
             for(int i=0; i<nSize; i++)
             {
                 if(pFontMapper->m_InstalledTTFonts[i].Compare(sFontFaceName))
-                    return TRUE;
+                    return true;
             }
         }
 
     }
 
-    return FALSE;
+    return false;
 }
 
 static int CharSet2CP(int charset)
 {
     if (charset == 128)
         return 932;
     if (charset == 134)
         return 936;
     if (charset == 129)
         return 949;
     if (charset == 136)
         return 950;
     return 0;
 }
 CPDF_Font* CFX_SystemHandler::AddNativeTrueTypeFontToPDF(CPDF_Document* pDoc, CFX_ByteString sFontFaceName,
                                                          uint8_t nCharset)
 {
     if(pDoc)
     {
         CFX_Font* pFXFont = new CFX_Font();
-        pFXFont->LoadSubst(sFontFaceName,TRUE,0,0,0,CharSet2CP(nCharset),FALSE);
-        CPDF_Font* pFont = pDoc->AddFont(pFXFont,nCharset,FALSE);
+        pFXFont->LoadSubst(sFontFaceName,true,0,0,0,CharSet2CP(nCharset),false);
+        CPDF_Font* pFont = pDoc->AddFont(pFXFont,nCharset,false);
         delete pFXFont;
         return pFont;
     }
 
     return NULL;
 }
 
 
 int32_t CFX_SystemHandler::SetTimer(int32_t uElapse, TimerCallback lpTimerFunc)
 {
@@ skipping 204 matching lines @@
         m_pIFormFiller = new CFFL_IFormFiller(this);
     return m_pIFormFiller;
 }
 
 CPDFSDK_Document::CPDFSDK_Document(CPDF_Document* pDoc,CPDFDoc_Environment* pEnv) :
     m_pDoc(pDoc),
     m_pInterForm(nullptr),
     m_pFocusAnnot(nullptr),
     m_pEnv(pEnv),
     m_pOccontent(nullptr),
-    m_bChangeMask(FALSE)
+    m_bChangeMask(false)
 {
 }
 
 CPDFSDK_Document::~CPDFSDK_Document()
 {
     for (auto& it : m_pageMap)
         delete it.second;
     m_pageMap.clear();
 
     delete m_pInterForm;
     m_pInterForm = nullptr;
 
     delete m_pOccontent;
     m_pOccontent = nullptr;
 }
 
-CPDFSDK_PageView* CPDFSDK_Document::GetPageView(CPDF_Page* pPDFPage, FX_BOOL ReNew)
+CPDFSDK_PageView* CPDFSDK_Document::GetPageView(CPDF_Page* pPDFPage, bool ReNew)
 {
     auto it = m_pageMap.find(pPDFPage);
     if (it != m_pageMap.end())
         return it->second;
 
     if (!ReNew)
         return nullptr;
 
     CPDFSDK_PageView* pPageView = new CPDFSDK_PageView(this, pPDFPage);
     m_pageMap[pPDFPage] = pPageView;
     // Delay to load all the annotations, to avoid endless loop.
     pPageView->LoadFXAnnots();
     return pPageView;
 }
 
 CPDFSDK_PageView* CPDFSDK_Document::GetCurrentView()
 {
     CPDF_Page* pPage = (CPDF_Page*)m_pEnv->FFI_GetCurrentPage(m_pDoc);
-    return pPage ? GetPageView(pPage, TRUE) : nullptr;
+    return pPage ? GetPageView(pPage, true) : nullptr;
 }
 
 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(int nIndex)
 {
     CPDF_Page* pTempPage = (CPDF_Page*)m_pEnv->FFI_GetPage(m_pDoc, nIndex);
     if (!pTempPage)
         return nullptr;
 
     auto it = m_pageMap.find(pTempPage);
     return it->second;
 }
 
 void CPDFSDK_Document:: ProcJavascriptFun()
 {
     CPDF_Document* pPDFDoc = GetDocument();
     CPDF_DocJSActions docJS(pPDFDoc);
     int iCount = docJS.CountJSActions();
     if (iCount < 1) return;
     for (int i = 0; i < iCount; i ++)
     {
         CFX_ByteString csJSName;
         CPDF_Action jsAction = docJS.GetJSAction(i, csJSName);
         if(m_pEnv->GetActionHander())
             m_pEnv->GetActionHander()->DoAction_JavaScript(jsAction,CFX_WideString::FromLocal(csJSName),this);
     }
 
 }
 
-FX_BOOL CPDFSDK_Document::ProcOpenAction()
+bool CPDFSDK_Document::ProcOpenAction()
 {
     if(!m_pDoc)
-        return FALSE;
+        return false;
 
     CPDF_Dictionary* pRoot = m_pDoc->GetRoot();
     if (!pRoot)
-        return FALSE;
+        return false;
 
     CPDF_Object* pOpenAction = pRoot->GetDict("OpenAction");
     if(!pOpenAction)
         pOpenAction = pRoot->GetArray("OpenAction");
 
     if(!pOpenAction)
-        return FALSE;
+        return false;
 
     if(pOpenAction->GetType()==PDFOBJ_ARRAY)
-        return TRUE;
+        return true;
 
     if(pOpenAction->GetType()==PDFOBJ_DICTIONARY)
     {
         CPDF_Dictionary * pDict=(CPDF_Dictionary*)pOpenAction;
         CPDF_Action action(pDict);
         if(m_pEnv->GetActionHander())
             m_pEnv->GetActionHander()->DoAction_DocOpen(action, this);
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 
 CPDF_OCContext* CPDFSDK_Document::GetOCContext()
 {
     if(!m_pOccontent)
         m_pOccontent = new CPDF_OCContext(m_pDoc);
     return m_pOccontent;
 }
 
 void CPDFSDK_Document::ReMovePageView(CPDF_Page* pPDFPage)
@@ skipping 33 matching lines @@
             pPageView->UpdateView(pAnnot);
         }
     }
 }
 
 CPDFSDK_Annot* CPDFSDK_Document::GetFocusAnnot()
 {
     return m_pFocusAnnot;
 }
 
-FX_BOOL CPDFSDK_Document::SetFocusAnnot(CPDFSDK_Annot* pAnnot,FX_UINT nFlag)
+bool CPDFSDK_Document::SetFocusAnnot(CPDFSDK_Annot* pAnnot,FX_UINT nFlag)
 {
 
-    if(m_pFocusAnnot==pAnnot) return TRUE;
+    if(m_pFocusAnnot==pAnnot) return true;
 
     if(m_pFocusAnnot)
     {
-        if(!KillFocusAnnot(nFlag) ) return FALSE;
+        if(!KillFocusAnnot(nFlag) ) return false;
     }
     CPDFSDK_PageView* pPageView = pAnnot->GetPageView();
     if(pAnnot && pPageView->IsValid())
     {
         CPDFSDK_AnnotHandlerMgr *pAnnotHandler=m_pEnv->GetAnnotHandlerMgr();
 
         if(pAnnotHandler&&!m_pFocusAnnot)
         {
             if (!pAnnotHandler->Annot_OnSetFocus(pAnnot,nFlag))
-                return FALSE;
+                return false;
             if(!m_pFocusAnnot)
             {
                 m_pFocusAnnot=pAnnot;
-                return TRUE;
+                return true;
             }
         }
     }
-    return FALSE;
+    return false;
 }
 
-FX_BOOL CPDFSDK_Document::KillFocusAnnot(FX_UINT nFlag)
+bool CPDFSDK_Document::KillFocusAnnot(FX_UINT nFlag)
 {
     if(m_pFocusAnnot)
     {
         CPDFSDK_AnnotHandlerMgr *pAnnotHandler=m_pEnv->GetAnnotHandlerMgr();
         if(pAnnotHandler)
         {
             CPDFSDK_Annot* pFocusAnnot = m_pFocusAnnot;
             m_pFocusAnnot = NULL;
             if(pAnnotHandler->Annot_OnKillFocus(pFocusAnnot, nFlag))
             {
 
                 if(pFocusAnnot->GetType() == FX_BSTRC("Widget"))
                 {
                     CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)pFocusAnnot;
                     int nFieldType = pWidget->GetFieldType();
                     if(FIELDTYPE_TEXTFIELD == nFieldType || FIELDTYPE_COMBOBOX == nFieldType)
-                        m_pEnv->FFI_OnSetFieldInputFocus(NULL, NULL, 0, FALSE);
+                        m_pEnv->FFI_OnSetFieldInputFocus(NULL, NULL, 0, false);
                 }
 
                 if(!m_pFocusAnnot)
-                    return TRUE;
+                    return true;
             }
             else
             {
                 m_pFocusAnnot = pFocusAnnot;
             }
         }
     }
-    return FALSE;
+    return false;
 }
 
 void CPDFSDK_Document::OnCloseDocument()
 {
     KillFocusAnnot();
 }
 
-FX_BOOL CPDFSDK_Document::GetPermissions(int nFlag)
+bool CPDFSDK_Document::GetPermissions(int nFlag)
 {
     FX_DWORD dwPermissions = m_pDoc->GetUserPermissions();
     return dwPermissions&nFlag;
 }
 
 IFXJS_Runtime * CPDFSDK_Document::GetJsRuntime()
 {
     ASSERT(m_pEnv!=NULL);
     return m_pEnv->GetJSRuntime();
 }
 
 CFX_WideString  CPDFSDK_Document::GetPath()
 {
     ASSERT(m_pEnv != NULL);
     return m_pEnv->JS_docGetFilePath();
 }
 
 
 CPDFSDK_PageView::CPDFSDK_PageView(CPDFSDK_Document* pSDKDoc,CPDF_Page* page):m_page(page),m_pSDKDoc(pSDKDoc)
 {
     CPDFSDK_InterForm* pInterForm = pSDKDoc->GetInterForm();
     if(pInterForm)
     {
         CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
         pPDFInterForm->FixPageFields(page);
     }
         m_page->SetPrivateData((void*)m_page, (void*)this, NULL);
     m_fxAnnotArray.RemoveAll();
 
-    m_bEnterWidget = FALSE;
-    m_bExitWidget = FALSE;
-    m_bOnWidget = FALSE;
+    m_bEnterWidget = false;
+    m_bExitWidget = false;
+    m_bOnWidget = false;
     m_CaptureWidget = NULL;
-    m_bValid = FALSE;
-        m_bLocked = FALSE;
-        m_bTakeOverPage = FALSE;
+    m_bValid = false;
+        m_bLocked = false;
+        m_bTakeOverPage = false;
 }
 
 CPDFSDK_PageView::~CPDFSDK_PageView()
 {
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     int nAnnotCount = m_fxAnnotArray.GetSize();
 
     for (int i=0; i<nAnnotCount; i++)
     {
         CPDFSDK_Annot* pAnnot = (CPDFSDK_Annot*)m_fxAnnotArray.GetAt(i);
@@ skipping 13 matching lines @@
         if(m_bTakeOverPage) {
             delete m_page;
         }
 }
 
 void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device,CPDF_RenderOptions* pOptions)
 {
     m_curMatrix = *pUser2Device;
 
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
-    CPDFSDK_AnnotIterator annotIterator(this, TRUE);
+    CPDFSDK_AnnotIterator annotIterator(this, true);
     CPDFSDK_Annot* pSDKAnnot = nullptr;
     int index = -1;
     while ((pSDKAnnot = annotIterator.Next(index))) {
         CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
         ASSERT(pAnnotHandlerMgr);
         pAnnotHandlerMgr->Annot_OnDraw(
             this, pSDKAnnot, pDevice, pUser2Device, 0);
     }
 }
 
@@ skipping 26 matching lines @@
             if(annotRect.Contains(pageX, pageY))
                 return pAnnot;
         }
     }
     return NULL;
 }
 
 CPDFSDK_Annot* CPDFSDK_PageView::GetFXAnnotAtPoint(FX_FLOAT pageX, FX_FLOAT pageY)
 {
 
-    CPDFSDK_AnnotIterator annotIterator(this, FALSE);
+    CPDFSDK_AnnotIterator annotIterator(this, false);
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
     CPDFSDK_Annot* pSDKAnnot = NULL;
     int index = -1;
     while((pSDKAnnot = annotIterator.Next(index)))
     {
         CPDF_Rect rc = pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
         if(rc.Contains(pageX, pageY))
             return pSDKAnnot;
     }
 
     return NULL;
 }
 
 CPDFSDK_Annot* CPDFSDK_PageView::GetFXWidgetAtPoint(FX_FLOAT pageX, FX_FLOAT pageY)
 {
 
-    CPDFSDK_AnnotIterator annotIterator(this, FALSE);
+    CPDFSDK_AnnotIterator annotIterator(this, false);
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
     CPDFSDK_Annot* pSDKAnnot = NULL;
     int index = -1;
     while((pSDKAnnot = annotIterator.Next(index)))
     {
         if(pSDKAnnot->GetType() == "Widget")
         {
             pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
             CPDF_Point point(pageX, pageY);
             if (pAnnotMgr->Annot_OnHitTest(this, pSDKAnnot, point))
                 return pSDKAnnot;
         }
     }
 
     return NULL;
 }
 
 
-FX_BOOL CPDFSDK_PageView::Annot_HasAppearance(CPDF_Annot* pAnnot)
+bool CPDFSDK_PageView::Annot_HasAppearance(CPDF_Annot* pAnnot)
 {
     CPDF_Dictionary* pAnnotDic = pAnnot->GetAnnotDict();
     if(pAnnotDic)
         return  pAnnotDic->KeyExist("AS");
-    return FALSE;
+    return false;
 }
 
 CPDFSDK_Annot*  CPDFSDK_PageView::AddAnnot(CPDF_Annot * pPDFAnnot)
 {
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     ASSERT(pEnv);
     CPDFSDK_AnnotHandlerMgr * pAnnotHandler= pEnv->GetAnnotHandlerMgr();
 
     CPDFSDK_Annot* pSDKAnnot =NULL;
 
@@ skipping 18 matching lines @@
 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Dictionary * pDict)
 {
     return pDict ? AddAnnot(pDict->GetString("Subtype"), pDict) : nullptr;
 }
 
 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(const FX_CHAR* lpSubType,CPDF_Dictionary * pDict)
 {
     return NULL;
 }
 
-FX_BOOL  CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot)
+bool  CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot)
 {
-    return FALSE;
+    return false;
 }
 
 CPDF_Document* CPDFSDK_PageView::GetPDFDocument()
 {
     if(m_page)
     {
         return m_page->m_pDocument;
     }
     return NULL;
 }
@@ skipping 19 matching lines @@
     int nCount = m_fxAnnotArray.GetSize();
     for(int i=0; i<nCount; i++)
     {
         CPDFSDK_Annot* pAnnot = (CPDFSDK_Annot*)m_fxAnnotArray.GetAt(i);
         if (pDict == pAnnot->GetPDFAnnot()->GetAnnotDict())
             return pAnnot;
     }
     return NULL;
 }
 
-FX_BOOL CPDFSDK_PageView::OnLButtonDown(const CPDF_Point & point, FX_UINT nFlag)
+bool CPDFSDK_PageView::OnLButtonDown(const CPDF_Point & point, FX_UINT nFlag)
 {
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     ASSERT(pEnv);
     CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
     if(!pFXAnnot)
     {
         KillFocusAnnot(nFlag);
     }
     else
     {
         CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
         ASSERT(pAnnotHandlerMgr);
 
-        FX_BOOL bRet = pAnnotHandlerMgr->Annot_OnLButtonDown(this, pFXAnnot, nFlag,point);
+        bool bRet = pAnnotHandlerMgr->Annot_OnLButtonDown(this, pFXAnnot, nFlag,point);
         if(bRet)
         {
             SetFocusAnnot(pFXAnnot);
         }
         return bRet;
     }
-    return FALSE;
+    return false;
 }
 
 
-FX_BOOL CPDFSDK_PageView::OnLButtonUp(const CPDF_Point & point, FX_UINT nFlag)
+bool CPDFSDK_PageView::OnLButtonUp(const CPDF_Point & point, FX_UINT nFlag)
 {
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     ASSERT(pEnv);
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
     ASSERT(pAnnotHandlerMgr);
     CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
     CPDFSDK_Annot* pFocusAnnot = GetFocusAnnot();
-    FX_BOOL bRet  = FALSE;
+    bool bRet  = false;
     if(pFocusAnnot && pFocusAnnot != pFXAnnot)
     {
         //Last focus Annot gets a chance to handle the event.
         bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFocusAnnot, nFlag,point);
     }
     if(pFXAnnot && !bRet)
     {
         bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFXAnnot, nFlag,point);
         return bRet;
     }
     return bRet;
 }
 
-FX_BOOL CPDFSDK_PageView::OnMouseMove(const CPDF_Point & point, int nFlag)
+bool CPDFSDK_PageView::OnMouseMove(const CPDF_Point & point, int nFlag)
 {
 
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
     ASSERT(pAnnotHandlerMgr);
     if(CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y))
     {
         if(m_CaptureWidget && m_CaptureWidget != pFXAnnot)
         {
-            m_bExitWidget = TRUE;
-            m_bEnterWidget = FALSE;
+            m_bExitWidget = true;
+            m_bEnterWidget = false;
             pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
         }
         m_CaptureWidget = (CPDFSDK_Widget*)pFXAnnot;
-        m_bOnWidget = TRUE;
+        m_bOnWidget = true;
         if(!m_bEnterWidget)
         {
-            m_bEnterWidget = TRUE;
-            m_bExitWidget = FALSE;
+            m_bEnterWidget = true;
+            m_bExitWidget = false;
             pAnnotHandlerMgr->Annot_OnMouseEnter(this, pFXAnnot,nFlag);
         }
         pAnnotHandlerMgr->Annot_OnMouseMove(this, pFXAnnot, nFlag, point);
-        return TRUE;
+        return true;
     }
     if(m_bOnWidget)
     {
-        m_bOnWidget = FALSE;
-        m_bExitWidget = TRUE;
-        m_bEnterWidget = FALSE;
+        m_bOnWidget = false;
+        m_bExitWidget = true;
+        m_bEnterWidget = false;
         if(m_CaptureWidget)
         {
             pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
             m_CaptureWidget = NULL;
         }
     }
-    return FALSE;
+    return false;
 }
 
-FX_BOOL CPDFSDK_PageView::OnMouseWheel(double deltaX, double deltaY,const CPDF_Point& point, int nFlag)
+bool CPDFSDK_PageView::OnMouseWheel(double deltaX, double deltaY,const CPDF_Point& point, int nFlag)
 {
     if(CPDFSDK_Annot* pAnnot = GetFXWidgetAtPoint(point.x, point.y))
     {
         CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
         CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
         ASSERT(pAnnotHandlerMgr);
         return pAnnotHandlerMgr->Annot_OnMouseWheel(this, pAnnot, nFlag, (int)deltaY, point);
     }
-    return FALSE;
+    return false;
 
 }
 
-FX_BOOL CPDFSDK_PageView::OnChar(int nChar, FX_UINT nFlag)
+bool CPDFSDK_PageView::OnChar(int nChar, FX_UINT nFlag)
 {
     if(CPDFSDK_Annot* pAnnot = GetFocusAnnot())
     {
         CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
         CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
         ASSERT(pAnnotHandlerMgr);
         return pAnnotHandlerMgr->Annot_OnChar(pAnnot, nChar, nFlag);
     }
 
-    return FALSE;
+    return false;
 }
 
-FX_BOOL CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag)
+bool CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag)
 {
     if(CPDFSDK_Annot* pAnnot = GetFocusAnnot())
     {
         CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
         CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
         ASSERT(pAnnotHandlerMgr);
         return pAnnotHandlerMgr->Annot_OnKeyDown(pAnnot, nKeyCode, nFlag);
     }
-    return FALSE;
+    return false;
 }
 
-FX_BOOL CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag)
+bool CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag)
 {
 //  if(CPDFSDK_Annot* pAnnot = GetFocusAnnot())
 //  {
 //      CFFL_IFormFiller* pIFormFiller = g_pFormFillApp->GetIFormFiller();
 //      return pIFormFiller->OnKeyUp(pAnnot, nKeyCode, nFlag);
 //  }
-    return FALSE;
+    return false;
 }
 
 extern void CheckUnSupportAnnot(CPDF_Document * pDoc, CPDF_Annot* pPDFAnnot);
 
 void CPDFSDK_PageView::LoadFXAnnots()
 {
     CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
 
-    FX_BOOL enableAPUpdate = CPDF_InterForm::UpdatingAPEnabled();
+    bool enableAPUpdate = CPDF_InterForm::UpdatingAPEnabled();
     //Disable the default AP construction.
-    CPDF_InterForm::EnableUpdateAP(FALSE);
+    CPDF_InterForm::EnableUpdateAP(false);
     m_pAnnotList = new CPDF_AnnotList(m_page);
     CPDF_InterForm::EnableUpdateAP(enableAPUpdate);
     int nCount = m_pAnnotList->Count();
-        SetLock(TRUE);
+        SetLock(true);
     for(int i=0; i<nCount; i++)
     {
         CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
         CPDF_Document * pDoc = GetPDFDocument();
 
         CheckUnSupportAnnot(pDoc, pPDFAnnot);
 
         CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
         ASSERT(pAnnotHandlerMgr != NULL);
 
         if(pAnnotHandlerMgr)
         {
             CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
             if(!pAnnot)
                 continue;
             m_fxAnnotArray.Add(pAnnot);
 
             pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
         }
 
     }
-        SetLock(FALSE);
+        SetLock(false);
 }
 
 void    CPDFSDK_PageView::UpdateRects(CFX_RectArray& rects)
 {
     for(int i=0; i<rects.GetSize(); i++)
     {
         CPDF_Rect rc = rects.GetAt(i);
         CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
         pEnv->FFI_Invalidate(m_page, rc.left, rc.top, rc.right, rc.bottom);
     }
@@ skipping 14 matching lines @@
         CPDF_Dictionary* pDic = m_page->m_pFormDict;
         CPDF_Document* pDoc = m_pSDKDoc->GetDocument();
         if(pDoc && pDic)
         {
             return pDoc->GetPageIndex(pDic->GetObjNum());
         }
     }
     return -1;
 }
 
-FX_BOOL CPDFSDK_PageView::IsValidAnnot(void* p)
+bool CPDFSDK_PageView::IsValidAnnot(void* p)
 {
-    if (p == NULL) return FALSE;
+    if (p == NULL) return false;
     int iCount = m_pAnnotList->Count();
     for (int i = 0; i < iCount; i++)
     {
         if (m_pAnnotList->GetAt(i) == p)
-            return TRUE;
+            return true;
     }
-    return FALSE;
+    return false;
 }
 
 
 CPDFSDK_Annot* CPDFSDK_PageView::GetFocusAnnot()
 {
     CPDFSDK_Annot* pFocusAnnot = m_pSDKDoc->GetFocusAnnot();
     if(!pFocusAnnot)
         return NULL;
 
     for(int i=0; i<m_fxAnnotArray.GetSize(); i++)
     {
         CPDFSDK_Annot* pAnnot = (CPDFSDK_Annot*)m_fxAnnotArray.GetAt(i);
         if(pAnnot == pFocusAnnot)
             return pAnnot;
     }
     return NULL;
 }