More FWL interface cleanup.

xfa/fwl/core/fwl_widgetimp.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_widgetimp.h"
 
 #include <algorithm>
 
 #include "xfa/fde/tto/fde_textout.h"
 #include "xfa/fwl/basewidget/ifwl_combobox.h"
 #include "xfa/fwl/basewidget/ifwl_datetimepicker.h"
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/cfwl_themebackground.h"
 #include "xfa/fwl/core/cfwl_themepart.h"
 #include "xfa/fwl/core/cfwl_themetext.h"
 #include "xfa/fwl/core/fwl_appimp.h"
 #include "xfa/fwl/core/fwl_noteimp.h"
-#include "xfa/fwl/core/fwl_targetimp.h"
-#include "xfa/fwl/core/fwl_threadimp.h"
 #include "xfa/fwl/core/fwl_widgetmgrimp.h"
 #include "xfa/fwl/core/ifwl_adapternative.h"
 #include "xfa/fwl/core/ifwl_adapterthreadmgr.h"
 #include "xfa/fwl/core/ifwl_adapterwidgetmgr.h"
 #include "xfa/fwl/core/ifwl_app.h"
 #include "xfa/fwl/core/ifwl_form.h"
 #include "xfa/fwl/core/ifwl_themeprovider.h"
 
 #define FWL_CLASSHASH_Menu 3957949655
 #define FWL_STYLEEXT_MNU_Vert (1L << 0)
 
+IFWL_Widget::~IFWL_Widget() {
+  delete m_pImpl;

[Tom Sepez, 2016/04/27 20:23:34]

nit: unique_ptr

[dsinclair, 2016/04/27 20:58:55]

Done.

+}
+
+FWL_ERR IFWL_Widget::GetClassName(CFX_WideString& wsClass) const {
+  return m_pImpl->GetClassName(wsClass);
+}
+
+uint32_t IFWL_Widget::GetClassID() const {
+  return m_pImpl->GetClassID();
+}
+
+FX_BOOL IFWL_Widget::IsInstance(const CFX_WideStringC& wsClass) const {
+  return m_pImpl->IsInstance(wsClass);
+}
+
+FWL_ERR IFWL_Widget::Initialize() {
+  return m_pImpl->Initialize();
+}
+
+FWL_ERR IFWL_Widget::Finalize() {
+  return m_pImpl->Finalize();
+}
+
 FWL_ERR IFWL_Widget::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
   return static_cast<CFWL_WidgetImp*>(GetImpl())
       ->GetWidgetRect(rect, bAutoSize);
 }
 FWL_ERR IFWL_Widget::GetGlobalRect(CFX_RectF& rect) {
   return static_cast<CFWL_WidgetImp*>(GetImpl())->GetGlobalRect(rect);
 }
 FWL_ERR IFWL_Widget::SetWidgetRect(const CFX_RectF& rect) {
   return static_cast<CFWL_WidgetImp*>(GetImpl())->SetWidgetRect(rect);
 }
@@ skipping 84 matching lines @@
   return static_cast<CFWL_WidgetImp*>(GetImpl())
       ->SetThemeProvider(pThemeProvider);
 }
 FWL_ERR IFWL_Widget::SetDataProvider(IFWL_DataProvider* pDataProvider) {
   return static_cast<CFWL_WidgetImp*>(GetImpl())
       ->SetDataProvider(pDataProvider);
 }
 IFWL_WidgetDelegate* IFWL_Widget::SetDelegate(IFWL_WidgetDelegate* pDelegate) {
   return static_cast<CFWL_WidgetImp*>(GetImpl())->SetDelegate(pDelegate);
 }
