Convert FWL_ERR into an enum class.

xfa/fwl/core/fwl_formimp.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_formimp.h"
 
 #include "xfa/fde/tto/fde_textout.h"
 #include "xfa/fwl/basewidget/fwl_formproxyimp.h"
@@ skipping 30 matching lines @@
   IFWL_Form* pForm = new IFWL_Form;
   CFWL_FormProxyImp* pFormProxyImpl = new CFWL_FormProxyImp(properties, pOuter);
   pForm->SetImpl(pFormProxyImpl);
   pFormProxyImpl->SetInterface(pForm);
   return pForm;
 }
 IFWL_Form::IFWL_Form() {}
 FWL_FORMSIZE IFWL_Form::GetFormSize() {
   return static_cast<CFWL_FormImp*>(GetImpl())->GetFormSize();
 }
-FWL_ERR IFWL_Form::SetFormSize(FWL_FORMSIZE eFormSize) {
+FWL_Error IFWL_Form::SetFormSize(FWL_FORMSIZE eFormSize) {
   return static_cast<CFWL_FormImp*>(GetImpl())->SetFormSize(eFormSize);
 }
 IFWL_Widget* IFWL_Form::DoModal() {
   return static_cast<CFWL_FormImp*>(GetImpl())->DoModal();
 }
 IFWL_Widget* IFWL_Form::DoModal(uint32_t& dwCommandID) {
   return static_cast<CFWL_FormImp*>(GetImpl())->DoModal(dwCommandID);
 }
-FWL_ERR IFWL_Form::EndDoModal() {
+FWL_Error IFWL_Form::EndDoModal() {
   return static_cast<CFWL_FormImp*>(GetImpl())->EndDoModal();
 }
-FWL_ERR IFWL_Form::SetBorderRegion(CFX_Path* pPath) {
+FWL_Error IFWL_Form::SetBorderRegion(CFX_Path* pPath) {
   return static_cast<CFWL_FormImp*>(GetImpl())->SetBorderRegion(pPath);
 }
 
 CFWL_FormImp::CFWL_FormImp(const CFWL_WidgetImpProperties& properties,
                            IFWL_Widget* pOuter)
     : CFWL_WidgetImp(properties, pOuter),
       m_pCloseBox(nullptr),
       m_pMinBox(nullptr),
       m_pMaxBox(nullptr),
       m_pCaptionBox(nullptr),
@@ skipping 18 matching lines @@
   m_rtRestore.Reset();
   m_rtCaptionText.Reset();
   m_rtIcon.Reset();
 }
 
 CFWL_FormImp::~CFWL_FormImp() {
   RemoveSysButtons();
   delete m_pNoteLoop;
 }
 
-FWL_ERR CFWL_FormImp::GetClassName(CFX_WideString& wsClass) const {
+FWL_Error CFWL_FormImp::GetClassName(CFX_WideString& wsClass) const {
   wsClass = FWL_CLASS_Form;
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 
 uint32_t CFWL_FormImp::GetClassID() const {
   return FWL_CLASSHASH_Form;
 }
 
 FX_BOOL CFWL_FormImp::IsInstance(const CFX_WideStringC& wsClass) const {
   if (wsClass == CFX_WideStringC(FWL_CLASS_Form))
     return TRUE;
   return CFWL_WidgetImp::IsInstance(wsClass);
 }
 
-FWL_ERR CFWL_FormImp::Initialize() {
-  if (CFWL_WidgetImp::Initialize() != FWL_ERR_Succeeded)
-    return FWL_ERR_Indefinite;
+FWL_Error CFWL_FormImp::Initialize() {
+  if (CFWL_WidgetImp::Initialize() != FWL_Error::Succeeded)
+    return FWL_Error::Indefinite;
   RegisterForm();
   RegisterEventTarget();
   m_pDelegate = new CFWL_FormImpDelegate(this);
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
-FWL_ERR CFWL_FormImp::Finalize() {
+FWL_Error CFWL_FormImp::Finalize() {
   delete m_pDelegate;
   m_pDelegate = nullptr;
   UnregisterEventTarget();
   UnRegisterForm();
   return CFWL_WidgetImp::Finalize();
 }
-FWL_ERR CFWL_FormImp::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
+FWL_Error CFWL_FormImp::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
   if (bAutoSize) {
     rect.Reset();
     FX_FLOAT fCapHeight = GetCaptionHeight();
     FX_FLOAT fCXBorder = GetBorderSize(TRUE);
     FX_FLOAT fCYBorder = GetBorderSize(FALSE);
     FX_FLOAT fEdge = GetEdgeWidth();
     rect.height += fCapHeight + fCYBorder + fEdge + fEdge;
     rect.width += fCXBorder + fCXBorder + fEdge + fEdge;
   } else {
     rect = m_pProperties->m_rtWidget;
   }
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
-FWL_ERR CFWL_FormImp::GetClientRect(CFX_RectF& rect) {
+FWL_Error CFWL_FormImp::GetClientRect(CFX_RectF& rect) {
   if ((m_pProperties->m_dwStyles & FWL_WGTSTYLE_Caption) == 0) {
     rect = m_pProperties->m_rtWidget;
     rect.Offset(-rect.left, -rect.top);
-    return FWL_ERR_Succeeded;
+    return FWL_Error::Succeeded;
   }
 #ifdef FWL_UseMacSystemBorder
   rect = m_rtRelative;
   CFWL_WidgetMgr* pWidgetMgr = static_cast<CFWL_WidgetMgr*>(FWL_GetWidgetMgr());
   if (!pWidgetMgr)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
 
   rect.left = 0;
   rect.top = 0;
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 #else
   FX_FLOAT x = 0;
   FX_FLOAT y = 0;
   FX_FLOAT t = 0;
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
   if (pTheme) {
     CFWL_ThemePart part;
     part.m_pWidget = m_pInterface;
     x = *static_cast<FX_FLOAT*>(
         pTheme->GetCapacity(&part, CFWL_WidgetCapacity::CXBorder));
     y = *static_cast<FX_FLOAT*>(
         pTheme->GetCapacity(&part, CFWL_WidgetCapacity::CYBorder));
     t = *static_cast<FX_FLOAT*>(
         pTheme->GetCapacity(&part, CFWL_WidgetCapacity::CYCaption));
   }
   rect = m_pProperties->m_rtWidget;
   rect.Offset(-rect.left, -rect.top);
   rect.Deflate(x, t, x, y);
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 #endif
 }
-FWL_ERR CFWL_FormImp::Update() {
+FWL_Error CFWL_FormImp::Update() {
   if (m_iLock > 0) {
-    return FWL_ERR_Succeeded;
+    return FWL_Error::Succeeded;
   }
   if (!m_pProperties->m_pThemeProvider) {
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
   }
 #ifdef FWL_UseMacSystemBorder
 #else
   SetThemeData();
   if (m_pProperties->m_dwStyles & FWL_WGTSTYLE_Icon) {
     UpdateIcon();
   }
 #endif
   UpdateCaption();
   Layout();
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 FWL_WidgetHit CFWL_FormImp::HitTest(FX_FLOAT fx, FX_FLOAT fy) {
   GetAvailableTheme();
   if (m_pCloseBox && m_pCloseBox->m_rtBtn.Contains(fx, fy))
     return FWL_WidgetHit::CloseBox;
   if (m_pMaxBox && m_pMaxBox->m_rtBtn.Contains(fx, fy))
     return FWL_WidgetHit::MaxBox;
   if (m_pMinBox && m_pMinBox->m_rtBtn.Contains(fx, fy))
     return FWL_WidgetHit::MinBox;
   CFX_RectF rtCap;
@@ skipping 33 matching lines @@
     if (rt.Contains(fx, fy))
       return FWL_WidgetHit::RightTop;
     rt.Set(m_rtRelative.width - m_fCYBorder - kCornerEnlarge,
            m_rtRelative.height - m_fCXBorder - kCornerEnlarge,
            m_fCYBorder + kCornerEnlarge, m_fCXBorder + kCornerEnlarge);
     if (rt.Contains(fx, fy))
       return FWL_WidgetHit::RightBottom;
   }
   return FWL_WidgetHit::Client;
 }
-FWL_ERR CFWL_FormImp::DrawWidget(CFX_Graphics* pGraphics,
-                                 const CFX_Matrix* pMatrix) {
+FWL_Error CFWL_FormImp::DrawWidget(CFX_Graphics* pGraphics,
+                                   const CFX_Matrix* pMatrix) {
   if (!pGraphics)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   if (!m_pProperties->m_pThemeProvider)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
   FX_BOOL bInactive = !IsActive();
   int32_t iState = bInactive ? CFWL_PartState_Inactive : CFWL_PartState_Normal;
   if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_FRM_NoDrawClient) == 0) {
     DrawBackground(pGraphics, pTheme);
   }
 #ifdef FWL_UseMacSystemBorder
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 #endif
   CFWL_ThemeBackground param;
   param.m_pWidget = m_pInterface;
   param.m_dwStates = iState;
   param.m_pGraphics = pGraphics;
   param.m_rtPart = m_rtRelative;
   if (pMatrix) {
     param.m_matrix.Concat(*pMatrix);
   }
   if (m_pProperties->m_dwStyles & FWL_WGTSTYLE_Border) {
@@ skipping 82 matching lines @@
       pTheme->DrawBackground(&param);
     }
     if (m_pMinBox) {
       param.m_iPart = CFWL_Part::MinimizeBox;
       param.m_dwStates = m_pMinBox->GetPartState();
       param.m_rtPart = m_pMinBox->m_rtBtn;
       pTheme->DrawBackground(&param);
     }
   }
 #endif
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 FWL_FORMSIZE CFWL_FormImp::GetFormSize() {
   return m_eFormSize;
 }
-FWL_ERR CFWL_FormImp::SetFormSize(FWL_FORMSIZE eFormSize) {
+FWL_Error CFWL_FormImp::SetFormSize(FWL_FORMSIZE eFormSize) {
   m_eFormSize = eFormSize;
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 }
 IFWL_Widget* CFWL_FormImp::DoModal() {
   IFWL_App* pApp = GetOwnerApp();
   if (!pApp)
     return nullptr;
 
   CFWL_NoteDriver* pDriver = pApp->GetNoteDriver();
   if (!pDriver)
     return nullptr;
 
   m_pNoteLoop = new CFWL_NoteLoop(this);
   pDriver->PushNoteLoop(m_pNoteLoop);
   m_bDoModalFlag = TRUE;
   SetStates(FWL_WGTSTATE_Invisible, FALSE);
   pDriver->Run();
 #if (_FX_OS_ == _FX_MACOSX_)
 #else
   pDriver->PopNoteLoop();
 #endif
   delete m_pNoteLoop;
   m_pNoteLoop = NULL;
   return NULL;
 }
 IFWL_Widget* CFWL_FormImp::DoModal(uint32_t& dwCommandID) {
   return DoModal();
 }
-FWL_ERR CFWL_FormImp::EndDoModal() {
+FWL_Error CFWL_FormImp::EndDoModal() {
   if (!m_pNoteLoop)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
   m_bDoModalFlag = FALSE;
 #if (_FX_OS_ == _FX_MACOSX_)
   m_pNoteLoop->EndModalLoop();
   IFWL_App* pApp = GetOwnerApp();
   if (!pApp)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
 
   CFWL_NoteDriver* pDriver =
       static_cast<CFWL_NoteDriver*>(pApp->GetNoteDriver());
   if (!pDriver)
-    return FWL_ERR_Indefinite;
+    return FWL_Error::Indefinite;
 
   pDriver->PopNoteLoop();
   SetStates(FWL_WGTSTATE_Invisible, TRUE);
-  return FWL_ERR_Succeeded;
+  return FWL_Error::Succeeded;
 #else
   SetStates(FWL_WGTSTATE_Invisible, TRUE);
   return m_pNoteLoop->EndModalLoop();
 #endif
 }
-FWL_ERR CFWL_FormImp::SetBorderRegion(CFX_Path* pPath) {
-  return FWL_ERR_Succeeded;
+FWL_Error CFWL_FormImp::SetBorderRegion(CFX_Path* pPath) {
+  return FWL_Error::Succeeded;
 }
 void CFWL_FormImp::DrawBackground(CFX_Graphics* pGraphics,
                                   IFWL_ThemeProvider* pTheme) {
   CFWL_ThemeBackground param;
   param.m_pWidget = m_pInterface;
   param.m_iPart = CFWL_Part::Background;
   param.m_pGraphics = pGraphics;
   param.m_rtPart = m_rtRelative;
   param.m_rtPart.Deflate(m_fCYBorder, m_rtCaption.height, m_fCYBorder,
                          m_fCXBorder);
@@ skipping 398 matching lines @@
       fTop -= bTop ? (fLimitMax - fHeight) : 0;
       fHeight = fLimitMax;
     }
   }
 }
 
 CFWL_FormImpDelegate::CFWL_FormImpDelegate(CFWL_FormImp* pOwner)
     : m_pOwner(pOwner) {}
 
 #ifdef FWL_UseMacSystemBorder
-int32_t CFWL_FormImpDelegate::OnProcessMessage(CFWL_Message* pMessage) {
+void CFWL_FormImpDelegate::OnProcessMessage(CFWL_Message* pMessage) {
   if (!pMessage)
-    return 0;
+    return;
+
   switch (pMessage->GetClassID()) {
     case CFWL_MessageType::Activate: {
       m_pOwner->m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Deactivated;
       m_pOwner->Repaint(&m_pOwner->m_rtRelative);
       break;
     }
     case CFWL_MessageType::Deactivate: {
       m_pOwner->m_pProperties->m_dwStates |= FWL_WGTSTATE_Deactivated;
       m_pOwner->Repaint(&m_pOwner->m_rtRelative);
       break;
     }
     default:
       break;
   }
-  return FWL_ERR_Succeeded;
 }
 #else
-int32_t CFWL_FormImpDelegate::OnProcessMessage(CFWL_Message* pMessage) {
+void CFWL_FormImpDelegate::OnProcessMessage(CFWL_Message* pMessage) {
   if (!pMessage)
-    return 0;
-  int32_t iRet = 1;
+    return;
+
   switch (pMessage->GetClassID()) {
     case CFWL_MessageType::Activate: {
       m_pOwner->m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Deactivated;
       IFWL_App* pApp = m_pOwner->GetOwnerApp();
       CFWL_NoteDriver* pDriver =
           static_cast<CFWL_NoteDriver*>(pApp->GetNoteDriver());
       CFWL_WidgetImp* pSubFocusImp = m_pOwner->GetSubFocus();
       IFWL_Widget* pSubFocus =
           pSubFocusImp ? pSubFocusImp->GetInterface() : nullptr;
       if (pSubFocus && pSubFocus != pDriver->GetFocus())
@@ skipping 52 matching lines @@
         }
         default:
           break;
       }
       break;
     }
     case CFWL_MessageType::Size: {
       CFWL_WidgetMgr* pWidgetMgr =
           static_cast<CFWL_WidgetMgr*>(FWL_GetWidgetMgr());
       if (!pWidgetMgr)
-        return 0;
+        return;
 
       pWidgetMgr->AddRedrawCounts(m_pOwner->m_pInterface);
       if (!m_pOwner->m_bSetMaximize)
         break;
 
       m_pOwner->m_bSetMaximize = FALSE;
       CFWL_MsgSize* pMsg = static_cast<CFWL_MsgSize*>(pMessage);
       m_pOwner->m_pProperties->m_rtWidget.left = 0;
       m_pOwner->m_pProperties->m_rtWidget.top = 0;
       m_pOwner->m_pProperties->m_rtWidget.width = (FX_FLOAT)pMsg->m_iWidth;
       m_pOwner->m_pProperties->m_rtWidget.height = (FX_FLOAT)pMsg->m_iHeight;
       m_pOwner->Update();
       break;
     }
     case CFWL_MessageType::WindowMove: {
       OnWindowMove(static_cast<CFWL_MsgWindowMove*>(pMessage));
       break;
     }
     case CFWL_MessageType::Close: {
       OnClose(static_cast<CFWL_MsgClose*>(pMessage));
       break;
     }
     default: {
-      iRet = 0;
       break;
     }
   }
-  return iRet;
 }
 #endif  // FWL_UseMacSystemBorder
 
-FWL_ERR CFWL_FormImpDelegate::OnProcessEvent(CFWL_Event* pEvent) {
-  if (!pEvent)
-    return FWL_ERR_Indefinite;
-  return FWL_ERR_Succeeded;
+void CFWL_FormImpDelegate::OnProcessEvent(CFWL_Event* pEvent) {}
+
+void CFWL_FormImpDelegate::OnDrawWidget(CFX_Graphics* pGraphics,
+                                        const CFX_Matrix* pMatrix) {
+  m_pOwner->DrawWidget(pGraphics, pMatrix);
 }
 
-FWL_ERR CFWL_FormImpDelegate::OnDrawWidget(CFX_Graphics* pGraphics,
-                                           const CFX_Matrix* pMatrix) {
-  return m_pOwner->DrawWidget(pGraphics, pMatrix);
-}
 void CFWL_FormImpDelegate::OnLButtonDown(CFWL_MsgMouse* pMsg) {
   m_pOwner->SetGrab(TRUE);
   m_pOwner->m_bLButtonDown = TRUE;
   m_pOwner->m_eResizeType = FORM_RESIZETYPE_None;
   CFWL_SysBtn* pPressBtn = m_pOwner->GetSysBtnAtPoint(pMsg->m_fx, pMsg->m_fy);
   m_pOwner->m_iCaptureBtn = m_pOwner->GetSysBtnIndex(pPressBtn);
   CFX_RectF rtCap;
   rtCap.Set(m_pOwner->m_rtCaption.left + m_pOwner->m_fCYBorder,
             m_pOwner->m_rtCaption.top + m_pOwner->m_fCXBorder,
             m_pOwner->m_rtCaption.width -
@@ skipping 134 matching lines @@
 }
 void CFWL_FormImpDelegate::OnWindowMove(CFWL_MsgWindowMove* pMsg) {
   m_pOwner->m_pProperties->m_rtWidget.left = pMsg->m_fx;
   m_pOwner->m_pProperties->m_rtWidget.top = pMsg->m_fy;
 }
 void CFWL_FormImpDelegate::OnClose(CFWL_MsgClose* pMsg) {
   CFWL_EvtClose eClose;
   eClose.m_pSrcTarget = m_pOwner->m_pInterface;
   m_pOwner->DispatchEvent(&eClose);
 }