Convert FWL_ERR into an enum class.

xfa/fwl/core/fwl_noteimp.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 "xfa/fwl/core/fwl_noteimp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fwl/basewidget/fwl_tooltipctrlimp.h"
 #include "xfa/fwl/basewidget/ifwl_tooltip.h"
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/fwl_appimp.h"
 #include "xfa/fwl/core/fwl_formimp.h"
 #include "xfa/fwl/core/fwl_widgetimp.h"
 #include "xfa/fwl/core/fwl_widgetmgrimp.h"
 #include "xfa/fwl/core/ifwl_app.h"
 #include "xfa/fwl/core/ifwl_tooltiptarget.h"
 
 CFWL_NoteLoop::CFWL_NoteLoop(CFWL_WidgetImp* pForm)
     : m_pForm(pForm), m_bContinueModal(TRUE) {}
 
-FWL_ERR CFWL_NoteLoop::Idle(int32_t count) {
+FWL_Error CFWL_NoteLoop::Idle(int32_t count) {
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_)
   if (count <= 0) {
 #endif
     CFWL_EvtIdle ev;
     IFWL_App* pApp = FWL_GetApp();
     if (!pApp)
-      return FWL_ERR_Indefinite;
+      return FWL_Error::Indefinite;
     CFWL_NoteDriver* pDriver = pApp->GetNoteDriver();
     if (!pDriver)
-      return FWL_ERR_Indefinite;
+      return FWL_Error::Indefinite;
     pDriver->SendEvent(&ev);
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_)
   }
 #endif
-  return FWL_ERR_Indefinite;
+  return FWL_Error::Indefinite;
 }
 CFWL_WidgetImp* CFWL_NoteLoop::GetForm() {
   return m_pForm;
 }
 FX_BOOL CFWL_NoteLoop::ContinueModal() {
   return m_bContinueModal;
 }
