Remove CFWL_Note.

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"
@@ skipping 16 matching lines @@
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_)
   if (count <= 0) {
 #endif
     CFWL_EvtIdle ev;
     IFWL_App* pApp = FWL_GetApp();
     if (!pApp)
       return FWL_ERR_Indefinite;
     IFWL_NoteDriver* pDriver = pApp->GetNoteDriver();
     if (!pDriver)
       return FWL_ERR_Indefinite;
-    pDriver->SendNote(&ev);
+    pDriver->SendEvent(&ev);
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_)
   }
 #endif
   return FWL_ERR_Indefinite;
 }
 CFWL_WidgetImp* CFWL_NoteLoop::GetForm() {
   return m_pForm;
 }
 FX_BOOL CFWL_NoteLoop::ContinueModal() {
   return m_bContinueModal;
@@ skipping 14 matching lines @@
 }
 void CFWL_NoteLoop::GenerateCommondEvent(uint32_t dwCommand) {
   CFWL_EvtMenuCommand ev;
   ev.m_iCommand = dwCommand;
   IFWL_Thread* pThread = m_pForm->GetOwnerThread();
   if (!pThread)
     return;
   IFWL_NoteDriver* pDriver = pThread->GetNoteDriver();
   if (!pDriver)
     return;
-  pDriver->SendNote(&ev);
+  pDriver->SendEvent(&ev);
 }
 CFWL_NoteDriver::CFWL_NoteDriver()
     : m_sendEventCalled(0),
       m_bFullScreen(FALSE),
       m_pHover(nullptr),
       m_pFocus(nullptr),
       m_pGrab(nullptr) {
   m_pNoteLoop = new CFWL_NoteLoop;
   PushNoteLoop(m_pNoteLoop);
 }
 CFWL_NoteDriver::~CFWL_NoteDriver() {
   delete m_pNoteLoop;
   ClearInvalidEventTargets(TRUE);
 }
-FX_BOOL CFWL_NoteDriver::SendNote(CFWL_Note* pNote) {
-  if (pNote->IsEvent()) {
+
+FX_BOOL CFWL_NoteDriver::SendEvent(CFWL_Event* pNote) {
     int32_t iCount = m_eventTargets.GetCount();
-    if (iCount < 1) {
+    if (iCount < 1)
       return TRUE;
-    }
-    if (FWL_EVTHASH_Mouse == static_cast<CFWL_Event*>(pNote)->GetClassID()) {
+    if (CFWL_EventType::Mouse == pNote->GetClassID()) {
       CFWL_EvtMouse* pMouse = static_cast<CFWL_EvtMouse*>(pNote);
       if (FWL_MSGMOUSECMD_MouseHover == pMouse->m_dwCmd) {
         if (m_pNoteLoop->GetForm() &&
             CFWL_ToolTipContainer::getInstance()->ProcessEnter(
                 pMouse, m_pNoteLoop->GetForm()->GetInterface())) {
         }
       } else if (FWL_MSGMOUSECMD_MouseLeave == pMouse->m_dwCmd) {
-        if (CFWL_ToolTipContainer::getInstance()->ProcessLeave(pMouse)) {
-        }
+        CFWL_ToolTipContainer::getInstance()->ProcessLeave(pMouse);
       } else if ((FWL_MSGMOUSECMD_LButtonDown <= pMouse->m_dwCmd) &&
                  (FWL_MSGMOUSECMD_MButtonDblClk >= pMouse->m_dwCmd)) {
-        if (CFWL_ToolTipContainer::getInstance()->ProcessLeave(pMouse)) {
-        }
+        CFWL_ToolTipContainer::getInstance()->ProcessLeave(pMouse);
       }
     }
     m_sendEventCalled++;
     FX_POSITION pos = m_eventTargets.GetStartPosition();
     while (pos) {
       void* key = NULL;
       CFWL_EventTarget* pEventTarget;
       m_eventTargets.GetNextAssoc(pos, key, (void*&)pEventTarget);
       if (pEventTarget && !pEventTarget->IsInvalid()) {
-        pEventTarget->ProcessEvent(static_cast<CFWL_Event*>(pNote));
+        pEventTarget->ProcessEvent(pNote);
       }
     }
     m_sendEventCalled--;
-  } else {
-    if (!pNote->m_pDstTarget)
-      return FALSE;
-    IFWL_WidgetDelegate* pDelegate = pNote->m_pDstTarget->SetDelegate(NULL);
-    if (pDelegate) {
-      pDelegate->OnProcessMessage(static_cast<CFWL_Message*>(pNote));
-    }
-  }
-  return TRUE;
+    return TRUE;
 }
 
 #define FWL_NoteDriver_EventKey 1100
 FWL_ERR 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);
@@ skipping 248 matching lines @@
 }
 
 FX_BOOL CFWL_NoteDriver::ProcessMessage(CFWL_Message* pMessage) {
   CFWL_WidgetMgr* pWidgetMgr = static_cast<CFWL_WidgetMgr*>(FWL_GetWidgetMgr());
   IFWL_Widget* pMessageForm = pWidgetMgr->IsFormDisabled()
                                   ? pMessage->m_pDstTarget
                                   : GetMessageForm(pMessage->m_pDstTarget);
   if (!pMessageForm)
     return FALSE;
   if (DispatchMessage(pMessage, pMessageForm)) {
-    if (pMessage->GetClassID() == FWL_MSGHASH_Mouse) {
+    if (pMessage->GetClassID() == CFWL_MessageType::Mouse)
       MouseSecondary(static_cast<CFWL_MsgMouse*>(pMessage));
-    }
     return TRUE;
   }
   return FALSE;
 }