-IFWL_Thread* IFWL_Widget::GetOwnerThread() const {
+IFWL_App* IFWL_Widget::GetOwnerThread() const {
   return static_cast<CFWL_WidgetImp*>(GetImpl())->GetOwnerThread();
 }
 CFX_SizeF IFWL_Widget::GetOffsetFromParent(IFWL_Widget* pParent) {
   return static_cast<CFWL_WidgetImp*>(GetImpl())->GetOffsetFromParent(pParent);
 }
+
 FWL_ERR CFWL_WidgetImp::Initialize() {
   IFWL_App* pApp = FWL_GetApp();
   if (!pApp)
     return FWL_ERR_Indefinite;
   IFWL_AdapterNative* pAdapter = pApp->GetAdapterNative();
   if (!pAdapter)
     return FWL_ERR_Indefinite;
   IFWL_AdapterThreadMgr* pAdapterThread = pAdapter->GetThreadMgr();
   if (!pAdapterThread)
     return FWL_ERR_Indefinite;
-  SetOwnerThread(static_cast<CFWL_ThreadImp*>(
-      pAdapterThread->GetCurrentThread()->GetImpl()));
+  SetOwnerThread(
+      static_cast<CFWL_AppImp*>(pAdapterThread->GetCurrentThread()->GetImpl()));
   IFWL_Widget* pParent = m_pProperties->m_pParent;
   m_pWidgetMgr->InsertWidget(pParent, m_pInterface);
   if (!IsChild()) {
     {
       IFWL_Widget* pOwner = m_pProperties->m_pOwner;
       if (pOwner) {
         m_pWidgetMgr->SetOwner(pOwner, m_pInterface);
       }
     }
     m_pWidgetMgr->CreateWidget_Native(m_pInterface);
   }
   return FWL_ERR_Succeeded;
 }
+
 FWL_ERR CFWL_WidgetImp::Finalize() {
   NotifyDriver();
   if (!IsChild())
     m_pWidgetMgr->DestroyWidget_Native(m_pInterface);
 
   m_pWidgetMgr->RemoveWidget(m_pInterface);
   return FWL_ERR_Succeeded;
 }
+
+FWL_ERR CFWL_WidgetImp::GetClassName(CFX_WideString& wsClass) const {
+  wsClass.clear();
+  return FWL_ERR_Succeeded;
+}
+
+uint32_t CFWL_WidgetImp::GetClassID() const {
+  return 0;
+}
+
+FX_BOOL CFWL_WidgetImp::IsInstance(const CFX_WideStringC& wsClass) const {
+  return FALSE;
+}
+
 FWL_ERR CFWL_WidgetImp::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
   if (bAutoSize) {
     if (HasEdge()) {
       FX_FLOAT fEdge = GetEdgeWidth();
       rect.Inflate(fEdge, fEdge);
     }
     if (HasBorder()) {
       FX_FLOAT fBorder = GetBorderSize();
       rect.Inflate(fBorder, fBorder);
     }
@@ skipping 304 matching lines @@
   if (!m_pCurDelegate) {
     m_pCurDelegate = m_pDelegate;
   }
   if (!pDelegate) {
     return m_pCurDelegate;
   }
   IFWL_WidgetDelegate* pOldDelegate = m_pCurDelegate;
   m_pCurDelegate = pDelegate;
   return pOldDelegate;
 }
-IFWL_Thread* CFWL_WidgetImp::GetOwnerThread() const {
-  return static_cast<IFWL_Thread*>(m_pOwnerThread->GetInterface());
+IFWL_App* CFWL_WidgetImp::GetOwnerThread() const {
+  return static_cast<IFWL_App*>(m_pOwnerThread->GetInterface());
 }
-FWL_ERR CFWL_WidgetImp::SetOwnerThread(CFWL_ThreadImp* pOwnerThread) {
+FWL_ERR CFWL_WidgetImp::SetOwnerThread(CFWL_AppImp* pOwnerThread) {
   m_pOwnerThread = pOwnerThread;
   return FWL_ERR_Succeeded;
 }
 IFWL_Widget* CFWL_WidgetImp::GetInterface() const {
   return m_pInterface;
 }
 void CFWL_WidgetImp::SetInterface(IFWL_Widget* pInterface) {
   m_pInterface = pInterface;
 }
 CFWL_WidgetImp::CFWL_WidgetImp(const CFWL_WidgetImpProperties& properties,
@@ skipping 161 matching lines @@
   CFWL_ThemeText calPart;
   calPart.m_pWidget = m_pInterface;
   calPart.m_wsText = wsText;
   calPart.m_dwTTOStyles = dwTTOStyles;
   calPart.m_iTTOAlign = iTTOAlign;
   pTheme->CalcTextRect(&calPart, rect);
 }
 void CFWL_WidgetImp::SetFocus(FX_BOOL bFocus) {
   if (m_pWidgetMgr->IsFormDisabled())
     return;
-  IFWL_Thread* pThread = GetOwnerThread();
+  IFWL_App* pThread = GetOwnerThread();
   if (!pThread)
     return;
   CFWL_NoteDriver* pDriver =
       static_cast<CFWL_NoteDriver*>(pThread->GetNoteDriver());
   if (!pDriver)
     return;
   IFWL_Widget* curFocus = pDriver->GetFocus();
   if (bFocus && curFocus != m_pInterface) {
     pDriver->SetFocus(m_pInterface);
   } else if (!bFocus && curFocus == m_pInterface) {
     pDriver->SetFocus(NULL);
   }
 }
 void CFWL_WidgetImp::SetGrab(FX_BOOL bSet) {
-  IFWL_Thread* pThread = GetOwnerThread();
+  IFWL_App* pThread = GetOwnerThread();
   if (!pThread)
     return;
   CFWL_NoteDriver* pDriver =
       static_cast<CFWL_NoteDriver*>(pThread->GetNoteDriver());
   pDriver->SetGrab(m_pInterface, bSet);
 }
 FX_BOOL CFWL_WidgetImp::GetPopupPos(FX_FLOAT fMinHeight,
                                     FX_FLOAT fMaxHeight,
                                     const CFX_RectF& rtAnchor,
                                     CFX_RectF& rtPopup) {
@@ skipping 95 matching lines @@
                 rtPopup.height);
   }
   rtPopup.Offset(fx, fy);
   return TRUE;
 }
 FX_BOOL CFWL_WidgetImp::GetScreenSize(FX_FLOAT& fx, FX_FLOAT& fy) {
   return FALSE;
 }
 void CFWL_WidgetImp::RegisterEventTarget(IFWL_Widget* pEventSource,
                                          uint32_t dwFilter) {
-  IFWL_Thread* pThread = GetOwnerThread();
+  IFWL_App* pThread = GetOwnerThread();
   if (!pThread)
     return;
-  IFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
+  CFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
   if (!pNoteDriver)
     return;
   pNoteDriver->RegisterEventTarget(m_pInterface, pEventSource, dwFilter);
 }
 void CFWL_WidgetImp::UnregisterEventTarget() {
-  IFWL_Thread* pThread = GetOwnerThread();
+  IFWL_App* pThread = GetOwnerThread();
   if (!pThread)
     return;
-  IFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
+  CFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
   if (!pNoteDriver)
     return;
   pNoteDriver->UnregisterEventTarget(m_pInterface);
 }
 void CFWL_WidgetImp::DispatchKeyEvent(CFWL_MsgKey* pNote) {
   if (!pNote)
     return;
   CFWL_EvtKey* pEvent = new CFWL_EvtKey;
   pEvent->m_pSrcTarget = m_pInterface;
   pEvent->m_dwCmd = pNote->m_dwCmd;
   pEvent->m_dwKeyCode = pNote->m_dwKeyCode;
   pEvent->m_dwFlags = pNote->m_dwFlags;
   DispatchEvent(pEvent);
   pEvent->Release();
 }
 void CFWL_WidgetImp::DispatchEvent(CFWL_Event* pEvent) {
   if (m_pOuter) {
     IFWL_WidgetDelegate* pDelegate = m_pOuter->SetDelegate(NULL);
     pDelegate->OnProcessEvent(pEvent);
     return;
   }
-  IFWL_Thread* pThread = GetOwnerThread();
+  IFWL_App* pThread = GetOwnerThread();
   if (!pThread)
     return;
-  IFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
+  CFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
   if (!pNoteDriver)
     return;
   pNoteDriver->SendEvent(pEvent);
 }
 void CFWL_WidgetImp::Repaint(const CFX_RectF* pRect) {
   if (pRect) {
     m_pWidgetMgr->RepaintWidget(m_pInterface, pRect);
     return;
   }
   CFX_RectF rect;
@@ skipping 43 matching lines @@
   param.m_pWidget = m_pInterface;
   param.m_iPart = iPartEdge;
   param.m_pGraphics = pGraphics;
   if (pMatrix) {
     param.m_matrix.Concat(*pMatrix, TRUE);
   }
   param.m_rtPart = rtEdge;
   pTheme->DrawBackground(&param);
 }
 void CFWL_WidgetImp::NotifyDriver() {
-  IFWL_Thread* pThread = GetOwnerThread();
+  IFWL_App* pThread = GetOwnerThread();
   if (!pThread)
     return;
   CFWL_NoteDriver* pDriver =
       static_cast<CFWL_NoteDriver*>(pThread->GetNoteDriver());
   if (!pDriver)
     return;
   pDriver->NotifyTargetDestroy(m_pInterface);
 }
 CFX_SizeF CFWL_WidgetImp::GetOffsetFromParent(IFWL_Widget* pParent) {
   if (pParent == GetInterface())
@@ skipping 100 matching lines @@
 FWL_ERR CFWL_WidgetImpDelegate::OnProcessEvent(CFWL_Event* pEvent) {
   return FWL_ERR_Succeeded;
 }
 
 FWL_ERR CFWL_WidgetImpDelegate::OnDrawWidget(CFX_Graphics* pGraphics,
                                              const CFX_Matrix* pMatrix) {
   CFWL_EvtDraw evt;
   evt.m_pGraphics = pGraphics;
   return FWL_ERR_Succeeded;
 }