[ATSPI] Apply multi-window to ATSPI

- Updated ATSPI codes to tell which window is visible or focused now.
- DevelWindow::VisibilityChangedSignal is used to check
  whether the window is shown or not.
- Added Window::FocusChangeSignal to check whether the window is
activated.

 1. Window show / hide -> object:state-chaged:showing
 2. Window focus / unfocus -> WindowEvent::ACTIVATE

Change-Id: I38a6f8f67c303234857a57e8d812511942a95917
Signed-off-by: Seoyeon Kim <seoyeon2.kim@samsung.com>

diff --git a/dali/devel-api/adaptor-framework/accessibility-impl.cpp b/dali/devel-api/adaptor-framework/accessibility-impl.cpp
index 3a96638..774915f 100644 (file)
--- a/dali/devel-api/adaptor-framework/accessibility-impl.cpp
+++ b/dali/devel-api/adaptor-framework/accessibility-impl.cpp
@@ -593,7 +593,7 @@ void Bridge::SetIsOnRootLevel(Accessible* owner)
 
 namespace
 {
-class NonControlAccessible : public virtual Accessible, public virtual Collection, public virtual Component
+class AdaptorAccessible : public virtual Accessible, public virtual Collection, public virtual Component
 {
 protected:
   Dali::WeakHandle<Dali::Actor> mSelf;
@@ -603,7 +603,7 @@ protected:
   {
     auto handle = mSelf.GetHandle();
 
-    // NonControlAccessible is deleted on ObjectDestroyedSignal
+    // AdaptorAccessible is deleted on ObjectDestroyedSignal
     // for the respective actor (see `nonControlAccessibles`).
     DALI_ASSERT_ALWAYS(handle);
 
@@ -611,7 +611,7 @@ protected:
   }
 
 public:
-  NonControlAccessible(Dali::Actor actor, bool isRoot)
+  AdaptorAccessible(Dali::Actor actor, bool isRoot)
   : mSelf(actor),
     mRoot(isRoot)
   {
@@ -772,11 +772,17 @@ public:
   {
     return {};
   }
-};
 
-using NonControlAccessiblesType = std::unordered_map<const Dali::RefObject*, std::unique_ptr<NonControlAccessible> >;
+  Dali::Actor GetInternalActor() override
+  {
+    return mSelf.GetHandle();
+  }
+}; // AdaptorAccessible
 
-NonControlAccessiblesType nonControlAccessibles;
+using AdaptorAccessiblesType = std::unordered_map<const Dali::RefObject*, std::unique_ptr<AdaptorAccessible> >;
+
+// Save RefObject from an Actor in Accessible::Get()
+AdaptorAccessiblesType gAdaptorAccessibles;
 
 std::function<Accessible*(Dali::Actor)> convertingFunctor = [](Dali::Actor) -> Accessible* {
   return nullptr;
@@ -790,7 +796,7 @@ void Accessible::SetObjectRegistry(ObjectRegistry registry)
   objectRegistry = registry;
 }
 
-void Accessible::RegisterControlAccessibilityGetter(std::function<Accessible*(Dali::Actor)> functor)
+void Accessible::RegisterExternalAccessibleGetter(std::function<Accessible*(Dali::Actor)> functor)
 {
   convertingFunctor = functor;
 }
@@ -805,18 +811,19 @@ Accessible* Accessible::Get(Dali::Actor actor, bool isRoot)
   auto accessible = convertingFunctor(actor);
   if(!accessible)
   {
-    if(nonControlAccessibles.empty() && objectRegistry)
+    if(gAdaptorAccessibles.empty() && objectRegistry)
     {
       objectRegistry.ObjectDestroyedSignal().Connect([](const Dali::RefObject* obj) {
-        nonControlAccessibles.erase(obj);
+        gAdaptorAccessibles.erase(obj);
       });
     }
-    auto pair = nonControlAccessibles.emplace(&actor.GetBaseObject(), nullptr);
+    auto pair = gAdaptorAccessibles.emplace(&actor.GetBaseObject(), nullptr);
     if(pair.second)
     {
-      pair.first->second.reset(new NonControlAccessible(actor, isRoot));
+      pair.first->second.reset(new AdaptorAccessible(actor, isRoot));
     }
     accessible = pair.first->second.get();
   }
+
   return accessible;
 }

