Merge to XFA: Remove header files that only have includes.

fpdfsdk/src/pdfwindow/PWL_Wnd.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 <map>
 
-#include "fpdfsdk/include/pdfwindow/PDFWindow.h"
 #include "fpdfsdk/include/pdfwindow/PWL_ScrollBar.h"
 #include "fpdfsdk/include/pdfwindow/PWL_Utils.h"
 #include "fpdfsdk/include/pdfwindow/PWL_Wnd.h"
 
-/* -------------------------- CPWL_Timer -------------------------- */
-
 static std::map<int32_t, CPWL_Timer*>& GetPWLTimeMap() {
   // Leak the object at shutdown.
   static auto timeMap = new std::map<int32_t, CPWL_Timer*>;
   return *timeMap;
 }
 
 CPWL_Timer::CPWL_Timer(CPWL_TimerHandler* pAttached,
                        IFX_SystemHandler* pSystemHandler)
     : m_nTimerID(0), m_pAttached(pAttached), m_pSystemHandler(pSystemHandler) {
   ASSERT(m_pAttached);
@@ skipping 25 matching lines @@
 void CPWL_Timer::TimerProc(int32_t idEvent) {
   auto it = GetPWLTimeMap().find(idEvent);
   if (it == GetPWLTimeMap().end())
     return;
 
   CPWL_Timer* pTimer = it->second;
   if (pTimer->m_pAttached)
     pTimer->m_pAttached->TimerProc();
 }
 
-/* -------------------------- CPWL_TimerHandler -------------------------- */
-
 CPWL_TimerHandler::CPWL_TimerHandler() : m_pTimer(NULL) {}
 
 CPWL_TimerHandler::~CPWL_TimerHandler() {
   delete m_pTimer;
 }
 
 void CPWL_TimerHandler::BeginTimer(int32_t nElapse) {
   if (!m_pTimer)
     m_pTimer = new CPWL_Timer(this, GetSystemHandler());
 
   if (m_pTimer)
     m_pTimer->SetPWLTimer(nElapse);
 }
 
 void CPWL_TimerHandler::EndTimer() {
   if (m_pTimer)
     m_pTimer->KillPWLTimer();
 }
 
 void CPWL_TimerHandler::TimerProc() {}
 
-/* --------------------------- CPWL_MsgControl ---------------------------- */
-
 class CPWL_MsgControl {
   friend class CPWL_Wnd;
 
  public:
-  CPWL_MsgControl(CPWL_Wnd* pWnd) {
-    //      PWL_TRACE("new CPWL_MsgControl\n");
+  explicit CPWL_MsgControl(CPWL_Wnd* pWnd) {
     m_pCreatedWnd = pWnd;
     Default();
   }
 
   ~CPWL_MsgControl() {
-    //      PWL_TRACE("~CPWL_MsgControl\n");
     Default();
   }
 
   void Default() {
     m_aMousePath.RemoveAll();
     m_aKeyboardPath.RemoveAll();
     m_pMainMouseWnd = NULL;
     m_pMainKeyboardWnd = NULL;
   }
 
   FX_BOOL IsWndCreated(const CPWL_Wnd* pWnd) const {
     return m_pCreatedWnd == pWnd;
   }
 
   FX_BOOL IsMainCaptureMouse(const CPWL_Wnd* pWnd) const {
     return pWnd == m_pMainMouseWnd;
   }
 
   FX_BOOL IsWndCaptureMouse(const CPWL_Wnd* pWnd) const {
-    if (pWnd)
-      for (int32_t i = 0, sz = m_aMousePath.GetSize(); i < sz; i++)
+    if (pWnd) {
+      for (int32_t i = 0, sz = m_aMousePath.GetSize(); i < sz; i++) {
         if (m_aMousePath.GetAt(i) == pWnd)
           return TRUE;
+      }
+    }
 
     return FALSE;
   }
 
   FX_BOOL IsMainCaptureKeyboard(const CPWL_Wnd* pWnd) const {
     return pWnd == m_pMainKeyboardWnd;
   }
 
   FX_BOOL IsWndCaptureKeyboard(const CPWL_Wnd* pWnd) const {
-    if (pWnd)
-      for (int32_t i = 0, sz = m_aKeyboardPath.GetSize(); i < sz; i++)
+    if (pWnd) {
+      for (int32_t i = 0, sz = m_aKeyboardPath.GetSize(); i < sz; i++) {
         if (m_aKeyboardPath.GetAt(i) == pWnd)
           return TRUE;
+      }
+    }
 
     return FALSE;
   }
 
   void SetFocus(CPWL_Wnd* pWnd) {
     m_aKeyboardPath.RemoveAll();
 
     if (pWnd) {
       m_pMainKeyboardWnd = pWnd;
 
@@ skipping 36 matching lines @@
   }
 
  private:
   CFX_ArrayTemplate<CPWL_Wnd*> m_aMousePath;
   CFX_ArrayTemplate<CPWL_Wnd*> m_aKeyboardPath;
   CPWL_Wnd* m_pCreatedWnd;
   CPWL_Wnd* m_pMainMouseWnd;
   CPWL_Wnd* m_pMainKeyboardWnd;
 };
 
-/* --------------------------- CPWL_Wnd ---------------------------- */
-
 CPWL_Wnd::CPWL_Wnd()
     : m_pVScrollBar(NULL),
       m_rcWindow(),
       m_rcClip(),
       m_bCreated(FALSE),
       m_bVisible(FALSE),
       m_bNotifying(FALSE),
       m_bEnabled(TRUE) {}
 
 CPWL_Wnd::~CPWL_Wnd() {
@@ skipping 411 matching lines @@
 }
 
 int32_t CPWL_Wnd::GetBorderWidth() const {
   if (HasFlag(PWS_BORDER))
     return m_sPrivateParam.dwBorderWidth;
 
   return 0;
 }
 
 int32_t CPWL_Wnd::GetInnerBorderWidth() const {
-  /*
-  switch (GetBorderStyle())
-  {
-  case PBS_BEVELED:
-  case PBS_INSET:
-      return GetBorderWidth() / 2;
-  }
-  */
   return 0;
 }
 
 void CPWL_Wnd::SetBorderWidth(int32_t nBorderWidth) {
   if (HasFlag(PWS_BORDER))
     m_sPrivateParam.dwBorderWidth = nBorderWidth;
 }
 
 CPWL_Color CPWL_Wnd::GetBorderColor() const {
   if (HasFlag(PWS_BORDER))
@@ skipping 254 matching lines @@
     case PBS_INSET:
       color = CPWL_Color(COLORTYPE_GRAY, 0.75f);
       break;
     case PBS_UNDERLINED:
       break;
   }
 
   return color;
 }
 
-/* ----------------------------------------------------------------- */
-
 int32_t CPWL_Wnd::GetTransparency() {
   return m_sPrivateParam.nTransparency;
 }
 
 void CPWL_Wnd::SetTransparency(int32_t nTransparency) {
   for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
     if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
       pChild->SetTransparency(nTransparency);
     }
   }
@@ skipping 154 matching lines @@
   return FALSE;
 }
 
 FX_BOOL CPWL_Wnd::IsINSERTpressed(FX_DWORD nFlag) const {
   if (IFX_SystemHandler* pSystemHandler = GetSystemHandler()) {
     return pSystemHandler->IsINSERTKeyDown(nFlag);
   }
 
   return FALSE;
 }