+
 FX_BOOL CFWL_NoteDriver::DispatchMessage(CFWL_Message* pMessage,
                                          IFWL_Widget* pMessageForm) {
   FX_BOOL bRet = FALSE;
   switch (pMessage->GetClassID()) {
-    case FWL_MSGHASH_Activate: {
+    case CFWL_MessageType::Activate: {
       bRet = DoActivate(static_cast<CFWL_MsgActivate*>(pMessage), pMessageForm);
       break;
     }
-    case FWL_MSGHASH_Deactivate: {
+    case CFWL_MessageType::Deactivate: {
       bRet = DoDeactivate(static_cast<CFWL_MsgDeactivate*>(pMessage),
                           pMessageForm);
       break;
     }
-    case FWL_MSGHASH_SetFocus: {
+    case CFWL_MessageType::SetFocus: {
       bRet = DoSetFocus(static_cast<CFWL_MsgSetFocus*>(pMessage), pMessageForm);
       break;
     }
-    case FWL_MSGHASH_KillFocus: {
+    case CFWL_MessageType::KillFocus: {
       bRet =
           DoKillFocus(static_cast<CFWL_MsgKillFocus*>(pMessage), pMessageForm);
       break;
     }
-    case FWL_MSGHASH_Key: {
+    case CFWL_MessageType::Key: {
       bRet = DoKey(static_cast<CFWL_MsgKey*>(pMessage), pMessageForm);
       break;
     }
-    case FWL_MSGHASH_Mouse: {
+    case CFWL_MessageType::Mouse: {
       bRet = DoMouse(static_cast<CFWL_MsgMouse*>(pMessage), pMessageForm);
       break;
     }
-    case FWL_MSGHASH_MouseWheel: {
+    case CFWL_MessageType::MouseWheel: {
       bRet = DoWheel(static_cast<CFWL_MsgMouseWheel*>(pMessage), pMessageForm);
       break;
     }
-    case FWL_MSGHASH_Size: {
+    case CFWL_MessageType::Size: {
       bRet = DoSize(static_cast<CFWL_MsgSize*>(pMessage));
       break;
     }
-    case FWL_MSGHASH_Cursor: {
+    case CFWL_MessageType::Cursor: {
       bRet = TRUE;
       break;
     }
-    case FWL_MSGHASH_WindowMove: {
+    case CFWL_MessageType::WindowMove: {
       bRet = DoWindowMove(static_cast<CFWL_MsgWindowMove*>(pMessage),
                           pMessageForm);
       break;
     }
-    case FWL_MSGHASH_DropFiles: {
+    case CFWL_MessageType::DropFiles: {
       bRet =
           DoDragFiles(static_cast<CFWL_MsgDropFiles*>(pMessage), pMessageForm);
       break;
     }
     default: {
       bRet = TRUE;
       break;
     }
   }
   if (bRet) {
     IFWL_WidgetDelegate* pDelegate = pMessage->m_pDstTarget->SetDelegate(NULL);
-    if (pDelegate) {
+    if (pDelegate)
       pDelegate->OnProcessMessage(pMessage);
-    }
   }
   return bRet;
 }
+
 FX_BOOL CFWL_NoteDriver::DoActivate(CFWL_MsgActivate* pMsg,
                                     IFWL_Widget* pMessageForm) {
   if (m_bFullScreen) {
     return FALSE;
   }
   pMsg->m_pDstTarget = pMessageForm;
   return (pMsg->m_pDstTarget)->GetStates() & FWL_WGTSTATE_Deactivated;
 }
 FX_BOOL CFWL_NoteDriver::DoDeactivate(CFWL_MsgDeactivate* pMsg,
                                       IFWL_Widget* pMessageForm) {
@@ skipping 210 matching lines @@
   m_pHover = pTarget;
   CFWL_MsgMouse msHover;
   msHover.m_pDstTarget = pTarget;
   msHover.m_fx = pMsg->m_fx;
   msHover.m_fy = pMsg->m_fy;
   msHover.m_dwFlags = 0;
   msHover.m_dwCmd = FWL_MSGMOUSECMD_MouseHover;
   DispatchMessage(&msHover, NULL);
 }
 FX_BOOL CFWL_NoteDriver::IsValidMessage(CFWL_Message* pMessage) {
-  if (pMessage->GetClassID() == FWL_MSGHASH_Post) {
+  if (pMessage->GetClassID() == CFWL_MessageType::Post)
     return TRUE;
-  }
+
   int32_t iCount = m_noteLoopQueue.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_NoteLoop* pNoteLoop = static_cast<CFWL_NoteLoop*>(m_noteLoopQueue[i]);
     CFWL_WidgetImp* pForm = pNoteLoop->GetForm();
-    if (pForm && (pForm->GetInterface() == pMessage->m_pDstTarget)) {
+    if (pForm && (pForm->GetInterface() == pMessage->m_pDstTarget))
       return TRUE;
-    }
   }
   iCount = m_forms.GetSize();
   for (int32_t j = 0; j < iCount; j++) {
     CFWL_FormImp* pForm = static_cast<CFWL_FormImp*>(m_forms[j]);
-    if (pForm->GetInterface() == pMessage->m_pDstTarget) {
+    if (pForm->GetInterface() == pMessage->m_pDstTarget)
       return TRUE;
-    }
   }
   return FALSE;
 }
+
 IFWL_Widget* CFWL_NoteDriver::GetMessageForm(IFWL_Widget* pDstTarget) {
   int32_t iTrackLoop = m_noteLoopQueue.GetSize();
   if (iTrackLoop <= 0)
     return NULL;
   IFWL_Widget* pMessageForm = NULL;
   if (iTrackLoop > 1) {
     CFWL_NoteLoop* pNootLoop =
         static_cast<CFWL_NoteLoop*>(m_noteLoopQueue[iTrackLoop - 1]);
     pMessageForm = pNootLoop->GetForm()->GetInterface();
   } else {
@@ skipping 65 matching lines @@
   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();
   }
   return 1;
 }
+
 FX_BOOL CFWL_EventTarget::ProcessEvent(CFWL_Event* pEvent) {
   IFWL_WidgetDelegate* pDelegate = m_pListener->SetDelegate(NULL);
   if (!pDelegate)
     return FALSE;
   if (m_eventSources.GetCount() == 0) {
     pDelegate->OnProcessEvent(pEvent);
     return TRUE;
   }
   FX_POSITION pos = m_eventSources.GetStartPosition();
   while (pos) {
     IFWL_Widget* pSource = NULL;
     uint32_t dwFilter = 0;
     m_eventSources.GetNextAssoc(pos, (void*&)pSource, dwFilter);
     if (pSource == pEvent->m_pSrcTarget ||
-        pEvent->GetClassID() == FWL_EVTHASH_Idle) {
+        pEvent->GetClassID() == CFWL_EventType::Idle) {
       if (IsFilterEvent(pEvent, dwFilter)) {
         pDelegate->OnProcessEvent(pEvent);
         return TRUE;
       }
     }
   }
   return FALSE;
 }
+
 FX_BOOL CFWL_EventTarget::IsFilterEvent(CFWL_Event* pEvent, uint32_t dwFilter) {
-  if (dwFilter == FWL_EVENT_ALL_MASK) {
+  if (dwFilter == FWL_EVENT_ALL_MASK)
     return TRUE;
-  }
+
   FX_BOOL bRet = FALSE;
   switch (pEvent->GetClassID()) {
-    case FWL_EVTHASH_Mouse: {
+    case CFWL_EventType::Mouse: {
       bRet = dwFilter & FWL_EVENT_MOUSE_MASK;
       break;
     }
-    case FWL_EVTHASH_MouseWheel: {
+    case CFWL_EventType::MouseWheel: {
       bRet = dwFilter & FWL_EVENT_MOUSEWHEEL_MASK;
       break;
     }
-    case FWL_EVTHASH_Key: {
+    case CFWL_EventType::Key: {
       bRet = dwFilter & FWL_EVENT_KEY_MASK;
       break;
     }
-    case FWL_EVTHASH_SetFocus:
-    case FWL_EVTHASH_KillFocus: {
+    case CFWL_EventType::SetFocus:
+    case CFWL_EventType::KillFocus: {
       bRet = dwFilter & FWL_EVENT_FOCUSCHANGED_MASK;
       break;
     }
-    case FWL_EVTHASH_Draw: {
+    case CFWL_EventType::Draw: {
       bRet = dwFilter & FWL_EVENT_DRAW_MASK;
       break;
     }
-    case FWL_EVTHASH_Close: {
+    case CFWL_EventType::Close: {
       bRet = dwFilter & FWL_EVENT_CLOSE_MASK;
       break;
     }
-    case FWL_EVTHASH_SizeChanged: {
+    case CFWL_EventType::SizeChanged: {
       bRet = dwFilter & FWL_EVENT_SIZECHANGED_MASK;
       break;
     }
-    case FWL_EVTHASH_Idle: {
+    case CFWL_EventType::Idle: {
       bRet = dwFilter & FWL_EVENT_IDLE_MASK;
       break;
     }
     default: {
       bRet = dwFilter & FWL_EVENT_CONTROL_MASK;
       break;
     }
   }
   return bRet;
 }
@@ skipping 113 matching lines @@
   if (HasToolTip(pEvt->m_pDstTarget) && NULL != m_pToolTipImp) {
     m_pToolTipImp->Hide();
     pCurTarget = NULL;
     return TRUE;
   }
   return FALSE;
 }
 IFWL_ToolTipTarget* CFWL_ToolTipContainer::GetCurrentToolTipTarget() {
   return pCurTarget;
 }