diff --git a/dali/devel-api/adaptor-framework/accessibility-impl.h b/dali/devel-api/adaptor-framework/accessibility-impl.h
index dfe1f6b..f600086 100644 (file)
--- a/dali/devel-api/adaptor-framework/accessibility-impl.h
+++ b/dali/devel-api/adaptor-framework/accessibility-impl.h
@@ -35,6 +35,7 @@
 
 //INTERNAL INCLUDES
 #include <dali/devel-api/adaptor-framework/accessibility.h>
+#include <dali/public-api/adaptor-framework/window.h>
 #include <dali/integration-api/debug.h>
 
 namespace Dali
@@ -147,13 +148,31 @@ struct DALI_ADAPTOR_API Bridge
 
   /**
    * @brief Notifies accessibility dbus that window has just been shown.
+   *
+   * @param[in] window The window to be shown
    */
-  virtual void WindowShown() = 0;
+  virtual void WindowShown(Window window) = 0;
 
   /**
    * @brief Notifies accessibility dbus that window has just been hidden.
+   *
+   * @param[in] window The window to be hidden
    */
-  virtual void WindowHidden() = 0;
+  virtual void WindowHidden(Window window) = 0;
+
+  /**
+   * @brief Notifies accessibility dbus that window has just been focused.
+   *
+   * @param[in] window The window to be focused
+   */
+  virtual void WindowFocused(Window window) = 0;
+
+  /**
+   * @brief Notifies accessibility dbus that window has just been out of focus.
+   *
+   * @param[in] window The window to be out of focus
+   */
+  virtual void WindowUnfocused(Window window) = 0;
 
   /**
    * @brief Initializes accessibility bus.
@@ -720,6 +739,13 @@ public:
   virtual std::vector<Relation> GetRelationSet() = 0;
 
   /**
+   * @brief Gets internal Actor to be saved before.
+   *
+   * @return The internal Actor
+   */
+  virtual Dali::Actor GetInternalActor() = 0;
+
+  /**
    * @brief Gets all implemented interfaces.
    *
    * @return The collection of strings with implemented interfaces
@@ -736,22 +762,6 @@ public:
     return mIsOnRootLevel;
   }
 
-  /**
-   * @brief The method registers functor resposible for converting Actor into Accessible.
-   * @param functor The returning Accessible handle from Actor object
-   */
-  static void RegisterControlAccessibilityGetter(std::function<Accessible*(Dali::Actor)> functor);
-
-  /**
-   * @brief Acquires Accessible object from Actor object.
-   *
-   * @param[in] actor Actor object
-   * @param[in] isRoot True, if it's top level object (window)
-   *
-   * @return The handle to Accessible object
-   */
-  static Accessible* Get(Dali::Actor actor, bool isRoot = false);
-
 protected:
   Accessible();
   Accessible(const Accessible&)         = delete;
@@ -798,12 +808,29 @@ public:
    */
   static void SetObjectRegistry(ObjectRegistry registry);
 
+  /**
+   * @brief The method registers functor resposible for converting Actor into Accessible.
+   * @param functor The returning Accessible handle from Actor object
+   */
+  static void RegisterExternalAccessibleGetter(std::function<Accessible*(Dali::Actor)> functor);
+
+  /**
+   * @brief Acquires Accessible object from Actor object.
+   *
+   * @param[in] actor Actor object
+   * @param[in] isRoot True, if it's top level object (window)
+   *
+   * @return The handle to Accessible object
+   */
+  static Accessible* Get(Dali::Actor actor, bool isRoot = false);
+
 private:
   friend class Bridge;
 
   std::weak_ptr<Bridge::Data> mBridgeData;
   bool                        mIsOnRootLevel = false;