-FWL_ERR CFWL_NoteLoop::EndModalLoop() {
+FWL_Error CFWL_NoteLoop::EndModalLoop() {
   m_bContinueModal = FALSE;
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 
-FWL_ERR CFWL_NoteLoop::SetMainForm(CFWL_WidgetImp* pForm) {
+FWL_Error CFWL_NoteLoop::SetMainForm(CFWL_WidgetImp* pForm) {
   m_pForm = pForm;
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 void CFWL_NoteLoop::GenerateCommondEvent(uint32_t dwCommand) {
   CFWL_EvtMenuCommand ev;
   ev.m_iCommand = dwCommand;
   IFWL_App* pApp = m_pForm->GetOwnerApp();
   if (!pApp)
     return;
 
   CFWL_NoteDriver* pDriver = pApp->GetNoteDriver();
   if (!pDriver)
@@ skipping 41 matching lines @@
 
     CFWL_EventTarget* pEventTarget = static_cast<CFWL_EventTarget*>(value);
     if (pEventTarget && !pEventTarget->IsInvalid())
       pEventTarget->ProcessEvent(pNote);
   }
   m_sendEventCalled--;
   return TRUE;
 }
 
 #define FWL_NoteDriver_EventKey 1100
-FWL_ERR CFWL_NoteDriver::RegisterEventTarget(IFWL_Widget* pListener,
-                                             IFWL_Widget* pEventSource,
-                                             uint32_t dwFilter) {
+FWL_Error CFWL_NoteDriver::RegisterEventTarget(IFWL_Widget* pListener,
+                                               IFWL_Widget* pEventSource,
+                                               uint32_t dwFilter) {
   uint32_t dwkey = (uint32_t)(uintptr_t)pListener->GetPrivateData(
       (void*)(uintptr_t)FWL_NoteDriver_EventKey);
   if (dwkey == 0) {
     void* random = FX_Random_MT_Start(0);
     dwkey = rand();
     FX_Random_MT_Close(random);
     pListener->SetPrivateData((void*)(uintptr_t)FWL_NoteDriver_EventKey,
                               (void*)(uintptr_t)dwkey, NULL);
   }
   CFWL_EventTarget* value = NULL;
   if (!m_eventTargets.Lookup((void*)(uintptr_t)dwkey, (void*&)value)) {
     value = new CFWL_EventTarget(this, pListener);
     m_eventTargets.SetAt((void*)(uintptr_t)dwkey, value);
   }
   value->SetEventSource(pEventSource, dwFilter);
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
-FWL_ERR CFWL_NoteDriver::UnregisterEventTarget(IFWL_Widget* pListener) {
+FWL_Error CFWL_NoteDriver::UnregisterEventTarget(IFWL_Widget* pListener) {
   uint32_t dwkey = (uint32_t)(uintptr_t)pListener->GetPrivateData(
       (void*)(uintptr_t)FWL_NoteDriver_EventKey);
   if (dwkey == 0) {
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   }
   CFWL_EventTarget* value = NULL;
   if (m_eventTargets.Lookup((void*)(uintptr_t)dwkey, (void*&)value)) {
     value->FlagInvalid();
   }
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 void CFWL_NoteDriver::ClearEventTargets(FX_BOOL bRemoveAll) {
   ClearInvalidEventTargets(bRemoveAll);
 }
 IFWL_App* CFWL_NoteDriver::GetOwnerApp() const {
   return FWL_GetApp();
 }
-FWL_ERR CFWL_NoteDriver::PushNoteLoop(CFWL_NoteLoop* pNoteLoop) {
+FWL_Error CFWL_NoteDriver::PushNoteLoop(CFWL_NoteLoop* pNoteLoop) {
   m_noteLoopQueue.Add(pNoteLoop);
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 CFWL_NoteLoop* CFWL_NoteDriver::PopNoteLoop() {
   int32_t pos = m_noteLoopQueue.GetSize();
   if (pos <= 0)
     return nullptr;
 
   CFWL_NoteLoop* p = m_noteLoopQueue.GetAt(pos - 1);
   m_noteLoopQueue.RemoveAt(pos - 1);
   return p;
 }
@@ skipping 30 matching lines @@
     if (bNotify) {
       ms.m_dwExtend = 1;
     }
     IFWL_WidgetDelegate* pDelegate = pFocus->SetDelegate(NULL);
     if (pDelegate) {
       pDelegate->OnProcessMessage(&ms);
     }
   }
   return TRUE;
 }
-FWL_ERR CFWL_NoteDriver::Run() {
+FWL_Error CFWL_NoteDriver::Run() {
   CFWL_WidgetMgr* pWidgetMgr = static_cast<CFWL_WidgetMgr*>(FWL_GetWidgetMgr());
   if (!pWidgetMgr)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
 
 #if (_FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_WIN32_DESKTOP_ || \
      _FX_OS_ == _FX_WIN64_)
   CFWL_NoteLoop* pTopLoop = NULL;
   for (;;) {
     pTopLoop = GetTopLoop();
     if (!pTopLoop || !pTopLoop->ContinueModal())
       break;
     if (UnqueueMessage(pTopLoop))
       continue;
   }
 #endif
 
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 
 IFWL_Widget* CFWL_NoteDriver::GetFocus() {
   return m_pFocus;
 }
 IFWL_Widget* CFWL_NoteDriver::GetHover() {
   return m_pHover;
 }
 void CFWL_NoteDriver::SetHover(IFWL_Widget* pHover) {
   m_pHover = pHover;
@@ skipping 31 matching lines @@
     }
     CFWL_WidgetImp* pSubFocus = pForm->GetSubFocus();
     if (!pSubFocus)
       return;
     if (pSubFocus && pSubFocus->GetInterface() == pNoteTarget) {
       pForm->SetSubFocus(NULL);
     }
   }
 }
 
-FWL_ERR CFWL_NoteDriver::RegisterForm(CFWL_WidgetImp* pForm) {
+FWL_Error CFWL_NoteDriver::RegisterForm(CFWL_WidgetImp* pForm) {
   if (!pForm)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   if (m_forms.Find(pForm) >= 0) {
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   }
   m_forms.Add(pForm);
   if (m_forms.GetSize() == 1) {
     CFWL_NoteLoop* pLoop =
         static_cast<CFWL_NoteLoop*>(m_noteLoopQueue.GetAt(0));
     if (!pLoop)
-      return FWL_ERR_Indefinite;
+      return FWL_Error::Indefinite;
     pLoop->SetMainForm(pForm);
   }
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
-FWL_ERR CFWL_NoteDriver::UnRegisterForm(CFWL_WidgetImp* pForm) {
+FWL_Error CFWL_NoteDriver::UnRegisterForm(CFWL_WidgetImp* pForm) {
   if (!pForm)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   int32_t nIndex = m_forms.Find(pForm);
   if (nIndex < 0) {
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   }
   m_forms.RemoveAt(nIndex);
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 FX_BOOL CFWL_NoteDriver::QueueMessage(CFWL_Message* pMessage) {
   pMessage->Retain();
   m_noteQueue.Add(pMessage);
   return TRUE;
 }
 FX_BOOL CFWL_NoteDriver::UnqueueMessage(CFWL_NoteLoop* pNoteLoop) {
   if (m_noteQueue.GetSize() < 1) {
     return FALSE;
   }
@@ skipping 371 matching lines @@
     CFWL_EventTarget* pEventTarget = NULL;
     m_eventTargets.GetNextAssoc(pos, key, (void*&)pEventTarget);
     if (pEventTarget && (bRemoveAll || pEventTarget->IsInvalid())) {
       m_eventTargets.RemoveKey(key);
       delete pEventTarget;
     }
   }
 }
 class CFWL_CoreToolTipDP : public IFWL_ToolTipDP {
  public:
-  FWL_ERR GetCaption(IFWL_Widget* pWidget, CFX_WideString& wsCaption);
+  FWL_Error GetCaption(IFWL_Widget* pWidget, CFX_WideString& wsCaption);
   int32_t GetInitialDelay(IFWL_Widget* pWidget);
   int32_t GetAutoPopDelay(IFWL_Widget* pWidget);
   CFX_DIBitmap* GetToolTipIcon(IFWL_Widget* pWidget);
   CFX_SizeF GetToolTipIconSize(IFWL_Widget* pWidget);
   CFX_RectF GetAnchor();
   CFWL_CoreToolTipDP();
 
   CFX_WideString m_wsCaption;
   int32_t m_nInitDelayTime;
   int32_t m_nAutoPopDelayTime;
   CFX_RectF m_fAnchor;
 };
 CFWL_CoreToolTipDP::CFWL_CoreToolTipDP() {
   m_nInitDelayTime = 500;
   m_nAutoPopDelayTime = 50000;
   m_fAnchor.Set(0.0, 0.0, 0.0, 0.0);
 }
-FWL_ERR CFWL_CoreToolTipDP::GetCaption(IFWL_Widget* pWidget,
-                                       CFX_WideString& wsCaption) {
+FWL_Error CFWL_CoreToolTipDP::GetCaption(IFWL_Widget* pWidget,
+                                         CFX_WideString& wsCaption) {
   wsCaption = m_wsCaption;
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 int32_t CFWL_CoreToolTipDP::GetInitialDelay(IFWL_Widget* pWidget) {
   return m_nInitDelayTime;
 }
 int32_t CFWL_CoreToolTipDP::GetAutoPopDelay(IFWL_Widget* pWidget) {
   return m_nAutoPopDelayTime;
 }
 CFX_DIBitmap* CFWL_CoreToolTipDP::GetToolTipIcon(IFWL_Widget* pWidget) {
   return NULL;
 }
@@ skipping 90 matching lines @@
     s_pInstance = new CFWL_ToolTipContainer;
   return s_pInstance;
 }
 
 // static
 void CFWL_ToolTipContainer::DeleteInstance() {
   delete s_pInstance;
   s_pInstance = NULL;
 }
 
-FX_ERR CFWL_ToolTipContainer::AddToolTipTarget(IFWL_ToolTipTarget* pTarget) {
+FWL_Error CFWL_ToolTipContainer::AddToolTipTarget(IFWL_ToolTipTarget* pTarget) {
   if (m_arrWidget.Find(pTarget) < 0) {
     m_arrWidget.Add(pTarget);
-    return FWL_ERR_Succeeded;
+    return FWL_Error::Succeeded;
   }
-  return FWL_ERR_Indefinite;
+  return FWL_Error::Indefinite;
 }
-FX_ERR CFWL_ToolTipContainer::RemoveToolTipTarget(IFWL_ToolTipTarget* pTarget) {
+FWL_Error CFWL_ToolTipContainer::RemoveToolTipTarget(
+    IFWL_ToolTipTarget* pTarget) {
   int index = m_arrWidget.Find(pTarget);
   if (index >= 0) {
     m_arrWidget.RemoveAt(index);
-    return FWL_ERR_Succeeded;
+    return FWL_Error::Succeeded;
   }
-  return FWL_ERR_Indefinite;
+  return FWL_Error::Indefinite;
 }
 FX_BOOL CFWL_ToolTipContainer::HasToolTip(IFWL_Widget* pWedget) {
   int32_t iCount = m_arrWidget.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     IFWL_ToolTipTarget* p = m_arrWidget[i];
     if (p->GetWidget() == pWedget) {
       pCurTarget = p;
       return TRUE;
     }
   }
@@ skipping 27 matching lines @@
       if (sz.x > 0 && sz.y > 0) {
         rt.width = sz.x;
         rt.height = sz.y;
       } else {
         CFX_RectF r;
         m_pToolTipImp->GetWidgetRect(r, TRUE);
         rt.width = r.width;
         rt.height = r.height;
       }
       CFX_PointF pt(pEvt->m_fx, pEvt->m_fy);
-      if (pCurTarget->GetToolTipPos(pt) == FWL_ERR_Succeeded) {
+      if (pCurTarget->GetToolTipPos(pt) == FWL_Error::Succeeded) {
         rt.left = pt.x;
         rt.top = pt.y;
         m_pToolTipImp->ModifyStylesEx(FWL_STYLEEXT_TTP_NoAnchor, 0);
       } else {
         CFX_RectF rtAnchor;
         pCurTarget->GetWidget()->GetClientRect(rtAnchor);
         pCurTarget->GetWidget()->TransformTo(NULL, rtAnchor.left, rtAnchor.top);
         m_pToolTipImp->SetAnchor(rtAnchor);
         m_pToolTipImp->ModifyStylesEx(0, FWL_STYLEEXT_TTP_NoAnchor);
       }
       m_pToolTipImp->SetWidgetRect(rt);
       m_pToolTipImp->Update();
       m_pToolTipImp->Show();
     }
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CFWL_ToolTipContainer::ProcessLeave(CFWL_EvtMouse* pEvt) {
   if (HasToolTip(pEvt->m_pDstTarget) && NULL != m_pToolTipImp) {
     m_pToolTipImp->Hide();
     pCurTarget = NULL;
     return TRUE;
   }
   return FALSE;
 }
 IFWL_ToolTipTarget* CFWL_ToolTipContainer::GetCurrentToolTipTarget() {
   return pCurTarget;
 }