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() {}
+
+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 {
-  return static_cast<CFWL_WidgetImp*>(GetImpl())->GetOwnerThread();
+IFWL_App* IFWL_Widget::GetOwnerApp() const {
+  return static_cast<CFWL_WidgetImp*>(GetImpl())->GetOwnerApp();
 }
 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()));
+  SetOwnerApp(
+      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 93 matching lines @@
   }
 }
 FWL_ERR CFWL_WidgetImp::SetStates(uint32_t dwStates, FX_BOOL bSet) {
   bSet ? (m_pProperties->m_dwStates |= dwStates)
        : (m_pProperties->m_dwStates &= ~dwStates);
   FWL_ERR ret = FWL_ERR_Succeeded;
   if (dwStates & FWL_WGTSTATE_Invisible) {
     if (bSet) {
       ret = m_pWidgetMgr->HideWidget_Native(m_pInterface);
       CFWL_NoteDriver* noteDriver =
-          static_cast<CFWL_NoteDriver*>(GetOwnerThread()->GetNoteDriver());
+          static_cast<CFWL_NoteDriver*>(GetOwnerApp()->GetNoteDriver());
       IFWL_WidgetMgr* widgetMgr = FWL_GetWidgetMgr();
       noteDriver->NotifyTargetHide(m_pInterface);
       IFWL_Widget* child =
           widgetMgr->GetWidget(m_pInterface, FWL_WGTRELATION_FirstChild);
       while (child) {
         noteDriver->NotifyTargetHide(child);
         NotifyHideChildWidget(widgetMgr, child, noteDriver);
         child = widgetMgr->GetWidget(child, FWL_WGTRELATION_NextSibling);
       }
     } else {
@@ skipping 190 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::GetOwnerApp() const {
+  return static_cast<IFWL_App*>(m_pOwnerApp->GetInterface());
 }
-FWL_ERR CFWL_WidgetImp::SetOwnerThread(CFWL_ThreadImp* pOwnerThread) {
-  m_pOwnerThread = pOwnerThread;
+FWL_ERR CFWL_WidgetImp::SetOwnerApp(CFWL_AppImp* pOwnerApp) {
+  m_pOwnerApp = pOwnerApp;
   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,
                                IFWL_Widget* pOuter)
@@ skipping 160 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();
-  if (!pThread)
+
+  IFWL_App* pApp = GetOwnerApp();
+  if (!pApp)
     return;
+
   CFWL_NoteDriver* pDriver =
-      static_cast<CFWL_NoteDriver*>(pThread->GetNoteDriver());
+      static_cast<CFWL_NoteDriver*>(pApp->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();
-  if (!pThread)
+  IFWL_App* pApp = GetOwnerApp();
+  if (!pApp)
     return;
   CFWL_NoteDriver* pDriver =
-      static_cast<CFWL_NoteDriver*>(pThread->GetNoteDriver());
+      static_cast<CFWL_NoteDriver*>(pApp->GetNoteDriver());
   pDriver->SetGrab(m_pInterface, bSet);
 }
 FX_BOOL CFWL_WidgetImp::GetPopupPos(FX_FLOAT fMinHeight,
                                     FX_FLOAT fMaxHeight,
                                     const CFX_RectF& rtAnchor,
                                     CFX_RectF& rtPopup) {
   if (GetClassID() == FWL_CLASSHASH_Menu) {
     return GetPopupPosMenu(fMinHeight, fMaxHeight, rtAnchor, rtPopup);
   } else {
     if (GetClassID() == FWL_CLASSHASH_ComboBox) {
@@ skipping 91 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();
-  if (!pThread)
+  IFWL_App* pApp = GetOwnerApp();
+  if (!pApp)
     return;
-  IFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
+
+  CFWL_NoteDriver* pNoteDriver = pApp->GetNoteDriver();
   if (!pNoteDriver)
     return;
+
   pNoteDriver->RegisterEventTarget(m_pInterface, pEventSource, dwFilter);
 }
 void CFWL_WidgetImp::UnregisterEventTarget() {
-  IFWL_Thread* pThread = GetOwnerThread();
-  if (!pThread)
+  IFWL_App* pApp = GetOwnerApp();
+  if (!pApp)
     return;
-  IFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
+
+  CFWL_NoteDriver* pNoteDriver = pApp->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();
-  if (!pThread)
+  IFWL_App* pApp = GetOwnerApp();
+  if (!pApp)
     return;
-  IFWL_NoteDriver* pNoteDriver = pThread->GetNoteDriver();
+  CFWL_NoteDriver* pNoteDriver = pApp->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();
-  if (!pThread)
+  IFWL_App* pApp = GetOwnerApp();
+  if (!pApp)
     return;
+
   CFWL_NoteDriver* pDriver =
-      static_cast<CFWL_NoteDriver*>(pThread->GetNoteDriver());
+      static_cast<CFWL_NoteDriver*>(pApp->GetNoteDriver());
   if (!pDriver)
     return;
+
   pDriver->NotifyTargetDestroy(m_pInterface);
 }
 CFX_SizeF CFWL_WidgetImp::GetOffsetFromParent(IFWL_Widget* pParent) {
   if (pParent == GetInterface())
     return CFX_SizeF();
 
   IFWL_WidgetMgr* pWidgetMgr = FWL_GetWidgetMgr();
   if (!pWidgetMgr)
     return CFX_SizeF();
 
@@ skipping 94 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;
 }