-};
+
+}; // Accessible class
 
 /**
  * @brief Interface enabling to perform provided actions.
@@ -1387,6 +1414,11 @@ public:
     return {};
   }
 
+  Dali::Actor GetInternalActor() override
+  {
+    return Dali::Actor{};
+  }
+
 private:
   Address mAddress;
 };

diff --git a/dali/internal/accessibility/bridge/bridge-base.cpp b/dali/internal/accessibility/bridge/bridge-base.cpp
index ee1987f..23c6c60 100644 (file)
--- a/dali/internal/accessibility/bridge/bridge-base.cpp
+++ b/dali/internal/accessibility/bridge/bridge-base.cpp
@@ -19,6 +19,7 @@
 #include <dali/internal/accessibility/bridge/bridge-base.h>
 
 // EXTERNAL INCLUDES
+#include <dali/devel-api/common/stage.h>
 #include <atomic>
 #include <cstdlib>
 #include <memory>
@@ -30,12 +31,14 @@ using namespace Dali::Accessibility;
 
 static Dali::Timer tickTimer;
 
-BridgeBase::~BridgeBase()
+BridgeBase::BridgeBase()
 {
 }
 
-BridgeBase::BridgeBase()
+BridgeBase::~BridgeBase()
 {
+  mApplication.mChildren.clear();
+  mApplication.mWindows.clear();
 }
 
 void BridgeBase::AddFilteredEvent(FilteredEvents kind, Dali::Accessibility::Accessible* obj, float delay, std::function<void()> functor)
@@ -217,17 +220,76 @@ void BridgeBase::RemovePopup(Accessible* object)
   }
 }
 
-void BridgeBase::AddTopLevelWindow(Accessible* root)
+void BridgeBase::OnWindowVisibilityChanged(Dali::Window window, bool visible)
+{
+  if(visible)
+  {
+    // TODO : Should we check 'out of screen' here? -> Then, we need an actor of this change.
+    Dali::Accessibility::Bridge::GetCurrentBridge()->WindowShown(window); // Called when Window is shown.
+  }
+  else
+  {
+    Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden(window); // Called when Window is hidden and iconified.
+  }
+
+}
+
+void BridgeBase::OnWindowFocusChanged(Dali::Window window, bool focusIn)
+{
+  if(focusIn)
+  {
+    Dali::Accessibility::Bridge::GetCurrentBridge()->WindowFocused(window); // Called when Window is focused.
+  }
+  else
+  {
+    Dali::Accessibility::Bridge::GetCurrentBridge()->WindowUnfocused(window); // Called when Window is out of focus.
+  }
+}
+
+void BridgeBase::AddTopLevelWindow(Accessible* windowAccessible)
 {
-  mApplication.mChildren.push_back(root);
-  SetIsOnRootLevel(root);
+  if(windowAccessible->GetInternalActor() == nullptr)
+  {
+    return;
+  }
+
+  // Prevent adding the default window twice.
+  if(!mApplication.mChildren.empty() &&
+     mApplication.mChildren[0]->GetInternalActor() == windowAccessible->GetInternalActor())
+  {
+    return;
+  }
+
+  // Adds Window to a list of Windows.
+  mApplication.mChildren.push_back(windowAccessible);
+  SetIsOnRootLevel(windowAccessible);
+
+  Dali::Window window = Dali::DevelWindow::Get(windowAccessible->GetInternalActor());
+  if(window)
+  {
+    mApplication.mWindows.push_back(window);
+    Dali::DevelWindow::VisibilityChangedSignal(window).Connect(this, &BridgeBase::OnWindowVisibilityChanged);
+    window.FocusChangeSignal().Connect(this, &BridgeBase::OnWindowFocusChanged);
+  }
 }
 
-void BridgeBase::RemoveTopLevelWindow(Accessible* root)
+void BridgeBase::RemoveTopLevelWindow(Accessible* windowAccessible)
 {
+  for(auto i = 0u; i < mApplication.mWindows.size(); ++i)
+  {
+    if(windowAccessible->GetInternalActor() == mApplication.mWindows[i].GetRootLayer())
+    {
+      Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden(mApplication.mWindows[i]);
+      Dali::DevelWindow::VisibilityChangedSignal(mApplication.mWindows[i]).Disconnect(this, &BridgeBase::OnWindowVisibilityChanged);
+      mApplication.mWindows[i].FocusChangeSignal().Disconnect(this, &BridgeBase::OnWindowFocusChanged);
+      mApplication.mWindows.erase(mApplication.mWindows.begin() + i);
+      break;
+    }
+  }
+
   for(auto i = 0u; i < mApplication.mChildren.size(); ++i)
   {
-    if(mApplication.mChildren[i] == root)
+    if(mApplication.mChildren[i] == windowAccessible)
     {
       mApplication.mChildren.erase(mApplication.mChildren.begin() + i);
       break;

diff --git a/dali/internal/accessibility/bridge/bridge-base.h b/dali/internal/accessibility/bridge/bridge-base.h
index 2c06249..62a0094 100644 (file)
--- a/dali/internal/accessibility/bridge/bridge-base.h
+++ b/dali/internal/accessibility/bridge/bridge-base.h
@@ -21,9 +21,11 @@
 // EXTERNAL INCLUDES
 #include <dali/public-api/dali-adaptor-version.h>
 #include <dali/public-api/signals/connection-tracker.h>
+#include <dali/public-api/actors/layer.h>
 #include <memory>
 
 // INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/window-devel.h>
 #include <dali/internal/accessibility/bridge/accessibility-common.h>
 
 /**
@@ -34,6 +36,7 @@ class AppAccessible : public virtual Dali::Accessibility::Accessible, public vir
 public:
   Dali::Accessibility::EmptyAccessibleWithAddress mParent;
   std::vector<Dali::Accessibility::Accessible*>   mChildren;
+  std::vector<Dali::Window>                       mWindows;
   std::string                                     mName;
 
   std::string GetName() override
@@ -87,14 +90,32 @@ public:
   }
 
   /**
-   * @brief Gets the active window.
+   * @brief Gets the Accessible object from the window.
    *
-   * @return Null if mChildren is empty, otherwise the active window
+   * @param[in] window The window to find
+   * @return Null if mChildren is empty, otherwise the Accessible object
    * @note Currently, the default window would be returned when mChildren is not empty.
    */
