mCallStack.PushCall("EndRenderPass", namedParams.str(), namedParams);
}
+ void ReadPixels(uint8_t* buffer) override
+ {
+ }
+
void ExecuteCommandBuffers(std::vector<const CommandBuffer*>&& commandBuffers) override
{
mCommands.emplace_back();
**/
virtual void EmitMovedOutOfScreen(Accessible* obj, ScreenRelativeMoveType type) = 0;
- /**
- * @brief Emits "org.a11y.atspi.Socket.Available" event on AT-SPI bus.
- *
- * @param obj Accessible object
- */
- virtual void EmitSocketAvailable(Accessible* obj) = 0;
-
/**
* @brief Emits ScrollStarted event on at-spi bus.
*
void OnPostRender()
{
- Accessibility::Bridge::GetCurrentBridge()->EmitPostRender(shared_from_this());
+ try
+ {
+ Accessibility::Bridge::GetCurrentBridge()->EmitPostRender(shared_from_this());
+ }
+ catch(const std::bad_weak_ptr& e)
+ {
+ DALI_LOG_ERROR("bad_weak_ptr exception caught: %s", e.what());
+ }
}
}; // AdaptorAccessible
// EXTERNAL INCLUDES
#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/window-devel.h>
+using namespace Dali::Accessibility;
+
+namespace
+{
+bool UpdateLastEmitted(std::map<State, int>& lastEmitted, State state, int newValue)
+{
+ bool updated = false;
+ const auto [iter, inserted] = lastEmitted.emplace(state, newValue);
+ if(!inserted && iter->second != newValue)
+ {
+ iter->second = newValue;
+ updated = true;
+ }
+
+ return inserted || updated;
+}
+
+bool IsModalRole(Role role)
+{
+ return role == Role::POPUP_MENU || role == Role::PANEL || role == Role::DIALOG || role == Role::PAGE_TAB;
+}
+
+bool IsWindowRole(Role role)
+{
+ return role == Role::WINDOW || role == Role::FRAME || role == Role::INPUT_METHOD_WINDOW;
+}
+
+bool ShouldEmitVisible(Accessible* accessible)
+{
+ Role role = accessible->GetRole();
+ return IsWindowRole(role);
+}
+
+bool ShouldEmitShowing(Accessible* accessible, bool showing)
+{
+ Role role = accessible->GetRole();
+ return IsWindowRole(role) || IsModalRole(role) || (showing && role == Role::NOTIFICATION) ||
+ (!showing && accessible->IsHighlighted()) || accessible->GetStates()[State::MODAL];
+}
+
+} // namespace
+
namespace Dali::Accessibility
{
ActorAccessible::ActorAccessible(Actor actor)
// Erase-remove idiom
// TODO (C++20): Replace with std::erase_if
- auto it = std::remove_if(mChildren.begin(), mChildren.end(), [shouldIncludeHidden](const Accessible* child) {
- return !child || (!shouldIncludeHidden && child->IsHidden());
- });
+ auto it = std::remove_if(mChildren.begin(), mChildren.end(), [shouldIncludeHidden](const Accessible* child) { return !child || (!shouldIncludeHidden && child->IsHidden()); });
mChildren.erase(it, mChildren.end());
mChildren.shrink_to_fit();
}
+void ActorAccessible::EmitActiveDescendantChanged(Accessible* child)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->EmitActiveDescendantChanged(this, child);
+ }
+}
+
+void ActorAccessible::EmitStateChanged(State state, int newValue, int reserved)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bool shouldEmit{false};
+
+ switch(state)
+ {
+ case State::SHOWING:
+ {
+ shouldEmit = ShouldEmitShowing(this, static_cast<bool>(newValue));
+ break;
+ }
+ case State::VISIBLE:
+ {
+ shouldEmit = ShouldEmitVisible(this);
+ break;
+ }
+ default:
+ {
+ shouldEmit = UpdateLastEmitted(mLastEmittedState, state, newValue);
+ break;
+ }
+ }
+
+ if(shouldEmit)
+ {
+ try
+ {
+ bridgeData->mBridge->EmitStateChanged(shared_from_this(), state, newValue, reserved);
+ }
+ catch(const std::bad_weak_ptr& e)
+ {
+ DALI_LOG_ERROR("bad_weak_ptr exception caught: %s", e.what());
+ }
+ }
+ }
+}
+
+void ActorAccessible::EmitShowing(bool isShowing)
+{
+ EmitStateChanged(State::SHOWING, isShowing ? 1 : 0);
+}
+
+void ActorAccessible::EmitVisible(bool isVisible)
+{
+ EmitStateChanged(State::VISIBLE, isVisible ? 1 : 0);
+}
+
+void ActorAccessible::EmitHighlighted(bool isHighlighted)
+{
+ EmitStateChanged(State::HIGHLIGHTED, isHighlighted ? 1 : 0);
+}
+
+void ActorAccessible::EmitFocused(bool isFocused)
+{
+ EmitStateChanged(State::FOCUSED, isFocused ? 1 : 0);
+}
+
+void ActorAccessible::EmitTextInserted(unsigned int position, unsigned int length, const std::string& content)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->EmitTextChanged(this, TextChangedState::INSERTED, position, length, content);
+ }
+}
+void ActorAccessible::EmitTextDeleted(unsigned int position, unsigned int length, const std::string& content)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->EmitTextChanged(this, TextChangedState::DELETED, position, length, content);
+ }
+}
+void ActorAccessible::EmitTextCursorMoved(unsigned int cursorPosition)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->EmitCursorMoved(this, cursorPosition);
+ }
+}
+
+void ActorAccessible::EmitMovedOutOfScreen(ScreenRelativeMoveType type)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->EmitMovedOutOfScreen(this, type);
+ }
+}
+
+void ActorAccessible::EmitScrollStarted()
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->EmitScrollStarted(this);
+ }
+}
+
+void ActorAccessible::EmitScrollFinished()
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->EmitScrollFinished(this);
+ }
+}
+
+void ActorAccessible::Emit(WindowEvent event, unsigned int detail)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ bridgeData->mBridge->Emit(this, event, detail);
+ }
+}
+void ActorAccessible::Emit(ObjectPropertyChangeEvent event)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ try
+ {
+ bridgeData->mBridge->Emit(shared_from_this(), event);
+ }
+ catch(const std::bad_weak_ptr& e)
+ {
+ DALI_LOG_ERROR("bad_weak_ptr exception caught: %s", e.what());
+ }
+ }
+}
+
+void ActorAccessible::EmitBoundsChanged(Rect<> rect)
+{
+ if(auto bridgeData = GetBridgeData())
+ {
+ try
+ {
+ bridgeData->mBridge->EmitBoundsChanged(shared_from_this(), rect);
+ }
+ catch(const std::bad_weak_ptr& e)
+ {
+ DALI_LOG_ERROR("bad_weak_ptr exception caught: %s", e.what());
+ }
+ }
+}
+
+void ActorAccessible::NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool isRecursive)
+{
+ if(Accessibility::IsUp())
+ {
+ const auto newStates = GetStates();
+ for(auto i = 0u; i < static_cast<unsigned int>(Dali::Accessibility::State::MAX_COUNT); i++)
+ {
+ const auto index = static_cast<Dali::Accessibility::State>(i);
+ if(states[index])
+ {
+ EmitStateChanged(index, newStates[index]);
+ }
+ }
+
+ if(isRecursive)
+ {
+ auto children = GetChildren();
+ for(auto child : children)
+ {
+ if(auto accessible = dynamic_cast<ActorAccessible*>(child))
+ {
+ accessible->NotifyAccessibilityStateChange(states, isRecursive);
+ }
+ }
+ }
+ }
+}
+
} // namespace Dali::Accessibility
public virtual Collection,
public virtual Component,
public Dali::ConnectionTracker,
- public Dali::BaseObjectObserver
+ public Dali::BaseObjectObserver,
+ public std::enable_shared_from_this<ActorAccessible>
{
public:
ActorAccessible() = delete;
*/
void OnChildrenChanged();
+ /**
+ * @brief Helper function for emiting active-descendant-changed event.
+ *
+ * @param[in] child The child of the object
+ */
+ void EmitActiveDescendantChanged(Accessible* child);
+
+ /**
+ * @brief Helper function for emiting state-changed event.
+ *
+ * @param[in] state The accessibility state (SHOWING, HIGHLIGHTED, etc)
+ * @param[in] newValue Whether the state value is changed to new value or not.
+ * @param[in] reserved Reserved. (TODO : Currently, this argument is not implemented in dali)
+ *
+ * @note The second argument determines which value is depending on State.
+ * For instance, if the state is PRESSED, newValue means isPressed or isSelected.
+ * If the state is SHOWING, newValue means isShowing.
+ */
+ void EmitStateChanged(State state, int newValue, int reserved = 0);
+
+ /**
+ * @brief Helper function for emiting bounds-changed event.
+ *
+ * @param rect The rectangle for changed bounds
+ */
+ void EmitBoundsChanged(Rect<> rect);
+
+ /**
+ * @brief Emits "showing" event.
+ * The method informs accessibility clients about "showing" state.
+ *
+ * @param[in] isShowing The flag pointing if object is showing
+ */
+ void EmitShowing(bool isShowing);
+
+ /**
+ * @brief Emits "visible" event.
+ * The method informs accessibility clients about "visible" state.
+ *
+ * @param[in] isVisible The flag pointing if object is visible
+ */
+ void EmitVisible(bool isVisible);
+
+ /**
+ * @brief Emits "highlighted" event.
+ * The method informs accessibility clients about "highlighted" state.
+ *
+ * @param[in] isHighlighted The flag pointing if object is highlighted
+ */
+ void EmitHighlighted(bool isHighlighted);
+
+ /**
+ * @brief Emits "focused" event.
+ * The method informs accessibility clients about "focused" state.
+ *
+ * @param[in] isFocused The flag pointing if object is focused
+ */
+ void EmitFocused(bool isFocused);
+
+ /**
+ * @brief Emits "text inserted" event.
+ *
+ * @param[in] position The cursor position
+ * @param[in] length The text length
+ * @param[in] content The inserted text
+ */
+ void EmitTextInserted(unsigned int position, unsigned int length, const std::string& content);
+
+ /**
+ * @brief Emits "text deleted" event.
+ *
+ * @param[in] position The cursor position
+ * @param[in] length The text length
+ * @param[in] content The deleted text
+ */
+ void EmitTextDeleted(unsigned int position, unsigned int length, const std::string& content);
+
+ /**
+ * @brief Emits "cursor moved" event.
+ *
+ * @param[in] cursorPosition The new cursor position
+ */
+ void EmitTextCursorMoved(unsigned int cursorPosition);
+
+ /**
+ * @brief Emits "MoveOuted" event.
+ *
+ * @param[in] type moved out of screen type
+ */
+ void EmitMovedOutOfScreen(ScreenRelativeMoveType type);
+
+ /**
+ * @brief Emits "ScrollStarted" event.
+ *
+ */
+ void EmitScrollStarted();
+
+ /**
+ * @brief Emits "ScrollFinished" event.
+ *
+ */
+ void EmitScrollFinished();
+
+ /**
+ * @brief Emits "highlighted" event.
+ *
+ * @param[in] event The enumerated window event
+ * @param[in] detail The additional parameter which interpretation depends on chosen event
+ */
+ void Emit(WindowEvent event, unsigned int detail = 0);
+
+ /**
+ * @brief Emits property-changed event.
+ *
+ * @param[in] event Property changed event
+ **/
+ void Emit(ObjectPropertyChangeEvent event);
+
+ /**
+ * @brief Re-emits selected states of an Accessibility Object.
+ *
+ * @param[in] states The chosen states to re-emit
+ * @param[in] isRecursive If true, all children of the Accessibility object will also re-emit the states
+ */
+ void NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool isRecursive);
+
protected:
Dali::Actor Self() const
{
std::vector<Accessible*> mChildren;
bool mChildrenDirty;
const uint32_t mActorId;
+ std::map<State, int> mLastEmittedState;
};
} // namespace Dali::Accessibility
* @brief Get PixelBuffer of captured image.
*
* @return PixelBuffer Captured result
+ * @note GetCapturedBuffer is only available inside FinishedSignal, otherwise this returns empty handle.
*/
DALI_ADAPTOR_API Dali::Devel::PixelBuffer GetCapturedBuffer(Dali::Capture capture);
return Dali::Internal::Adaptor::NativeImageSource::GetImplementation(image).ReleaseBuffer(updatedArea);\r
}\r
\r
+bool SetPixels(NativeImageSource& image, uint8_t* pixbuf, const Pixel::Format& pixelFormat)\r
+{\r
+ return Dali::Internal::Adaptor::NativeImageSource::GetImplementation(image).SetPixels(pixbuf, pixelFormat);\r
+}\r
+\r
void SetResourceDestructionCallback(NativeImageSource& image, EventThreadCallback* callback)\r
{\r
return Dali::Internal::Adaptor::NativeImageSource::GetImplementation(image).SetResourceDestructionCallback(callback);\r
*/\r
DALI_ADAPTOR_API bool ReleaseBuffer(NativeImageSource& image, const Rect<uint32_t>& updatedArea);\r
\r
+/**\r
+ * @brief Sets PixelBuffers to NativeImageSource\r
+ *\r
+ * @param[in] image The instance of NativeImageSource.\r
+ * @param[in] pixbuf Pixel buffer to copy.\r
+ * @param[in] pixelFormat Pixel format of the pixel buffer\r
+ * @return @c true If the buffer is successfully set.\r
+ * @note The width and height of the input pixel buffer should be same with those of NativeImageSource.\r
+ * @note Only Pixel::Format::RGB888 and Pixel::Format::RGBA8888 are available as a input pixel format.\r
+ */\r
+DALI_ADAPTOR_API bool SetPixels(NativeImageSource& image, uint8_t* pixbuf, const Pixel::Format& pixelFormat);\r
+\r
/**\r
* @brief Set the Resource Destruction Callback object\r
*\r
/**
* @brief Basic interface implemented by all accessibility objects.
*/
-class DALI_ADAPTOR_API Accessible : public std::enable_shared_from_this<Accessible>
+class DALI_ADAPTOR_API Accessible
{
public:
virtual ~Accessible() noexcept;
- /**
- * @brief Helper function for emiting active-descendant-changed event.
- *
- * @param[in] child The child of the object
- */
- void EmitActiveDescendantChanged(Accessible* child);
-
- /**
- * @brief Helper function for emiting state-changed event.
- *
- * @param[in] state The accessibility state (SHOWING, HIGHLIGHTED, etc)
- * @param[in] newValue Whether the state value is changed to new value or not.
- * @param[in] reserved Reserved. (TODO : Currently, this argument is not implemented in dali)
- *
- * @note The second argument determines which value is depending on State.
- * For instance, if the state is PRESSED, newValue means isPressed or isSelected.
- * If the state is SHOWING, newValue means isShowing.
- */
- void EmitStateChanged(State state, int newValue, int reserved = 0);
-
- /**
- * @brief Helper function for emiting bounds-changed event.
- *
- * @param rect The rectangle for changed bounds
- */
- void EmitBoundsChanged(Rect<> rect);
-
- /**
- * @brief Emits "showing" event.
- * The method informs accessibility clients about "showing" state.
- *
- * @param[in] isShowing The flag pointing if object is showing
- */
- void EmitShowing(bool isShowing);
-
- /**
- * @brief Emits "visible" event.
- * The method informs accessibility clients about "visible" state.
- *
- * @param[in] isVisible The flag pointing if object is visible
- */
- void EmitVisible(bool isVisible);
-
- /**
- * @brief Emits "highlighted" event.
- * The method informs accessibility clients about "highlighted" state.
- *
- * @param[in] isHighlighted The flag pointing if object is highlighted
- */
- void EmitHighlighted(bool isHighlighted);
-
- /**
- * @brief Emits "focused" event.
- * The method informs accessibility clients about "focused" state.
- *
- * @param[in] isFocused The flag pointing if object is focused
- */
- void EmitFocused(bool isFocused);
-
- /**
- * @brief Emits "text inserted" event.
- *
- * @param[in] position The cursor position
- * @param[in] length The text length
- * @param[in] content The inserted text
- */
- void EmitTextInserted(unsigned int position, unsigned int length, const std::string& content);
-
- /**
- * @brief Emits "text deleted" event.
- *
- * @param[in] position The cursor position
- * @param[in] length The text length
- * @param[in] content The deleted text
- */
- void EmitTextDeleted(unsigned int position, unsigned int length, const std::string& content);
-
- /**
- * @brief Emits "cursor moved" event.
- *
- * @param[in] cursorPosition The new cursor position
- */
- void EmitTextCursorMoved(unsigned int cursorPosition);
-
- /**
- * @brief Emits "MoveOuted" event.
- *
- * @param[in] type moved out of screen type
- */
- void EmitMovedOutOfScreen(ScreenRelativeMoveType type);
-
- /**
- * @brief Emits "org.a11y.atspi.Socket.Available" signal.
- */
- // This belongs to Dali::Accessibility::Socket. However, all Emit*() helpers
- // are here in Accessible, regardless of what interface they belong to (perhaps
- // to spare a dynamic_cast if used like this: Accessible::Get()->Emit*(...)).
- void EmitSocketAvailable();
-
- /**
- * @brief Emits "ScrollStarted" event.
- *
- */
- void EmitScrollStarted();
-
- /**
- * @brief Emits "ScrollFinished" event.
- *
- */
- void EmitScrollFinished();
-
- /**
- * @brief Emits "highlighted" event.
- *
- * @param[in] event The enumerated window event
- * @param[in] detail The additional parameter which interpretation depends on chosen event
- */
- void Emit(WindowEvent event, unsigned int detail = 0);
-
- /**
- * @brief Emits property-changed event.
- *
- * @param[in] event Property changed event
- **/
- void Emit(ObjectPropertyChangeEvent event);
-
/**
* @brief Gets accessibility name.
*
*/
virtual bool DoGesture(const GestureInfo& gestureInfo) = 0;
- /**
- * @brief Re-emits selected states of an Accessibility Object.
- *
- * @param[in] states The chosen states to re-emit
- * @param[in] isRecursive If true, all children of the Accessibility object will also re-emit the states
- */
- void NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool isRecursive);
-
/**
* @brief Gets information about current object and all relations that connects
* it with other accessibility objects.
mutable AtspiInterfaces mInterfaces;
AtspiEvents mSuppressedEvents;
bool mIsOnRootLevel = false;
- std::map<State, int> mLastEmittedState;
}; // Accessible class
using namespace Dali::Accessibility;
-namespace
-{
-bool UpdateLastEmitted(std::map<State, int>& lastEmitted, State state, int newValue)
-{
- bool updated = false;
- const auto [iter, inserted] = lastEmitted.emplace(state, newValue);
- if(!inserted && iter->second != newValue)
- {
- iter->second = newValue;
- updated = true;
- }
-
- return inserted || updated;
-}
-
-bool IsModalRole(Role role)
-{
- return role == Role::POPUP_MENU || role == Role::PANEL || role == Role::DIALOG || role == Role::PAGE_TAB;
-}
-
-bool IsWindowRole(Role role)
-{
- return role == Role::WINDOW || role == Role::FRAME || role == Role::INPUT_METHOD_WINDOW;
-}
-
-bool ShouldEmitVisible(Accessible* accessible)
-{
- Role role = accessible->GetRole();
- return IsWindowRole(role);
-}
-
-bool ShouldEmitShowing(Accessible* accessible, bool showing)
-{
- Role role = accessible->GetRole();
- return IsWindowRole(role) || IsModalRole(role) || (showing && role == Role::NOTIFICATION) ||
- (!showing && accessible->IsHighlighted()) || accessible->GetStates()[State::MODAL];
-}
-
-} // namespace
-
Accessible::Accessible()
{
}
}
}
-void Accessible::EmitActiveDescendantChanged(Accessible* child)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitActiveDescendantChanged(this, child);
- }
-}
-
-void Accessible::EmitStateChanged(State state, int newValue, int reserved)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bool shouldEmit{false};
-
- switch(state)
- {
- case State::SHOWING:
- {
- shouldEmit = ShouldEmitShowing(this, static_cast<bool>(newValue));
- break;
- }
- case State::VISIBLE:
- {
- shouldEmit = ShouldEmitVisible(this);
- break;
- }
- default:
- {
- shouldEmit = UpdateLastEmitted(mLastEmittedState, state, newValue);
- break;
- }
- }
-
- if(shouldEmit)
- {
- bridgeData->mBridge->EmitStateChanged(shared_from_this(), state, newValue, reserved);
- }
- }
-}
-
-void Accessible::EmitShowing(bool isShowing)
-{
- EmitStateChanged(State::SHOWING, isShowing ? 1 : 0);
-}
-
-void Accessible::EmitVisible(bool isVisible)
-{
- EmitStateChanged(State::VISIBLE, isVisible ? 1 : 0);
-}
-
-void Accessible::EmitHighlighted(bool isHighlighted)
-{
- EmitStateChanged(State::HIGHLIGHTED, isHighlighted ? 1 : 0);
-}
-
-void Accessible::EmitFocused(bool isFocused)
-{
- EmitStateChanged(State::FOCUSED, isFocused ? 1 : 0);
-}
-
-void Accessible::EmitTextInserted(unsigned int position, unsigned int length, const std::string& content)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitTextChanged(this, TextChangedState::INSERTED, position, length, content);
- }
-}
-void Accessible::EmitTextDeleted(unsigned int position, unsigned int length, const std::string& content)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitTextChanged(this, TextChangedState::DELETED, position, length, content);
- }
-}
-void Accessible::EmitTextCursorMoved(unsigned int cursorPosition)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitCursorMoved(this, cursorPosition);
- }
-}
-
-void Accessible::EmitMovedOutOfScreen(ScreenRelativeMoveType type)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitMovedOutOfScreen(this, type);
- }
-}
-
-void Accessible::EmitSocketAvailable()
-{
- DALI_ASSERT_DEBUG(Socket::DownCast(this));
-
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitSocketAvailable(this);
- }
-}
-
-void Accessible::EmitScrollStarted()
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitScrollStarted(this);
- }
-}
-
-void Accessible::EmitScrollFinished()
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitScrollFinished(this);
- }
-}
-
-void Accessible::Emit(WindowEvent event, unsigned int detail)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->Emit(this, event, detail);
- }
-}
-void Accessible::Emit(ObjectPropertyChangeEvent event)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->Emit(shared_from_this(), event);
- }
-}
-
-void Accessible::EmitBoundsChanged(Rect<> rect)
-{
- if(auto bridgeData = GetBridgeData())
- {
- bridgeData->mBridge->EmitBoundsChanged(shared_from_this(), rect);
- }
-}
-
std::shared_ptr<Bridge::Data> Accessible::GetBridgeData() const
{
auto handle = mBridgeData.lock();
{
return false;
}
-
-void Accessible::NotifyAccessibilityStateChange(Dali::Accessibility::States states, bool isRecursive)
-{
- if(Accessibility::IsUp())
- {
- const auto newStates = GetStates();
- for(auto i = 0u; i < static_cast<unsigned int>(Dali::Accessibility::State::MAX_COUNT); i++)
- {
- const auto index = static_cast<Dali::Accessibility::State>(i);
- if(states[index])
- {
- EmitStateChanged(index, newStates[index]);
- }
- }
-
- if(isRecursive)
- {
- auto children = GetChildren();
- for(auto iter : children)
- {
- iter->NotifyAccessibilityStateChange(states, isRecursive);
- }
- }
- }
-}
#include <tuple>
// INTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/actor-accessible.h>
#include <dali/devel-api/adaptor-framework/proxy-accessible.h>
#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/devel-api/atspi-interfaces/accessible.h>
* @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* GetWindowAccessible(Dali::Window window)
+ Dali::Accessibility::ActorAccessible* GetWindowAccessible(Dali::Window window)
{
if(mChildren.empty())
{
{
if(rootLayer == mChildren[i]->GetInternalActor())
{
- return mChildren[i];
+ return dynamic_cast<Dali::Accessibility::ActorAccessible*>(mChildren[i]);
}
}
// If can't find its children, return the default window.
- return mChildren[0];
+ return dynamic_cast<Dali::Accessibility::ActorAccessible*>(mChildren[0]);
}
bool DoGesture(const Dali::Accessibility::GestureInfo& gestureInfo) override
{"", "root"});
}
-void BridgeObject::EmitSocketAvailable(Accessible* obj)
-{
- if(!IsUp() || obj->IsHidden()) //TODO Suppress SocketAvailable event
- {
- return;
- }
-
- mDbusServer.emit2<Address, Address>(
- GetAccessiblePath(obj),
- Accessible::GetInterfaceName(AtspiInterface::SOCKET),
- "Available",
- obj->GetAddress(),
- {"", "root"});
-}
-
void BridgeObject::EmitScrollStarted(Accessible* obj)
{
if(!IsUp() || obj->IsHidden() || obj->GetSuppressedEvents()[AtspiEvent::SCROLL_STARTED])
*/
void EmitMovedOutOfScreen(Dali::Accessibility::Accessible* obj, Dali::Accessibility::ScreenRelativeMoveType type) override;
- /**
- * @copydoc Dali::Accessibility::Bridge::EmitSocketAvailable()
- */
- void EmitSocketAvailable(Dali::Accessibility::Accessible* obj) override;
-
/**
* @copydoc Dali::Accessibility::Bridge::EmitScrollStarted()
*/
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return std::string{widgetInstanceId};
}
-void Accessibility::Accessible::EmitStateChanged(Accessibility::State state, int newValue, int reserved)
-{
-}
-
-void Accessibility::Accessible::Emit(Accessibility::ObjectPropertyChangeEvent event)
-{
-}
-
-void Accessibility::Accessible::EmitHighlighted(bool set)
-{
-}
-
-void Accessibility::Accessible::EmitBoundsChanged(Rect<> rect)
-{
-}
-
-void Accessibility::Accessible::EmitShowing(bool showing)
-{
-}
-
-void Accessibility::Accessible::EmitFocused(bool set)
-{
-}
-
-void Accessibility::Accessible::EmitVisible(bool visible)
-{
-}
-
-void Accessibility::Accessible::EmitTextInserted(unsigned int position, unsigned int length, const std::string& content)
-{
-}
-
-void Accessibility::Accessible::EmitTextDeleted(unsigned int position, unsigned int length, const std::string& content)
-{
-}
-
-void Accessibility::Accessible::EmitTextCursorMoved(unsigned int cursorPosition)
-{
-}
-
-void Accessibility::Accessible::EmitActiveDescendantChanged(Accessibility::Accessible* child)
-{
-}
-
-void Accessibility::Accessible::EmitMovedOutOfScreen(Accessibility::ScreenRelativeMoveType type)
-{
-}
-
-void Accessibility::Accessible::EmitSocketAvailable()
-{
-}
-
-void Accessibility::Accessible::EmitScrollStarted()
-{
-}
-
-void Accessibility::Accessible::EmitScrollFinished()
-{
-}
-
-void Accessibility::Accessible::NotifyAccessibilityStateChange(Accessibility::States states, bool isRecursive)
-{
-}
-
} // namespace Dali
{
}
- void EmitSocketAvailable(Accessibility::Accessible* obj) override
- {
- }
-
void EmitScrollStarted(Accessibility::Accessible* obj) override
{
}
fprintf(output, "{\"Cmd\":\"END_RENDER_PASS\"}\n");
break;
}
+ case GLES::CommandType::READ_PIXELS:
+ {
+ fprintf(output, "{\"Cmd\":\"READ_PIXELS\"}\n");
+ break;
+ }
case GLES::CommandType::PRESENT_RENDER_TARGET:
{
fprintf(output, "{\"Cmd\":\"PRESENT_RENDER_TARGET\"}\n");
}
break;
}
+ case GLES::CommandType::READ_PIXELS:
+ {
+ mCurrentContext->ReadPixels(cmd.readPixelsBuffer.buffer);
+ break;
+ }
case GLES::CommandType::PRESENT_RENDER_TARGET:
{
ResolvePresentRenderTarget(cmd.presentRenderTarget.targetToPresent);
}
}
+void Context::ReadPixels(uint8_t* buffer)
+{
+ if(mImpl->mCurrentRenderTarget)
+ {
+ GLES::Framebuffer* framebuffer = mImpl->mCurrentRenderTarget->GetFramebuffer();
+ auto* gl = mImpl->GetGL();
+ if(framebuffer && gl)
+ {
+ gl->Finish(); // To guarantee ReadPixels.
+ gl->ReadPixels(0, 0, framebuffer->GetCreateInfo().size.width, framebuffer->GetCreateInfo().size.height, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
+ }
+ }
+}
+
+
void Context::ClearState()
{
mImpl->mCurrentTextureBindings.clear();
*/
void EndRenderPass(TextureDependencyChecker& checker);
+ /**
+ * @brief Request to read pixels
+ * @param[out] buffer to load pixel data.
+ */
+ void ReadPixels(uint8_t* buffer);
+
/**
* @brief Returns the cache of GL state in the context
* @return the reference of GL state cache (which can be modified)
command->endRenderPass.syncObject = static_cast<GLES::SyncObject*>(syncObject);
}
+void CommandBuffer::ReadPixels(uint8_t* buffer)
+{
+ auto command = mCommandPool->AllocateCommand(CommandType::READ_PIXELS);
+ command->readPixelsBuffer.buffer = buffer;
+}
+
void CommandBuffer::ExecuteCommandBuffers(std::vector<const Graphics::CommandBuffer*>&& commandBuffers)
{
auto command = mCommandPool->AllocateCommand(CommandType::EXECUTE_COMMAND_BUFFERS);
SET_VIEWPORT,
BEGIN_RENDERPASS,
END_RENDERPASS,
+ READ_PIXELS,
EXECUTE_COMMAND_BUFFERS,
PRESENT_RENDER_TARGET,
SET_COLOR_MASK,
Graphics::SyncObject* syncObject;
} endRenderPass;
+ struct
+ {
+ uint8_t* buffer;
+ } readPixelsBuffer;
+
struct
{
IndirectPtr<const GLES::CommandBuffer*> buffers;
*/
void EndRenderPass(Graphics::SyncObject* syncObject) override;
+ /**
+ * @copydoc Dali::Graphics::CommandBuffer::ReadPixels
+ */
+ void ReadPixels(uint8_t* buffer) override;
+
/**
* @copydoc Dali::Graphics::CommandBuffer::ExecuteCommandBuffers
*/
{
auto shader = gl->CreateShader(pipelineStage);
const auto src = !sourcePreprocessed.empty() ? reinterpret_cast<const char*>(sourcePreprocessed.data()) : reinterpret_cast<const char*>(createInfo.sourceData);
- GLint size = !sourcePreprocessed.empty() ? GLint(sourcePreprocessed.size()) : createInfo.sourceSize;
+
+ // null-terminated char already included. So we should remove last character (null terminator) from size.
+ GLint size = (!sourcePreprocessed.empty() ? GLint(sourcePreprocessed.size()) : createInfo.sourceSize) - 1u;
+
gl->ShaderSource(shader, 1, const_cast<const char**>(&src), &size);
gl->CompileShader(shader);
return;
}
- sourcePreprocessed.resize(size + 1 /* Include null-terminated char */);
- sourcePreprocessed[size] = '\0';
+ const uint8_t* dataPtr = reinterpret_cast<const uint8_t*>(data);
+
+ if(*(dataPtr + size - 1) != '\0')
+ {
+ sourcePreprocessed.resize(size + 1 /* Include null-terminated char */);
+ sourcePreprocessed[size] = '\0';
+ }
+ else
+ {
+ // null-terminated char already included.
+ sourcePreprocessed.resize(size);
+ }
- std::copy(reinterpret_cast<const uint8_t*>(data),
- reinterpret_cast<const uint8_t*>(data) + size,
- sourcePreprocessed.data());
+ std::copy(dataPtr, dataPtr + size, sourcePreprocessed.data());
}
EglGraphicsController& controller;
}
mFramebufferTextureDependencies.clear();
- // VD TRUNK-2025 block these codes
- // for(uint32_t nativeIndex = 0u; nativeIndex < 2u; ++nativeIndex)
- // {
- // for(auto& nativeTextureDependency : mNativeTextureDependencies[nativeIndex])
- // {
- // mController.GetSyncPool().FreeSyncObject(nativeTextureDependency.agingSyncObject);
- // }
- // mNativeTextureDependencies[nativeIndex].clear();
- // }
+ for(uint32_t nativeIndex = 0u; nativeIndex < 2u; ++nativeIndex)
+ {
+ for(auto& nativeTextureDependency : mNativeTextureDependencies[nativeIndex])
+ {
+ if(nativeTextureDependency.agingSyncObject != nullptr)
+ {
+ mController.GetSyncPool().FreeSyncObject(nativeTextureDependency.agingSyncObject);
+ }
+ }
+ mNativeTextureDependencies[nativeIndex].clear();
+ }
}
}
void TextureDependencyChecker::Reset()
}
mFramebufferTextureDependencies.clear();
- // VD TRUNK-2025 block these codes
-
- // if(mNativeTextureDependencies[0].size() > 0 || mNativeTextureDependencies[1].size())
- // {
- // DALI_ASSERT_ALWAYS(mIsFirstPreparedNativeTextureDependency && "CreateNativeTextureSync should be called before PostRender!");
+ if(mNativeTextureDependencies[0].size() > 0 || mNativeTextureDependencies[1].size())
+ {
+ DALI_ASSERT_ALWAYS(mIsFirstPreparedNativeTextureDependency && "CreateNativeTextureSync should be called before PostRender!");
- // // Remove all infomations about previous native textures
- // for(auto& nativeTextureDependency : mNativeTextureDependencies[mPreviousNativeTextureDependencyIndex])
- // {
- // mController.GetSyncPool().FreeSyncObject(nativeTextureDependency.agingSyncObject);
- // }
- // mNativeTextureDependencies[mPreviousNativeTextureDependencyIndex].clear();
+ // Remove all infomations about previous native textures
+ for(auto& nativeTextureDependency : mNativeTextureDependencies[mPreviousNativeTextureDependencyIndex])
+ {
+ if(nativeTextureDependency.agingSyncObject != nullptr)
+ {
+ mController.GetSyncPool().FreeSyncObject(nativeTextureDependency.agingSyncObject);
+ }
+ }
+ mNativeTextureDependencies[mPreviousNativeTextureDependencyIndex].clear();
- // mCurrentNativeTextureDependencyIndex = __sync_fetch_and_xor(&mPreviousNativeTextureDependencyIndex, 1);
- // }
+ mCurrentNativeTextureDependencyIndex = __sync_fetch_and_xor(&mPreviousNativeTextureDependencyIndex, 1);
+ }
}
void TextureDependencyChecker::AddTextures(const GLES::Context* writeContext, const GLES::Framebuffer* framebuffer)
}
}
- // VD TRUNK-2025 block these codes
+ // Native dependency check
+ if(texture->IsNativeTexture())
+ {
+ // TODO : Optimize here. For now, we don't have too much EndPass call. So just keep this logic.
+ for(auto& nativeTextureDependency : mNativeTextureDependencies[mPreviousNativeTextureDependencyIndex])
+ {
+ if(nativeTextureDependency.synced)
+ {
+ // Fast-out if we know it is already synced
+ continue;
+ }
- // // Native dependency check
- // if(texture->IsNativeTexture())
- // {
- // // TODO : Optimize here. For now, we don't have too much EndPass call. So just keep this logic.
- // for(auto& nativeTextureDependency : mNativeTextureDependencies[mPreviousNativeTextureDependencyIndex])
- // {
- // if(nativeTextureDependency.synced)
- // {
- // // Fast-out if we know it is already synced
- // continue;
- // }
+ auto iter = nativeTextureDependency.textures.find(texture);
+ if(iter != nativeTextureDependency.textures.end())
+ {
+ if(nativeTextureDependency.agingSyncObject != nullptr)
+ {
+ if(cpu)
+ {
+ DALI_LOG_INFO(gLogSyncFilter, Debug::Verbose, "TextureDependencyChecker::CheckNeedsSync (for native) Insert CPU WAIT");
+ nativeTextureDependency.synced = mController.GetSyncPool().ClientWait(nativeTextureDependency.agingSyncObject);
- // auto iter = nativeTextureDependency.textures.find(texture);
- // if(iter != nativeTextureDependency.textures.end())
- // {
- // if(nativeTextureDependency.agingSyncObject != nullptr)
- // {
- // if(cpu)
- // {
- // DALI_LOG_INFO(gLogSyncFilter, Debug::Verbose, "TextureDependencyChecker::CheckNeedsSync (for native) Insert CPU WAIT");
- // nativeTextureDependency.synced = mController.GetSyncPool().ClientWait(nativeTextureDependency.agingSyncObject);
- // }
- // else
- // {
- // // Wait on the sync object in GPU. This will ensure that the writeContext completes its tasks prior
- // // to the sync point.
- // // However, this may instead timeout, and we can't tell the difference (at least, for glFenceSync)
- // DALI_LOG_INFO(gLogSyncFilter, Debug::Verbose, "TextureDependencyChecker::CheckNeedsSync (for native) Insert GPU WAIT");
- // mController.GetSyncPool().Wait(nativeTextureDependency.agingSyncObject);
- // }
- // }
+ if(DALI_LIKELY(nativeTextureDependency.synced) && readContext == nativeTextureDependency.agingSyncObject->writeContext)
+ {
+ // We can free sync object immediatly if we are using same context.
+ mController.GetSyncPool().FreeSyncObject(nativeTextureDependency.agingSyncObject);
+ nativeTextureDependency.agingSyncObject = nullptr;
+ }
+ }
+ else
+ {
+ // Wait on the sync object in GPU. This will ensure that the writeContext completes its tasks prior
+ // to the sync point.
+ // However, this may instead timeout, and we can't tell the difference (at least, for glFenceSync)
+ DALI_LOG_INFO(gLogSyncFilter, Debug::Verbose, "TextureDependencyChecker::CheckNeedsSync (for native) Insert GPU WAIT");
+ mController.GetSyncPool().Wait(nativeTextureDependency.agingSyncObject);
+ }
+ }
- // nativeTextureDependency.textures.erase(iter);
- // }
- // }
- // }
+ nativeTextureDependency.textures.erase(iter);
+ }
+ }
+ }
}
void TextureDependencyChecker::MarkNativeTexturePrepared(const GLES::Texture* texture)
{
- // VD TRUNK-2025 block these codes
- // if(DALI_LIKELY(texture->IsNativeTexture()))
- // {
- // if(mIsFirstPreparedNativeTextureDependency)
- // {
- // mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].emplace_back();
- // mIsFirstPreparedNativeTextureDependency = false;
- // }
+ if(DALI_LIKELY(texture->IsNativeTexture()))
+ {
+ if(mIsFirstPreparedNativeTextureDependency)
+ {
+ mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].emplace_back();
+ mIsFirstPreparedNativeTextureDependency = false;
+ }
- // if(DALI_LIKELY(!mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].empty()))
- // {
- // auto& nativeTextureDependency = mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].back();
- // nativeTextureDependency.textures.insert(texture);
- // }
- // }
+ if(DALI_LIKELY(!mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].empty()))
+ {
+ auto& nativeTextureDependency = mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].back();
+ nativeTextureDependency.textures.insert(texture);
+ }
+ }
}
void TextureDependencyChecker::DiscardNativeTexture(const GLES::Texture* texture)
{
- // VD TRUNK-2025 block these codes
- // if(DALI_LIKELY(texture->IsNativeTexture()))
- // {
- // for(uint32_t nativeIndex = 0u; nativeIndex < 2u; ++nativeIndex)
- // {
- // for(auto iter = mNativeTextureDependencies[nativeIndex].begin(); iter != mNativeTextureDependencies[nativeIndex].end();)
- // {
- // auto& nativeTextureDependency = *iter;
+ if(DALI_LIKELY(texture->IsNativeTexture()))
+ {
+ for(uint32_t nativeIndex = 0u; nativeIndex < 2u; ++nativeIndex)
+ {
+ for(auto iter = mNativeTextureDependencies[nativeIndex].begin(); iter != mNativeTextureDependencies[nativeIndex].end();)
+ {
+ auto& nativeTextureDependency = *iter;
- // bool isErased = false;
+ bool isErased = false;
- // auto jter = nativeTextureDependency.textures.find(texture);
- // if(jter != nativeTextureDependency.textures.end())
- // {
- // nativeTextureDependency.textures.erase(jter);
- // if(nativeTextureDependency.textures.empty())
- // {
- // mController.GetSyncPool().FreeSyncObject(nativeTextureDependency.agingSyncObject);
- // iter = mNativeTextureDependencies[nativeIndex].erase(iter);
+ auto jter = nativeTextureDependency.textures.find(texture);
+ if(jter != nativeTextureDependency.textures.end())
+ {
+ nativeTextureDependency.textures.erase(jter);
+ if(nativeTextureDependency.textures.empty())
+ {
+ mController.GetSyncPool().FreeSyncObject(nativeTextureDependency.agingSyncObject);
+ iter = mNativeTextureDependencies[nativeIndex].erase(iter);
- // isErased = true;
- // }
- // }
+ isErased = true;
+ }
+ }
- // if(!isErased)
- // {
- // ++iter;
- // }
- // }
- // }
- // }
+ if(!isErased)
+ {
+ ++iter;
+ }
+ }
+ }
+ }
}
void TextureDependencyChecker::CreateNativeTextureSync(const GLES::Context* writeContext)
{
- // VD TRUNK-2025 block these codes
- // if(mIsFirstPreparedNativeTextureDependency)
- // {
- // return;
- // }
+ if(mIsFirstPreparedNativeTextureDependency)
+ {
+ return;
+ }
- // // Reset flag
- // mIsFirstPreparedNativeTextureDependency = true;
+ // Reset flag
+ mIsFirstPreparedNativeTextureDependency = true;
- // if(DALI_LIKELY(!mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].empty()))
- // {
- // auto& nativeTextureDependency = mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].back();
+ if(DALI_LIKELY(!mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].empty()))
+ {
+ auto& nativeTextureDependency = mNativeTextureDependencies[mCurrentNativeTextureDependencyIndex].back();
- // DALI_LOG_INFO(gLogSyncFilter, Debug::Verbose, "TextureDependencyChecker::CreateNativeTextureSync() Allocating sync object\n");
- // nativeTextureDependency.agingSyncObject = mController.GetSyncPool().AllocateSyncObject(writeContext, SyncPool::SyncContext::EGL);
- // }
+ DALI_LOG_INFO(gLogSyncFilter, Debug::Verbose, "TextureDependencyChecker::CreateNativeTextureSync() Allocating sync object\n");
+ nativeTextureDependency.agingSyncObject = mController.GetSyncPool().AllocateSyncObject(writeContext, SyncPool::SyncContext::EGL);
+ }
}
} // namespace Dali::Graphics::GLES
mCommandBuffer.endRenderPass();
}
+void CommandBufferImpl::ReadPixels(uint8_t* buffer)
+{
+}
+
void CommandBufferImpl::PipelineBarrier(
vk::PipelineStageFlags srcStageMask,
vk::PipelineStageFlags dstStageMask,
*/
void EndRenderPass();
+ /**
+ * Request to read pixels.
+ */
+ void ReadPixels(uint8_t* buffer);
+
void PipelineBarrier(vk::PipelineStageFlags srcStageMask,
vk::PipelineStageFlags dstStageMask,
vk::DependencyFlags dependencyFlags,
mCommandBufferImpl->EndRenderPass();
}
+void CommandBuffer::ReadPixels(uint8_t* buffer)
+{
+ mCommandBufferImpl->ReadPixels(buffer);
+}
+
void CommandBuffer::ExecuteCommandBuffers(std::vector<const Graphics::CommandBuffer*>&& gfxCommandBuffers)
{
std::vector<vk::CommandBuffer> vkCommandBuffers;
*/
void EndRenderPass(Graphics::SyncObject* syncObject) override;
+ /**
+ * @copydoc Dali::Graphics::CommandBuffer::ReadPixels
+ */
+ void ReadPixels(uint8_t* buffer) override;
+
/**
* @brief Executes a list of secondary command buffers
*
return;
}
- sourcePreprocessed.resize(size + 1 /* Include null-terminated char */);
- sourcePreprocessed[size] = '\0';
+ const uint8_t* dataPtr = reinterpret_cast<const uint8_t*>(data);
- std::copy(reinterpret_cast<const uint8_t*>(data),
- reinterpret_cast<const uint8_t*>(data) + size,
- sourcePreprocessed.data());
+ if(*(dataPtr + size - 1) != '\0')
+ {
+ sourcePreprocessed.resize(size + 1 /* Include null-terminated char */);
+ sourcePreprocessed[size] = '\0';
+ }
+ else
+ {
+ // null-terminated char already included.
+ sourcePreprocessed.resize(size);
+ }
+
+ std::copy(dataPtr, dataPtr + size, sourcePreprocessed.data());
}
VulkanGraphicsController& controller;
return success;
}
+bool NativeImageSourceAndroid::SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat)
+{
+ return false;
+}
+
void NativeImageSourceAndroid::SetSource(Any source)
{
if(mPixmap)
*/
bool GetPixels(std::vector<uint8_t>& pixbuf, uint32_t& width, uint32_t& height, Pixel::Format& pixelFormat) const override;
+ /**
+ * @copydoc Dali::NativeImageSource::SetPixels()
+ */
+ bool SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat) override;
+
/**
* @copydoc Dali::NativeImageSource::SetSource( Any source )
*/
*/
virtual bool GetPixels(std::vector<uint8_t>& pixbuf, uint32_t& width, uint32_t& height, Pixel::Format& pixelFormat) const = 0;
+ /**
+ * @copydoc Dali::NativeImageSource::SetPixels()
+ */
+ virtual bool SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat) = 0;
+
/**
* @copydoc Dali::NativeImageSource::SetSource( Any source )
*/
return true;
}
+bool NativeImageSourceCocoa::SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat)
+{
+ return false;
+}
+
void NativeImageSourceCocoa::SetSource(Any source)
{
}
uint32_t& height,
Pixel::Format& pixelFormat) const override;
+ /**
+ * @copydoc Dali::NativeImageSource::SetPixels()
+ */
+ bool SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat) override;
+
/**
* @copydoc Dali::NativeImageSource::SetSource( Any source )
*/
return false;
}
+bool NativeImageSourceTizen::SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat)
+{
+ std::scoped_lock lock(mMutex);
+ if(mTbmSurface != NULL)
+ {
+ tbm_surface_info_s surface_info;
+
+ if(tbm_surface_map(mTbmSurface, TBM_SURF_OPTION_READ | TBM_SURF_OPTION_WRITE, &surface_info) != TBM_SURFACE_ERROR_NONE)
+ {
+ DALI_LOG_ERROR("Fail to map tbm_surface\n");
+ return false;
+ }
+ tbm_surface_internal_ref(mTbmSurface);
+
+ if(pixelFormat != Pixel::Format::RGBA8888 && pixelFormat != Pixel::Format::RGB888)
+ {
+ DALI_LOG_ERROR("Not Supported PixelFormat\n");
+ return false;
+ }
+
+ tbm_format format = surface_info.format;
+ uint32_t stride = surface_info.planes[0].stride;
+ uint8_t* ptr = surface_info.planes[0].ptr;
+
+ size_t lineSize;
+ size_t inputBufferLinePixelSize = Dali::Pixel::GetBytesPerPixel(pixelFormat);
+
+ switch(format)
+ {
+ case TBM_FORMAT_RGB888:
+ {
+ lineSize = mWidth * inputBufferLinePixelSize;
+ uint8_t* bufptr = &pixbuf[0];
+
+ for(uint32_t r = 0; r < mHeight; ++r, bufptr += lineSize)
+ {
+ for(uint32_t c = 0; c < mWidth; ++c)
+ {
+ size_t sOffset = c * inputBufferLinePixelSize;
+ size_t dOffset = c * 3;
+ size_t offset = dOffset + r * stride;
+ ptr[offset + 2] = *(bufptr + sOffset);
+ ptr[offset + 1] = *(bufptr + sOffset + 1);
+ ptr[offset] = *(bufptr + sOffset + 2);
+ }
+ }
+ break;
+ }
+ case TBM_FORMAT_RGBA8888:
+ {
+ lineSize = mWidth * inputBufferLinePixelSize;
+ uint8_t* bufptr = &pixbuf[0];
+
+ for(uint32_t r = 0; r < mHeight; ++r, bufptr += lineSize)
+ {
+ for(uint32_t c = 0; c < mWidth; ++c)
+ {
+ size_t sOffset = c * inputBufferLinePixelSize;
+ size_t dOffset = c * 4;
+ size_t offset = dOffset + r * stride;
+ ptr[offset + 3] = *(bufptr + sOffset);
+ ptr[offset + 2] = *(bufptr + sOffset + 1);
+ ptr[offset + 1] = *(bufptr + sOffset + 2);
+ ptr[offset] = (inputBufferLinePixelSize == 4) ? *(bufptr + sOffset + 3) : 0xFF;
+ }
+ }
+ break;
+ }
+ case TBM_FORMAT_ARGB8888:
+ {
+ lineSize = mWidth * inputBufferLinePixelSize;
+ uint8_t* bufptr = &pixbuf[0];
+
+ for(uint32_t r = 0; r < mHeight; ++r, bufptr += lineSize)
+ {
+ for(uint32_t c = 0; c < mWidth; ++c)
+ {
+ size_t sOffset = c * inputBufferLinePixelSize;
+ size_t dOffset = c * 4;
+ size_t offset = dOffset + r * stride;
+ ptr[offset + 2] = *(bufptr + sOffset);
+ ptr[offset + 1] = *(bufptr + sOffset + 1);
+ ptr[offset] = *(bufptr + sOffset + 2);
+ ptr[offset + 3] = (inputBufferLinePixelSize == 4) ? *(bufptr + sOffset + 3) : 0xFF;
+ }
+ }
+ break;
+ }
+ default:
+ {
+ DALI_ASSERT_ALWAYS(0 && "Tbm surface has unsupported pixel format.\n");
+
+ return false;
+ }
+ }
+
+ if(tbm_surface_unmap(mTbmSurface) != TBM_SURFACE_ERROR_NONE)
+ {
+ DALI_LOG_ERROR("Fail to unmap tbm_surface\n");
+ }
+ tbm_surface_internal_unref(mTbmSurface);
+
+ return true;
+ }
+
+ DALI_LOG_WARNING("TBM surface does not exist.\n");
+
+ return false;
+}
+
void NativeImageSourceTizen::SetSource(Any source)
{
std::scoped_lock lock(mMutex);
*/
bool GetPixels(std::vector<uint8_t>& pixbuf, uint32_t& width, uint32_t& height, Pixel::Format& pixelFormat) const override;
+ /**
+ * @copydoc Dali::NativeImageSource::SetPixels()
+ */
+ bool SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat) override;
+
/**
* @copydoc Dali::NativeImageSource::SetSource( Any source )
*/
return success;
}
+bool NativeImageSourceX::SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat)
+{
+ return false;
+}
+
void NativeImageSourceX::SetSource(Any source)
{
mPixmap = GetPixmapFromAny(source);
*/
bool GetPixels(std::vector<uint8_t>& pixbuf, uint32_t& width, uint32_t& height, Pixel::Format& pixelFormat) const override;
+ /**
+ * @copydoc Dali::NativeImageSource::SetPixels()
+ */
+ bool SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat) override;
+
/**
* @copydoc Dali::NativeImageSource::SetSource( Any source )
*/
return success;
}
+bool NativeImageSourceWin::SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat)
+{
+ return false;
+}
+
void NativeImageSourceWin::SetSource(Any source)
{
mPixmap = GetPixmapFromAny(source);
*/
bool GetPixels(std::vector<uint8_t>& pixbuf, uint32_t& width, uint32_t& height, Pixel::Format& pixelFormat) const override;
+ /**
+ * @copydoc Dali::NativeImageSource::SetPixels()
+ */
+ bool SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat) override;
+
/**
* @copydoc Dali::NativeImageSource::SetSource( Any source )
*/
return success;
}
+bool NativeImageSourceX::SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat)
+{
+ return false;
+}
+
void NativeImageSourceX::SetSource(Any source)
{
mPixmap = GetPixmapFromAny(source);
*/
bool GetPixels(std::vector<unsigned char>& pixbuf, uint32_t& width, uint32_t& height, Pixel::Format& pixelFormat) const override;
+ /**
+ * @copydoc Dali::NativeImageSource::SetPixels()
+ */
+ bool SetPixels(uint8_t* pixbuf, const Pixel::Format& pixelFormat) override;
+
/**
* @copydoc Dali::NativeImageSource::SetSource( Any source )
*/
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/pixel-data-integ.h>
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/render-tasks/render-task-list.h>
#include <string.h>
namespace
{
static constexpr uint32_t ORDER_INDEX_CAPTURE_RENDER_TASK = 1000;
-constexpr int32_t SHADER_VERSION_NATIVE_IMAGE_SOURCE_AVAILABLE = 300;
constexpr uint32_t TIME_OUT_DURATION = 1000;
constexpr int32_t GL_VERSION_NATIVE_IMAGE_SOURCE_AVAILABLE = 30;
} // namespace
: mQuality(DEFAULT_QUALITY),
mTimer(),
mPath(),
- mNativeImageSourcePtr(NULL),
mFileSave(false),
mUseDefaultCamera(true),
mSceneOffCameraAfterCaptureFinished(false)
mCameraActor(cameraActor),
mTimer(),
mPath(),
- mNativeImageSourcePtr(NULL),
mFileSave(false),
mUseDefaultCamera(!cameraActor),
mSceneOffCameraAfterCaptureFinished(false)
{
Adaptor::Get().UnregisterProcessorOnce(*this, true);
}
- DeleteNativeImageSource();
mTexture.Reset();
}
// Increase the reference count focely to avoid application mistake.
Reference();
+ UnsetResources();
+ SetupResources(position, size, clearColor, source);
+
mPath = path;
if(!mPath.empty())
{
mFileSave = true;
}
-
- UnsetResources();
- SetupResources(position, size, clearColor, source);
+ mRenderTask.KeepRenderResult();
mInCapture = true;
Adaptor::Get().RegisterProcessorOnce(*this, true);
return mIsExclusive;
}
-Dali::NativeImageSourcePtr Capture::GetNativeImageSource() const
+Dali::NativeImageSourcePtr Capture::GetNativeImageSource()
{
- return mNativeImageSourcePtr;
+ Dali::NativeImageSourcePtr result;
+ if(mRenderTask)
+ {
+ Dali::PixelData pixelData = mRenderTask.GetRenderResult();
+ if(pixelData)
+ {
+ auto pixelDataBuffer = Dali::Integration::GetPixelDataBuffer(pixelData);
+ NativeImageSourcePtr nativeImageSourcePtr = Dali::NativeImageSource::New(pixelData.GetWidth(), pixelData.GetHeight(), Dali::NativeImageSource::COLOR_DEPTH_32); // Texture pixel format is RGBA8888
+
+ if(Dali::DevelNativeImageSource::SetPixels(*nativeImageSourcePtr, pixelDataBuffer.buffer, pixelData.GetPixelFormat()))
+ {
+ result = nativeImageSourcePtr;
+ }
+ }
+ }
+ return result;
}
Dali::Texture Capture::GetTexture() const
Dali::Devel::PixelBuffer Capture::GetCapturedBuffer()
{
- if(!mPixelBuffer || (mPixelBuffer && !mPixelBuffer.GetBuffer()))
+ Devel::PixelBuffer pixelBuffer;
+ if(mRenderTask)
{
- std::vector<uint8_t> buffer;
- uint32_t width, height;
- Dali::Pixel::Format pixelFormat;
- if(!mNativeImageSourcePtr->GetPixels(buffer, width, height, pixelFormat))
+ Dali::PixelData pixelData = mRenderTask.GetRenderResult();
+ if(pixelData)
{
- return Dali::Devel::PixelBuffer();
+ auto pixelDataBuffer = Dali::Integration::GetPixelDataBuffer(pixelData);
+ pixelBuffer = Dali::Devel::PixelBuffer::New(pixelData.GetWidth(), pixelData.GetHeight(), pixelData.GetPixelFormat());
+ memcpy(pixelBuffer.GetBuffer(), pixelDataBuffer.buffer, pixelDataBuffer.bufferSize);
}
- mPixelBuffer = Dali::Devel::PixelBuffer::New(width, height, pixelFormat);
- memcpy(mPixelBuffer.GetBuffer(), &buffer[0], width * height * Dali::Pixel::GetBytesPerPixel(pixelFormat));
}
- return mPixelBuffer;
+ return pixelBuffer;
}
Dali::Capture::CaptureFinishedSignalType& Capture::FinishedSignal()
void Capture::CreateTexture(const Vector2& size)
{
- if(!mNativeImageSourcePtr)
- {
- mNativeImageSourcePtr = Dali::NativeImageSource::New(size.width, size.height, Dali::NativeImageSource::COLOR_DEPTH_DEFAULT);
- mTexture = Dali::Texture::New(*mNativeImageSourcePtr);
- }
-}
-
-void Capture::DeleteNativeImageSource()
-{
- if(mNativeImageSourcePtr)
- {
- mNativeImageSourcePtr.Reset();
- }
+ mTexture = Dali::Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, unsigned(size.width), unsigned(size.height));
}
void Capture::CreateFrameBuffer()
Dali::RenderTaskList taskList = sceneHolder.GetRenderTaskList();
taskList.RemoveTask(mRenderTask);
}
+ mRenderTask.ClearRenderResult();
mRenderTask.Reset();
mSource.Reset();
+ mTexture.Reset();
mSceneHolderHandle.Reset();
}
bool Capture::SaveFile()
{
- if(mNativeImageSourcePtr)
+ Dali::PixelData pixelData = mRenderTask.GetRenderResult();
+ if(pixelData)
{
- return Dali::DevelNativeImageSource::EncodeToFile(*mNativeImageSourcePtr, mPath, mQuality);
+ auto pixelDataBuffer = Dali::Integration::GetPixelDataBuffer(pixelData);
+ return Dali::EncodeToFile(pixelDataBuffer.buffer, mPath, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight(), mQuality);
}
return false;
/**
* @copydoc Dali::Capture::GetNativeImageSource
*/
- Dali::NativeImageSourcePtr GetNativeImageSource() const;
+ Dali::NativeImageSourcePtr GetNativeImageSource();
/**
* @copydoc Dali::Capture::GetCapturedBuffer
*/
void CreateTexture(const Dali::Vector2& size);
- /**
- * @brief Delete native image source.
- */
- void DeleteNativeImageSource();
-
/**
* @brief Create frame buffer.
*/
Dali::Timer mTimer; ///< For timeout.
Dali::Capture::CaptureFinishedSignalType mFinishedSignal;
std::string mPath;
- Dali::NativeImageSourcePtr mNativeImageSourcePtr; ///< pointer to surface image
- Dali::Devel::PixelBuffer mPixelBuffer;
bool mInCapture{false};
bool mIsExclusive{false};
bool mFileSave;
// INTERNAL HEADERS
#include <dali/devel-api/adaptor-framework/accessibility-bridge.h>
-#include <dali/devel-api/atspi-interfaces/accessible.h>
+#include <dali/devel-api/adaptor-framework/actor-accessible.h>
#include <dali/integration-api/adaptor-framework/render-surface-interface.h>
#include <dali/internal/window-system/common/event-handler.h>
#include <dali/internal/window-system/common/orientation-impl.h>
if(Dali::Accessibility::IsUp())
{
- if(auto accessible = Dali::Accessibility::Accessible::Get(mScene.GetRootLayer()))
+ if(auto accessible = dynamic_cast<Accessibility::ActorAccessible*>(Accessibility::Accessible::Get(mScene.GetRootLayer())))
{
accessible->EmitBoundsChanged(Dali::Rect<>(oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight()));
}
if(Dali::Accessibility::IsUp())
{
- if(auto accessible = Dali::Accessibility::Accessible::Get(mScene.GetRootLayer()))
+ if(auto accessible = dynamic_cast<Accessibility::ActorAccessible*>(Accessibility::Accessible::Get(mScene.GetRootLayer())))
{
accessible->EmitBoundsChanged(Dali::Rect<>(position.GetX(), position.GetY(), oldRect.width, oldRect.height));
}
if((moved || resize) && Dali::Accessibility::IsUp())
{
- if(auto accessible = Dali::Accessibility::Accessible::Get(mScene.GetRootLayer()))
+ if(auto accessible = dynamic_cast<Accessibility::ActorAccessible*>(Accessibility::Accessible::Get(mScene.GetRootLayer())))
{
accessible->EmitBoundsChanged(Dali::Rect<>(positionSize.x, positionSize.y, positionSize.width, positionSize.height));
}
if((moved || resize) && Dali::Accessibility::IsUp())
{
- if(auto accessible = Dali::Accessibility::Accessible::Get(mScene.GetRootLayer()))
+ if(auto accessible = dynamic_cast<Accessibility::ActorAccessible*>(Accessibility::Accessible::Get(mScene.GetRootLayer())))
{
accessible->EmitBoundsChanged(Dali::Rect<>(positionSize.x, positionSize.y, positionSize.width, positionSize.height));
}
// EXTERNAL_HEADERS
#include <dali/integration-api/debug.h>
+#include <tbm_bufmgr.h>
#include <tbm_dummy_display.h>
#ifdef ECORE_WAYLAND2
{
namespace Adaptor
{
+namespace
+{
+/**
+ * @brief Helper class to make we keep NativeDisplay for NativeRenderSurface as unique pointer
+ * even if Application terminated and restart again.
+ *
+ * @note Follow by eglSpec, eglGetDipslay() creates new EGLDisplay per each input paramater,
+ * and never be deleted until process terminated. But we can re-create DisplayConnecter multiple times
+ * when we are using OffscreenApplication.
+ * So, we need to keep dummy NativeDisplay pointer to avoid creating multiple EGLDisplay.
+ */
+struct NativeRenderSurfaceDisplayHolder
+{
+ NativeRenderSurfaceDisplayHolder()
+ : mBufMgr(nullptr),
+ mDisplay(nullptr)
+ {
+ Initialize();
+ }
+ ~NativeRenderSurfaceDisplayHolder()
+ {
+ Destroy();
+ }
+
+ void Initialize()
+ {
+ mBufMgr = tbm_bufmgr_init(-1); // -1 is meaningless. The parameter in this function is deprecated.
+ if(mBufMgr)
+ {
+ mDisplay = reinterpret_cast<NativeDisplayType>(tbm_dummy_display_create());
+ }
+ }
+ void Destroy()
+ {
+#ifdef VULKAN_ENABLED
+ if(!mDisplay.Empty())
+ {
+ // TODO: Fix this call for Vulkan
+ //tbm_dummy_display_destroy(mDisplay.Get<tbm_dummy_display>());
+ }
+#else
+ if(mDisplay)
+ {
+ tbm_dummy_display_destroy(reinterpret_cast<tbm_dummy_display*>(mDisplay));
+ }
+#endif
+ if(mBufMgr)
+ {
+ tbm_bufmgr_deinit(mBufMgr);
+ }
+ }
+
+ tbm_bufmgr mBufMgr; ///< For creating tbm_dummy_display
+
+ NativeDisplayType mDisplay;
+};
+
+static NativeDisplayType GetUniqueTbmDummyDisplay()
+{
+ static NativeRenderSurfaceDisplayHolder sNativeRenderSurfaceDisplayHolder;
+ if(sNativeRenderSurfaceDisplayHolder.mBufMgr == nullptr)
+ {
+ // Retry to initialize tbm bufmgr
+ sNativeRenderSurfaceDisplayHolder.Destroy();
+ sNativeRenderSurfaceDisplayHolder.Initialize();
+ if(sNativeRenderSurfaceDisplayHolder.mBufMgr == nullptr)
+ {
+ DALI_LOG_ERROR("Fail to init tbm buf mgr\n");
+ return nullptr;
+ }
+ }
+ return sNativeRenderSurfaceDisplayHolder.mDisplay;
+}
+} // namespace
+
DisplayConnection* DisplayConnectionEcoreWl::New()
{
DisplayConnection* pDisplayConnection(new DisplayConnectionEcoreWl());
DisplayConnectionEcoreWl::DisplayConnectionEcoreWl()
: mDisplay(NULL),
- mSurfaceType(Integration::RenderSurfaceInterface::WINDOW_RENDER_SURFACE),
- mBufMgr(nullptr)
+ mSurfaceType(Integration::RenderSurfaceInterface::WINDOW_RENDER_SURFACE)
{
}
NativeDisplayType DisplayConnectionEcoreWl::GetNativeDisplay()
{
- mBufMgr = tbm_bufmgr_init(-1); // -1 is meaningless. The parameter in this function is deprecated.
- if(mBufMgr == nullptr)
- {
- DALI_LOG_ERROR("Fail to init tbm buf mgr\n");
- return nullptr;
- }
- return NativeDisplayType(tbm_dummy_display_create());
+ return GetUniqueTbmDummyDisplay();
}
void DisplayConnectionEcoreWl::ReleaseNativeDisplay()
{
-#ifdef VULKAN_ENABLED
- if(!mDisplay.Empty())
- {
- // TODO: Fix this call for Vulkan
- //tbm_dummy_display_destroy(mDisplay.Get<tbm_dummy_display>());
- }
-#else
- if(mDisplay)
- {
- tbm_dummy_display_destroy(reinterpret_cast<tbm_dummy_display*>(mDisplay));
- }
-#endif
- if(mBufMgr != nullptr)
- {
- tbm_bufmgr_deinit(mBufMgr);
- }
}
} // namespace Adaptor
*/
// EXTERNAL INCLUDES
-#include <tbm_bufmgr.h>
// INTERNAL INCLUDES
#include <dali/internal/window-system/common/display-connection-impl.h>
private:
NativeDisplayType mDisplay; ///< Wayland-display for rendering
Dali::Integration::RenderSurfaceInterface::Type mSurfaceType; ///< The surface type
- tbm_bufmgr mBufMgr; ///< For creating tbm_dummy_display
};
} // namespace Adaptor
return GetImpl(*this).IsExclusive();
}
-Dali::NativeImageSourcePtr Capture::GetNativeImageSource() const
+Dali::NativeImageSourcePtr Capture::GetNativeImageSource()
{
return GetImpl(*this).GetNativeImageSource();
}
* @SINCE_1_9.10
*
* @return NativeImageSourcePtr Captured result that can be rendered with DALi
+ * @note GetNativeImageSource is only available inside FinishedSignal.
*/
- Dali::NativeImageSourcePtr GetNativeImageSource() const;
+ Dali::NativeImageSourcePtr GetNativeImageSource();
/**
* @brief Get Texture of captured image.
*
* @return Texture Captured result
+ * @note GetTexture is only available inside FinishedSignal.
*/
Dali::Texture GetTexture() const;
projects / platform / core / uifw / dali-adaptor.git / commitdiff