Cleanup fwl_* classes and cfx_* classes in fwl.

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/fx_ext.h"
+#include "third_party/base/ptr_util.h"
 #include "third_party/base/stl_util.h"
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/cfwl_widgetmgr.h"
 #include "xfa/fwl/core/ifwl_app.h"
 #include "xfa/fwl/core/ifwl_tooltip.h"
 
-CFWL_NoteLoop::CFWL_NoteLoop(IFWL_Widget* pForm)
-    : m_pForm(pForm), m_bContinueModal(true) {}
+CFWL_NoteLoop::CFWL_NoteLoop() : m_bContinueModal(true) {}
 
-FWL_Error CFWL_NoteLoop::Idle(int32_t count) {
-#if (_FX_OS_ == _FX_WIN32_DESKTOP_)
-  if (count <= 0) {
-#endif
-    CFWL_EvtIdle ev;
-    const IFWL_App* pApp = m_pForm->GetOwnerApp();
-    if (!pApp)
-      return FWL_Error::Indefinite;
-
-    CFWL_NoteDriver* pDriver = pApp->GetNoteDriver();
-    if (!pDriver)
-      return FWL_Error::Indefinite;
-
-    pDriver->SendEvent(&ev);
-#if (_FX_OS_ == _FX_WIN32_DESKTOP_)
-  }
-#endif
-  return FWL_Error::Indefinite;
-}
-IFWL_Widget* CFWL_NoteLoop::GetForm() {
-  return m_pForm;
-}
-bool CFWL_NoteLoop::ContinueModal() {
-  return m_bContinueModal;
-}
-FWL_Error CFWL_NoteLoop::EndModalLoop() {
-  m_bContinueModal = false;
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error CFWL_NoteLoop::SetMainForm(IFWL_Widget* pForm) {
-  m_pForm = pForm;
-  return FWL_Error::Succeeded;
-}
-void CFWL_NoteLoop::GenerateCommondEvent(uint32_t dwCommand) {
-  CFWL_EvtMenuCommand ev;
-  ev.m_iCommand = dwCommand;
-  const IFWL_App* pApp = m_pForm->GetOwnerApp();
-  if (!pApp)
-    return;
-
-  CFWL_NoteDriver* pDriver = pApp->GetNoteDriver();
-  if (!pDriver)
-    return;
-
-  pDriver->SendEvent(&ev);
-}
 CFWL_NoteDriver::CFWL_NoteDriver()
     : m_pHover(nullptr),
       m_pFocus(nullptr),
       m_pGrab(nullptr),
-      m_pNoteLoop(new CFWL_NoteLoop) {
+      m_pNoteLoop(pdfium::MakeUnique<CFWL_NoteLoop>()) {
   PushNoteLoop(m_pNoteLoop.get());
 }
 CFWL_NoteDriver::~CFWL_NoteDriver() {
-  ClearInvalidEventTargets(true);
+  ClearEventTargets(true);
 }
 
 void CFWL_NoteDriver::SendEvent(CFWL_Event* pNote) {
   if (m_eventTargets.empty())
     return;
 
   for (const auto& pair : m_eventTargets) {
     CFWL_EventTarget* pEventTarget = pair.second;
     if (pEventTarget && !pEventTarget->IsInvalid())
       pEventTarget->ProcessEvent(pNote);
   }
 }
 
-FWL_Error CFWL_NoteDriver::RegisterEventTarget(IFWL_Widget* pListener,
-                                               IFWL_Widget* pEventSource,
-                                               uint32_t dwFilter) {
+void CFWL_NoteDriver::RegisterEventTarget(IFWL_Widget* pListener,
+                                          IFWL_Widget* pEventSource,
+                                          uint32_t dwFilter) {
   uint32_t key = pListener->GetEventKey();
   if (key == 0) {
     do {
       key = rand();
     } while (key == 0 || pdfium::ContainsKey(m_eventTargets, key));
     pListener->SetEventKey(key);
   }
   if (!m_eventTargets[key])
-    m_eventTargets[key] = new CFWL_EventTarget(this, pListener);
+    m_eventTargets[key] = new CFWL_EventTarget(pListener);
 
   m_eventTargets[key]->SetEventSource(pEventSource, dwFilter);
-  return FWL_Error::Succeeded;
 }
 
-FWL_Error CFWL_NoteDriver::UnregisterEventTarget(IFWL_Widget* pListener) {
+void CFWL_NoteDriver::UnregisterEventTarget(IFWL_Widget* pListener) {
   uint32_t key = pListener->GetEventKey();
   if (key == 0)
-    return FWL_Error::Indefinite;
+    return;
 
   auto it = m_eventTargets.find(key);
   if (it != m_eventTargets.end())
     it->second->FlagInvalid();
-
-  return FWL_Error::Succeeded;
 }
 
-void CFWL_NoteDriver::ClearEventTargets(bool bRemoveAll) {
-  ClearInvalidEventTargets(bRemoveAll);
+void CFWL_NoteDriver::PushNoteLoop(CFWL_NoteLoop* pNoteLoop) {
+  m_noteLoopQueue.Add(pNoteLoop);
 }
 
-FWL_Error CFWL_NoteDriver::PushNoteLoop(CFWL_NoteLoop* pNoteLoop) {
-  m_noteLoopQueue.Add(pNoteLoop);
-  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;
 }
 bool CFWL_NoteDriver::SetFocus(IFWL_Widget* pFocus, bool bNotify) {
@@ skipping 23 matching lines @@
     ms.m_pDstTarget = pFocus;
     if (bNotify) {
       ms.m_dwExtend = 1;
     }
 
     if (IFWL_WidgetDelegate* pDelegate = pFocus->GetDelegate())
       pDelegate->OnProcessMessage(&ms);
   }
   return true;
 }
-FWL_Error CFWL_NoteDriver::Run() {
+
+void CFWL_NoteDriver::Run() {
 #if (_FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_WIN32_DESKTOP_ || \
      _FX_OS_ == _FX_WIN64_)
   CFWL_NoteLoop* pTopLoop = nullptr;
   for (;;) {
     pTopLoop = GetTopLoop();
     if (!pTopLoop || !pTopLoop->ContinueModal())
       break;
     if (UnqueueMessage(pTopLoop))
       continue;
   }
 #endif
-
-  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;
-}
-void CFWL_NoteDriver::SetGrab(IFWL_Widget* pGrab, bool bSet) {
-  m_pGrab = bSet ? pGrab : nullptr;
-}
 void CFWL_NoteDriver::NotifyTargetHide(IFWL_Widget* pNoteTarget) {
   if (m_pFocus == pNoteTarget) {
     m_pFocus = nullptr;
   }
   if (m_pHover == pNoteTarget) {
     m_pHover = nullptr;
   }
   if (m_pGrab == pNoteTarget) {
     m_pGrab = nullptr;
   }
@@ skipping 17 matching lines @@
     }
     IFWL_Widget* pSubFocus = pForm->GetSubFocus();
     if (!pSubFocus)
       return;
     if (pSubFocus == pNoteTarget) {
       pForm->SetSubFocus(nullptr);
     }
   }
 }
 
-FWL_Error CFWL_NoteDriver::RegisterForm(IFWL_Widget* pForm) {
-  if (!pForm)
-    return FWL_Error::Indefinite;
-  if (m_forms.Find(pForm) >= 0) {
-    return FWL_Error::Indefinite;
-  }
+void CFWL_NoteDriver::RegisterForm(IFWL_Widget* pForm) {
+  if (!pForm || m_forms.Find(pForm) >= 0)
+    return;
+
   m_forms.Add(pForm);
   if (m_forms.GetSize() == 1) {
     CFWL_NoteLoop* pLoop =
         static_cast<CFWL_NoteLoop*>(m_noteLoopQueue.GetAt(0));
     if (!pLoop)
-      return FWL_Error::Indefinite;
+      return;
     pLoop->SetMainForm(pForm);
   }
-  return FWL_Error::Succeeded;
 }
-FWL_Error CFWL_NoteDriver::UnRegisterForm(IFWL_Widget* pForm) {
+
+void CFWL_NoteDriver::UnRegisterForm(IFWL_Widget* pForm) {
   if (!pForm)
-    return FWL_Error::Indefinite;
+    return;
   int32_t nIndex = m_forms.Find(pForm);
-  if (nIndex < 0) {
-    return FWL_Error::Indefinite;
-  }
+  if (nIndex < 0)
+    return;
   m_forms.RemoveAt(nIndex);
-  return FWL_Error::Succeeded;
 }
 bool CFWL_NoteDriver::QueueMessage(CFWL_Message* pMessage) {
   pMessage->Retain();
   m_noteQueue.Add(pMessage);
   return true;
 }
 bool CFWL_NoteDriver::UnqueueMessage(CFWL_NoteLoop* pNoteLoop) {
   if (m_noteQueue.GetSize() < 1) {
     return false;
   }
   CFWL_Message* pMessage = m_noteQueue[0];
   m_noteQueue.RemoveAt(0);
   if (!IsValidMessage(pMessage)) {
     pMessage->Release();
     return true;
   }
   ProcessMessage(pMessage);
 
   pMessage->Release();
   return true;
 }
-CFWL_NoteLoop* CFWL_NoteDriver::GetTopLoop() {
+CFWL_NoteLoop* CFWL_NoteDriver::GetTopLoop() const {
   int32_t size = m_noteLoopQueue.GetSize();
   if (size <= 0)
     return nullptr;
   return static_cast<CFWL_NoteLoop*>(m_noteLoopQueue[size - 1]);
 }
-int32_t CFWL_NoteDriver::CountLoop() {
-  return m_noteLoopQueue.GetSize();
-}
 
 bool CFWL_NoteDriver::ProcessMessage(CFWL_Message* pMessage) {
   CFWL_WidgetMgr* pWidgetMgr =
       pMessage->m_pDstTarget->GetOwnerApp()->GetWidgetMgr();
   IFWL_Widget* pMessageForm = pWidgetMgr->IsFormDisabled()
                                   ? pMessage->m_pDstTarget
                                   : GetMessageForm(pMessage->m_pDstTarget);
   if (!pMessageForm)
     return false;
   if (DispatchMessage(pMessage, pMessageForm)) {
@@ skipping 321 matching lines @@
   }
   if (!pMessageForm && pDstTarget) {
     CFWL_WidgetMgr* pWidgetMgr = pDstTarget->GetOwnerApp()->GetWidgetMgr();
     if (!pWidgetMgr)
       return nullptr;
     pMessageForm = pWidgetMgr->GetSystemFormWidget(pDstTarget);
   }
   return pMessageForm;
 }
 
-void CFWL_NoteDriver::ClearInvalidEventTargets(bool bRemoveAll) {
+void CFWL_NoteDriver::ClearEventTargets(bool bRemoveAll) {
   auto it = m_eventTargets.begin();
   while (it != m_eventTargets.end()) {
     auto old = it++;
     if (old->second && (bRemoveAll || old->second->IsInvalid())) {
       delete old->second;
       m_eventTargets.erase(old);
     }
   }
 }
 
-CFWL_EventTarget::CFWL_EventTarget(CFWL_NoteDriver* pNoteDriver,
-                                   IFWL_Widget* pListener)
-    : m_pListener(pListener), m_pNoteDriver(pNoteDriver), m_bInvalid(false) {}
+CFWL_EventTarget::CFWL_EventTarget(IFWL_Widget* pListener)
+    : m_pListener(pListener), m_bInvalid(false) {}
 CFWL_EventTarget::~CFWL_EventTarget() {
   m_eventSources.RemoveAll();
 }
 
 int32_t CFWL_EventTarget::SetEventSource(IFWL_Widget* pSource,
                                          uint32_t dwFilter) {
   if (pSource) {
     m_eventSources.SetAt(pSource, dwFilter);
     return m_eventSources.GetCount();
   }
@@ skipping 17 matching lines @@
         pEvent->GetClassID() == CFWL_EventType::Idle) {
       if (IsFilterEvent(pEvent, dwFilter)) {
         pDelegate->OnProcessEvent(pEvent);
         return true;
       }
     }
   }
   return false;
 }
 
-bool CFWL_EventTarget::IsFilterEvent(CFWL_Event* pEvent, uint32_t dwFilter) {
+bool CFWL_EventTarget::IsFilterEvent(CFWL_Event* pEvent,
+                                     uint32_t dwFilter) const {
   if (dwFilter == FWL_EVENT_ALL_MASK)
     return true;
 
   switch (pEvent->GetClassID()) {
     case CFWL_EventType::Mouse:
       return !!(dwFilter & FWL_EVENT_MOUSE_MASK);
     case CFWL_EventType::MouseWheel:
       return !!(dwFilter & FWL_EVENT_MOUSEWHEEL_MASK);
     case CFWL_EventType::Key:
       return !!(dwFilter & FWL_EVENT_KEY_MASK);
     case CFWL_EventType::SetFocus:
     case CFWL_EventType::KillFocus:
       return !!(dwFilter & FWL_EVENT_FOCUSCHANGED_MASK);
     case CFWL_EventType::Draw:
       return !!(dwFilter & FWL_EVENT_DRAW_MASK);
     case CFWL_EventType::Close:
       return !!(dwFilter & FWL_EVENT_CLOSE_MASK);
     case CFWL_EventType::SizeChanged:
       return !!(dwFilter & FWL_EVENT_SIZECHANGED_MASK);
     case CFWL_EventType::Idle:
       return !!(dwFilter & FWL_EVENT_IDLE_MASK);
     default:
       return !!(dwFilter & FWL_EVENT_CONTROL_MASK);
   }
 }
-
-CFWL_ToolTipContainer* CFWL_ToolTipContainer::s_pInstance = nullptr;
-
-CFWL_ToolTipContainer::CFWL_ToolTipContainer()
-    : m_nInitDelayTime(0), m_nAutoPopDelayTime(2000) {
-  m_fAnchor.Set(0.0, 0.0, 0.0, 0.0);
-}
-
-CFWL_ToolTipContainer::~CFWL_ToolTipContainer() {}
-
-void CFWL_ToolTipContainer::GetCaption(IFWL_Widget* pWidget,
-                                       CFX_WideString& wsCaption) {
-  wsCaption = m_wsCaption;
-}
-
-int32_t CFWL_ToolTipContainer::GetInitialDelay(IFWL_Widget* pWidget) {
-  return m_nInitDelayTime;
-}
-
-int32_t CFWL_ToolTipContainer::GetAutoPopDelay(IFWL_Widget* pWidget) {
-  return m_nAutoPopDelayTime;
-}
-
-CFX_DIBitmap* CFWL_ToolTipContainer::GetToolTipIcon(IFWL_Widget* pWidget) {
-  return nullptr;
-}
-
-CFX_SizeF CFWL_ToolTipContainer::GetToolTipIconSize(IFWL_Widget* pWidget) {
-  return CFX_SizeF();
-}
-
-CFX_RectF CFWL_ToolTipContainer::GetAnchor() {
-  return m_fAnchor;
-}
-
-// static
-CFWL_ToolTipContainer* CFWL_ToolTipContainer::getInstance() {
-  if (!s_pInstance)
-    s_pInstance = new CFWL_ToolTipContainer;
-  return s_pInstance;
-}
-
-// static
-void CFWL_ToolTipContainer::DeleteInstance() {
-  delete s_pInstance;
-  s_pInstance = nullptr;
-}