-  Dali::Accessibility::Accessible* GetActiveWindow()
+  Dali::Accessibility::Accessible* GetWindowAccessible(Dali::Window window)
   {
-    return mChildren.empty() ? nullptr : mChildren[0];
+    if(mChildren.empty())
+    {
+      return nullptr;
+    }
+
+    Dali::Layer rootLayer = window.GetRootLayer();
+
+    // Find a child which is related to the window.
+    for(auto i = 0u; i < mChildren.size(); ++i)
+    {
+      if(rootLayer == mChildren[i]->GetInternalActor())
+      {
+        return mChildren[i];
+      }
+    }
+
+    // If can't find its children, return the default window.
+    return mChildren[0];
   }
 
   bool DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo) override
@@ -107,6 +128,11 @@ public:
     return {};
   }
 
+  Dali::Actor GetInternalActor() override
+  {
+    return Dali::Actor{};
+  }
+
   Dali::Accessibility::Address GetAddress() override
   {
     return {"", "root"};
@@ -170,6 +196,22 @@ public:
   void AddFilteredEvent(FilteredEvents kind, Dali::Accessibility::Accessible* obj, float delay, std::function<void()> functor);
 
   /**
+   * @brief Callback when the visibility of the window is changed.
+   *
+   * @param[in] window The window to be changed
+   * @param[in] visible The visibility of the window
+   */
+  void OnWindowVisibilityChanged(Dali::Window window, bool visible);
+
+  /**
+   * @brief Callback when the window focus is changed.
+   *
+   * @param[in] window The window whose focus is changed
+   * @param[in] focusIn Whether the focus is in/out
+   */
+  void OnWindowFocusChanged(Dali::Window window, bool focusIn);
+
+  /**
    * @copydoc Dali::Accessibility::Bridge::GetBusName()
    */
   const std::string& GetBusName() const override;
@@ -177,12 +219,12 @@ public:
   /**
    * @copydoc Dali::Accessibility::Bridge::AddTopLevelWindow()
    */
-  void AddTopLevelWindow(Dali::Accessibility::Accessible* window) override;
+  void AddTopLevelWindow(Dali::Accessibility::Accessible* windowAccessible) override;
 
   /**
    * @copydoc Dali::Accessibility::Bridge::RemoveTopLevelWindow()
    */
-  void RemoveTopLevelWindow(Dali::Accessibility::Accessible* window) override;
+  void RemoveTopLevelWindow(Dali::Accessibility::Accessible* windowAccessible) override;
 
   /**
    * @copydoc Dali::Accessibility::Bridge::AddPopup()

diff --git a/dali/internal/accessibility/bridge/bridge-impl.cpp b/dali/internal/accessibility/bridge/bridge-impl.cpp
index a4144ab..f46f5ea 100644 (file)
--- a/dali/internal/accessibility/bridge/bridge-impl.cpp
+++ b/dali/internal/accessibility/bridge/bridge-impl.cpp
@@ -215,6 +215,8 @@ public:
     mRegistryClient       = {};
     mDirectReadingClient  = {};
     mDirectReadingCallbacks.clear();
+    mApplication.mChildren.clear();
+    mApplication.mWindows.clear();
   }
 
   /**
@@ -285,65 +287,120 @@ public:
     assert(res);
 
     mApplication.mParent.SetAddress(std::move(std::get<0>(res)));
+
     if(mIsShown)
     {
-      EmitActivate();
+      auto rootLayer = Dali::Stage::GetCurrent().GetRootLayer();
+      auto window    = Dali::DevelWindow::Get(rootLayer);
+      EmitActivate(window); // Currently, sends a signal that the default window is activated here.
     }
     return ForceUpResult::JUST_STARTED;
   }
 
   /**
-   * @brief Sends a signal to dbus that the default window is activated.
+   * @brief Sends a signal to dbus that the window is shown.
+   *
+   * @param[in] window The window to be shown
+   * @see Accessible::EmitShowing() and BridgeObject::EmitStateChanged()
+   */
+  void EmitShown(Dali::Window window)
+  {
+    auto windowAccessible = mApplication.GetWindowAccessible(window);
+    if(windowAccessible)
+    {
+      windowAccessible->EmitShowing(true);
+    }
+  }
+
+  /**
+   * @brief Sends a signal to dbus that the window is hidden.
+   *
+   * @param[in] window The window to be hidden
+   * @see Accessible::EmitShowing() and BridgeObject::EmitStateChanged()
+   */
+  void EmitHidden(Dali::Window window)
+  {
+    auto windowAccessible = mApplication.GetWindowAccessible(window);
+    if(windowAccessible)
+    {
+      windowAccessible->EmitShowing(false);
+    }
+  }
+
+  /**
+   * @brief Sends a signal to dbus that the window is activated.
    *
-   * TODO : This is subject to change if/when we implement multi-window support.
+   * @param[in] window The window to be activated
    * @see BridgeObject::Emit()
    */
-  void EmitActivate()
+  void EmitActivate(Dali::Window window)
   {
-    auto win = mApplication.GetActiveWindow();
-    if(win)
+    auto windowAccessible = mApplication.GetWindowAccessible(window);
+    if(windowAccessible)
     {
-      win->Emit(WindowEvent::ACTIVATE, 0);
+      windowAccessible->Emit(WindowEvent::ACTIVATE, 0);
     }
   }
 
   /**
-   * @brief Sends a signal to dbus that the default window is deactivated.
+   * @brief Sends a signal to dbus that the window is deactivated.
    *
-   * TODO : This is subject to change if/when we implement multi-window support.
+   * @param[in] window The window to be deactivated
    * @see BridgeObject::Emit()
    */
-  void EmitDeactivate()
+  void EmitDeactivate(Dali::Window window)
+  {
+    auto windowAccessible = mApplication.GetWindowAccessible(window);
+    if(windowAccessible)
+    {
+      windowAccessible->Emit(WindowEvent::DEACTIVATE, 0);
+    }
+  }
+
+  /**
+   * @copydoc Dali::Accessibility::Bridge::WindowShown()
+   */
+  void WindowShown(Dali::Window window) override
   {
-    auto win = mApplication.GetActiveWindow();
-    if(win)
+    if(!mIsShown && IsUp())
     {
-      win->Emit(WindowEvent::DEACTIVATE, 0);
+      EmitShown(window);
     }
+    mIsShown = true;
   }
 
   /**
    * @copydoc Dali::Accessibility::Bridge::WindowHidden()
    */
-  void WindowHidden() override
+  void WindowHidden(Dali::Window window) override
   {
     if(mIsShown && IsUp())
     {
-      EmitDeactivate();
+      EmitHidden(window);
     }
     mIsShown = false;
   }
 
   /**
-   * @copydoc Dali::Accessibility::Bridge::WindowShown()
+   * @copydoc Dali::Accessibility::Bridge::WindowFocused()
    */
-  void WindowShown() override
+  void WindowFocused(Dali::Window window) override
   {
-    if(!mIsShown && IsUp())
+    if(mIsShown && IsUp())
     {
-      EmitActivate();
+      EmitActivate(window);
+    }
+  }
+
+  /**
+   * @copydoc Dali::Accessibility::Bridge::WindowUnfocused()
+   */
+  void WindowUnfocused(Dali::Window window) override
+  {
+    if(mIsShown && IsUp())
+    {
+      EmitDeactivate(window);
     }
-    mIsShown = true;
   }
 
   void ReadAndListenProperty()
@@ -538,17 +595,19 @@ void Bridge::EnableAutoInit()
     return;
   }
 
