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;
{
auto handle = mSelf.GetHandle();
- // NonControlAccessible is deleted on ObjectDestroyedSignal
+ // AdaptorAccessible is deleted on ObjectDestroyedSignal
// for the respective actor (see `nonControlAccessibles`).
DALI_ASSERT_ALWAYS(handle);
}
public:
- NonControlAccessible(Dali::Actor actor, bool isRoot)
+ AdaptorAccessible(Dali::Actor actor, bool isRoot)
: mSelf(actor),
mRoot(isRoot)
{
{
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;
objectRegistry = registry;
}
-void Accessible::Register
ControlAccessibilityGetter(std::function<Accessible*(Dali::Actor)> functor)
+void Accessible::Register
ExternalAccessibleGetter(std::function<Accessible*(Dali::Actor)> functor)
{
convertingFunctor = functor;
}
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;
}
//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
/**
* @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(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 WindowHidden() = 0;
+ virtual void WindowUnfocused(Window window) = 0;
/**
* @brief Initializes accessibility bus.
*/
static void EnableAutoInit();
+ static Signal<void()>& EnabledSignal()
+ {
+ return mEnabledSignal;
+ }
+
+ static Signal<void()>& DisabledSignal()
+ {
+ return mDisabledSignal;
+ }
+
protected:
struct Data
{
inline static AutoInitState mAutoInitState = AutoInitState::ENABLED;
+ inline static Signal<void()> mEnabledSignal;
+ inline static Signal<void()> mDisabledSignal;
+
/**
* @brief Registers accessible object to be known in bridge object.
*
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
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;
*/
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.
return {};
}
+ Dali::Actor GetInternalActor() override
+ {
+ return Dali::Actor{};
+ }
+
private:
Address mAddress;
};
#include <dali/internal/accessibility/bridge/bridge-base.h>
// EXTERNAL INCLUDES
+#include <dali/devel-api/common/stage.h>
#include <atomic>
#include <cstdlib>
#include <memory>
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)
}
}
-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;
// 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>
/**
public:
Dali::Accessibility::EmptyAccessibleWithAddress mParent;
std::vector<Dali::Accessibility::Accessible*> mChildren;
+ std::vector<Dali::Window> mWindows;
std::string mName;
std::string GetName() override
}
/**
- * @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
return {};
}
+ Dali::Actor GetInternalActor() override
+ {
+ return Dali::Actor{};
+ }
+
Dali::Accessibility::Address GetAddress() override
{
return {"", "root"};
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;
/**
* @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()
}
mData->mCurrentlyHighlightedActor = {};
mData->mHighlightActor = {};
+
+ mDisabledSignal.Emit();
}
mHighlightedActor = {};
mHighlightClearAction = {};
mRegistryClient = {};
mDirectReadingClient = {};
mDirectReadingCallbacks.clear();
+ mApplication.mChildren.clear();
+ mApplication.mWindows.clear();
}
/**
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.
}
+
+ mEnabledSignal.Emit();
+
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.
*
- * TODO : This is subject to change if/when we implement multi-window support.
- * @see BridgeObject::Emit()
+ * @param[in] window The window to be shown
+ * @see Accessible::EmitShowing() and BridgeObject::EmitStateChanged()
*/
- void EmitActivate()
+ void EmitShown(Dali::Window window)
{
- auto win = mApplication.GetActiveWindow();
- if(win)
+ auto windowAccessible = mApplication.GetWindowAccessible(window);
+ if(windowAccessible)
{
- win->Emit(WindowEvent::ACTIVATE, 0);
+ windowAccessible->EmitShowing(true);
}
}
/**
- * @brief Sends a signal to dbus that the default window is deactivated.
+ * @brief Sends a signal to dbus that the window is hidden.
*
- * TODO : This is subject to change if/when we implement multi-window support.
+ * @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.
+ *
+ * @param[in] window The window to be activated
* @see BridgeObject::Emit()
*/
- void EmitDeactivate()
+ void EmitActivate(Dali::Window window)
{
- auto win = mApplication.GetActiveWindow();
- if(win)
+ auto windowAccessible = mApplication.GetWindowAccessible(window);
+ if(windowAccessible)
{
- win->Emit(WindowEvent::DEACTIVATE, 0);
+ windowAccessible->Emit(WindowEvent::ACTIVATE, 0);
}
}
/**
- * @copydoc Dali::Accessibility::Bridge::WindowHidden()
+ * @brief Sends a signal to dbus that the window is deactivated.
+ *
+ * @param[in] window The window to be deactivated
+ * @see BridgeObject::Emit()
*/
- void WindowHidden() override
+ void EmitDeactivate(Dali::Window window)
{
- if(mIsShown && IsUp())
+ auto windowAccessible = mApplication.GetWindowAccessible(window);
+ if(windowAccessible)
{
- EmitDeactivate();
+ windowAccessible->Emit(WindowEvent::DEACTIVATE, 0);
}
- mIsShown = false;
}
/**
* @copydoc Dali::Accessibility::Bridge::WindowShown()
*/
- void WindowShown() override
+ void WindowShown(Dali::Window window) override
{
if(!mIsShown && IsUp())
{
- EmitActivate();
+ EmitShown(window);
}
mIsShown = true;
}
- void ReadAndListenProperty()
+ /**
+ * @copydoc Dali::Accessibility::Bridge::WindowHidden()
+ */
+ void WindowHidden(Dali::Window window) override
{
- // read property
- auto enabled = mAccessibilityStatusClient.property<bool>("ScreenReaderEnabled").get();
- if(enabled)
+ if(mIsShown && IsUp())
{
- mIsScreenReaderEnabled = std::get<0>(enabled);
+ EmitHidden(window);
}
+ mIsShown = false;
+ }
- enabled = mAccessibilityStatusClient.property<bool>("IsEnabled").get();
- if(enabled)
+ /**
+ * @copydoc Dali::Accessibility::Bridge::WindowFocused()
+ */
+ void WindowFocused(Dali::Window window) override
+ {
+ if(mIsShown && IsUp())
{
- mIsEnabled = std::get<0>(enabled);
+ EmitActivate(window);
}
+ }
- if(mIsScreenReaderEnabled || mIsEnabled)
+ /**
+ * @copydoc Dali::Accessibility::Bridge::WindowUnfocused()
+ */
+ void WindowUnfocused(Dali::Window window) override
+ {
+ if(mIsShown && IsUp())
{
- ForceUp();
+ EmitDeactivate(window);
}
+ }
- // listen property change
- mAccessibilityStatusClient.addPropertyChangedEvent<bool>("ScreenReaderEnabled", [this](bool res) {
- mIsScreenReaderEnabled = res;
+ void ReadIsEnabledProperty()
+ {
+ mAccessibilityStatusClient.property<bool>("IsEnabled").asyncGet([this](DBus::ValueOrError<bool> msg) {
+ if(!msg)
+ {
+ DALI_LOG_ERROR("Get IsEnabled property error: %s\n", msg.getError().message.c_str());
+ if(msg.getError().errorType == DBus::ErrorType::INVALID_REPLY)
+ {
+ ReadIsEnabledProperty();
+ }
+ return;
+ }
+ mIsEnabled = std::get<0>(msg);
+ if(mIsEnabled)
+ {
+ ForceUp();
+ }
+ });
+ }
+
+ void ListenIsEnabledProperty()
+ {
+ mAccessibilityStatusClient.addPropertyChangedEvent<bool>("IsEnabled", [this](bool res) {
+ mIsEnabled = res;
if(mIsScreenReaderEnabled || mIsEnabled)
{
ForceUp();
ForceDown();
}
});
+ }
- mAccessibilityStatusClient.addPropertyChangedEvent<bool>("IsEnabled", [this](bool res) {
- mIsEnabled = res;
+ void ReadScreenReaderEnabledProperty()
+ {
+ mAccessibilityStatusClient.property<bool>("ScreenReaderEnabled").asyncGet([this](DBus::ValueOrError<bool> msg) {
+ if(!msg)
+ {
+ DALI_LOG_ERROR("Get ScreenReaderEnabled property error: %s\n", msg.getError().message.c_str());
+ if(msg.getError().errorType == DBus::ErrorType::INVALID_REPLY)
+ {
+ ReadScreenReaderEnabledProperty();
+ }
+ return;
+ }
+ mIsScreenReaderEnabled = std::get<0>(msg);
+ if(mIsScreenReaderEnabled)
+ {
+ ForceUp();
+ }
+ });
+ }
+
+ void ListenScreenReaderEnabledProperty()
+ {
+ mAccessibilityStatusClient.addPropertyChangedEvent<bool>("ScreenReaderEnabled", [this](bool res) {
+ mIsScreenReaderEnabled = res;
if(mIsScreenReaderEnabled || mIsEnabled)
{
ForceUp();
});
}
+ void ReadAndListenProperties()
+ {
+ ReadIsEnabledProperty();
+ ListenIsEnabledProperty();
+
+ ReadScreenReaderEnabledProperty();
+ ListenScreenReaderEnabledProperty();
+ }
+
bool InitializeAccessibilityStatusClient()
{
mAccessibilityStatusClient = DBus::DBusClient{A11yDbusName, A11yDbusPath, A11yDbusStatusInterface, DBus::ConnectionType::SESSION};
{
if ( InitializeAccessibilityStatusClient() )
{
- ReadAndListenProperty();
+ ReadAndListenProperties();
mIdleCallback = NULL;
return false;
}
{
if ( InitializeAccessibilityStatusClient() )
{
- ReadAndListenProperty();
+ ReadAndListenProperties();
return;
}
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);
}
}
*/
void setDebugPrinter(std::function<void(const char*, size_t)>);
+/**
+ * @brief Enumeration indicatng DBus error type
+ */
+enum class ErrorType
+{
+ DEFAULT, ///< default
+ INVALID_REPLY ///< reply message has error
+};
+
struct Error
{
std::string message;
+ ErrorType errorType{ErrorType::DEFAULT};
Error() = default;
- Error(std::string msg)
- : message(std::move(msg))
+ Error(std::string msg, ErrorType errorType = ErrorType::DEFAULT)
+ : message(std::move(msg)),
+ errorType(errorType)
{
assert(!message.empty());
}
if(DBUS_W->eldbus_message_error_get_impl(reply, errname, errmsg))
{
DBUS_DEBUG("call %d: %s: %s", callId.id, errname.c_str(), errmsg.c_str());
- callback(Error{errname + ": " + errmsg});
+ callback(Error{errname + ": " + errmsg, ErrorType::INVALID_REPLY});
}
else
{
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
{
}
Adaptor::~Adaptor()
{
- Accessibility::Bridge::GetCurrentBridge()->WindowHidden();
Accessibility::Bridge::GetCurrentBridge()->Terminate();
// Ensure stop status
void Adaptor::OnWindowShown()
{
- Dali::Accessibility::Bridge::GetCurrentBridge()->WindowShown();
-
if(PAUSED_WHILE_HIDDEN == mState)
{
// Adaptor can now be resumed
void Adaptor::OnWindowHidden()
{
- Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden();
-
if(RUNNING == mState || READY == mState)
{
bool allWindowsHidden = true;
void Application::QuitFromMainLoop()
{
- Accessibility::Bridge::GetCurrentBridge()->WindowHidden();
Accessibility::Bridge::GetCurrentBridge()->Terminate();
mAdaptor->Stop();
WebPAnimDecoderGetInfo(webPAnimDecoder, &webPAnimInfo);
width = webPAnimInfo.canvas_width;
height = webPAnimInfo.canvas_height;
+ ReleaseResource(webPData, webPAnimDecoder);
return true;
}
}
bitmap = Dali::Devel::PixelBuffer::New(webPAnimInfo.canvas_width, webPAnimInfo.canvas_height, Dali::Pixel::RGBA8888);
const int32_t bufferSize = webPAnimInfo.canvas_width * webPAnimInfo.canvas_height * sizeof(uint32_t);
memcpy(bitmap.GetBuffer(), frameBuffer, bufferSize);
+ ReleaseResource(webPData, webPAnimDecoder);
return true;
}
}
{
Internal::Platform::FileReader fileReader(mUrl);
fp = fileReader.GetFile();
- if(fp == NULL)
+ if(fp == nullptr)
{
return false;
}
return false;
}
- // Moveable but not copyable
-
- Impl(const Impl&) = delete;
- Impl& operator=(const Impl&) = delete;
- Impl(Impl&&) = default;
- Impl& operator=(Impl&&) = default;
-
- ~Impl()
+ void ReleaseResource()
{
#ifdef DALI_ANIMATED_WEBP_ENABLED
- if(&mWebPData != NULL)
+ if(&mWebPData != nullptr)
{
mWebPData.bytes = nullptr;
WebPDataInit(&mWebPData);
}
- if(mWebPAnimDecoder)
+ if(mWebPAnimDecoder != nullptr)
{
WebPAnimDecoderDelete(mWebPAnimDecoder);
+ mWebPAnimDecoder = nullptr;
}
#endif
- free((void*)mBuffer);
- mBuffer = nullptr;
+ if(mBuffer != nullptr)
+ {
+ free((void*)mBuffer);
+ mBuffer = nullptr;
+ }
+ }
+
+ // Moveable but not copyable
+
+ Impl(const Impl&) = delete;
+ Impl& operator=(const Impl&) = delete;
+ Impl(Impl&&) = default;
+ Impl& operator=(Impl&&) = default;
+
+ ~Impl()
+ {
+ ReleaseResource();
}
std::string mUrl;
const int32_t imageBufferSize = width * height * sizeof(uint8_t) * channelNumber;
memcpy(pixelBuffer.GetBuffer(), frameBuffer, imageBufferSize);
free((void*)frameBuffer);
- return pixelBuffer;
}
+ mImpl->ReleaseResource();
+ return pixelBuffer;
}
#endif
#include <dali/devel-api/threading/mutex.h>
#include <dali/public-api/common/dali-vector.h>
#include <tbm_surface.h>
+#include <memory>
// INTERNAL INCLUDES
#include <dali/internal/imaging/common/native-image-source-impl.h>
// EXTERNAL INCLUDES
#include <dali/internal/system/linux/dali-ecore-x.h>
+#include <memory>
// INTERNAL INCLUDES
-#include <dali/internal/graphics/common/graphics-interface.h>
-
#include <dali/public-api/adaptor-framework/native-image-source.h>
-
#include <dali/internal/imaging/common/native-image-source-impl.h>
namespace Dali
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);
}
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);
{
if(focusIn)
{
- bridge->WindowShown();
+ bridge->WindowFocused(handle);
}
else
{
- bridge->WindowHidden();
+ bridge->WindowUnfocused(handle);
}
}
}
{
const unsigned int ADAPTOR_MAJOR_VERSION = 2;
const unsigned int ADAPTOR_MINOR_VERSION = 0;
-const unsigned int ADAPTOR_MICRO_VERSION = 51;
+const unsigned int ADAPTOR_MICRO_VERSION = 52;
const char* const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-adaptor
Summary: The DALi Tizen Adaptor
-Version: 2.0.51
+Version: 2.0.52
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-adaptor.git / commitdiff