-  auto rootLayer       = Dali::Stage::GetCurrent().GetRootLayer();
+  auto rootLayer       = Dali::Stage::GetCurrent().GetRootLayer(); // A root layer of the default window.
   auto window          = Dali::DevelWindow::Get(rootLayer);
   auto applicationName = Dali::Internal::Adaptor::Adaptor::GetApplicationPackageName();
 
+  auto accessible = Accessibility::Accessible::Get(rootLayer, true);
+
   auto* bridge = Bridge::GetCurrentBridge();
-  bridge->AddTopLevelWindow(Dali::Accessibility::Accessible::Get(rootLayer, true));
+  bridge->AddTopLevelWindow(accessible);
   bridge->SetApplicationName(applicationName);
   bridge->Initialize();
 
   if(window && window.IsVisible())
   {
-    bridge->WindowShown();
+    bridge->WindowShown(window);
   }
 }

diff --git a/dali/internal/accessibility/bridge/dummy-atspi.h b/dali/internal/accessibility/bridge/dummy-atspi.h
index bcdc26a..06995b9 100644 (file)
--- a/dali/internal/accessibility/bridge/dummy-atspi.h
+++ b/dali/internal/accessibility/bridge/dummy-atspi.h
@@ -65,11 +65,19 @@ struct DummyBridge : Dali::Accessibility::Bridge
     return nullptr;
   }
 
-  void WindowShown() override
+  void WindowShown(Window window) override
   {
   }
 
-  void WindowHidden() override
+  void WindowHidden(Window window) override
+  {
+  }
+
+  void WindowFocused(Window window) override
+  {
+  }
+
+  void WindowUnfocused(Window window) override
   {
   }
 

diff --git a/dali/internal/adaptor/common/adaptor-impl.cpp b/dali/internal/adaptor/common/adaptor-impl.cpp
index e787668..feac31b 100644 (file)
--- a/dali/internal/adaptor/common/adaptor-impl.cpp
+++ b/dali/internal/adaptor/common/adaptor-impl.cpp
@@ -330,7 +330,6 @@ void Adaptor::AccessibilityObserver::OnAccessibleKeyEvent(const Dali::KeyEvent&
 
 Adaptor::~Adaptor()
 {
-  Accessibility::Bridge::GetCurrentBridge()->WindowHidden();
   Accessibility::Bridge::GetCurrentBridge()->Terminate();
 
   // Ensure stop status
@@ -956,8 +955,6 @@ void Adaptor::RequestProcessEventsOnIdle(bool forceProcess)
 
 void Adaptor::OnWindowShown()
 {
-  Dali::Accessibility::Bridge::GetCurrentBridge()->WindowShown();
-
   if(PAUSED_WHILE_HIDDEN == mState)
   {
     // Adaptor can now be resumed
@@ -988,8 +985,6 @@ void Adaptor::OnWindowShown()
 
 void Adaptor::OnWindowHidden()
 {
-  Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden();
-
   if(RUNNING == mState || READY == mState)
   {
     bool allWindowsHidden = true;

diff --git a/dali/internal/adaptor/common/application-impl.cpp b/dali/internal/adaptor/common/application-impl.cpp
index 1311e2a..4e08ba1 100644 (file)
--- a/dali/internal/adaptor/common/application-impl.cpp
+++ b/dali/internal/adaptor/common/application-impl.cpp
@@ -238,7 +238,6 @@ void Application::Quit()
 
 void Application::QuitFromMainLoop()
 {
-  Accessibility::Bridge::GetCurrentBridge()->WindowHidden();
   Accessibility::Bridge::GetCurrentBridge()->Terminate();
 
   mAdaptor->Stop();

diff --git a/dali/internal/window-system/common/window-impl.cpp b/dali/internal/window-system/common/window-impl.cpp
index 2396704..cd060f0 100644 (file)
--- a/dali/internal/window-system/common/window-impl.cpp
+++ b/dali/internal/window-system/common/window-impl.cpp
@@ -98,13 +98,13 @@ Window::Window()
 
 Window::~Window()
 {
+  auto bridge     = Accessibility::Bridge::GetCurrentBridge();
+  auto rootLayer  = mScene.GetRootLayer();
+  auto accessible = Accessibility::Accessible::Get(rootLayer);
+  bridge->RemoveTopLevelWindow(accessible);
+
   if(mAdaptor)
   {
-    auto bridge     = Accessibility::Bridge::GetCurrentBridge();
-    auto rootLayer  = mScene.GetRootLayer();
-    auto accessible = Accessibility::Accessible::Get(rootLayer);
-    bridge->RemoveTopLevelWindow(accessible);
-
     mAdaptor->RemoveWindow(this);
   }
 
@@ -171,6 +171,7 @@ void Window::OnAdaptorSet(Dali::Adaptor& adaptor)
   mEventHandler = EventHandlerPtr(new EventHandler(mWindowSurface->GetWindowBase(), *mAdaptor));
   mEventHandler->AddObserver(*this);
 
+  // Add Window to bridge for ATSPI
   auto bridge     = Accessibility::Bridge::GetCurrentBridge();
   auto rootLayer  = mScene.GetRootLayer();
   auto accessible = Accessibility::Accessible::Get(rootLayer, true);
@@ -753,11 +754,11 @@ void Window::OnFocusChanged(bool focusIn)
   {
     if(focusIn)
     {
-      bridge->WindowShown();
+      bridge->WindowFocused(handle);
     }
     else
     {
-      bridge->WindowHidden();
+      bridge->WindowUnfocused(handle);
     }
   }
 }