#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/actors/actor-devel.h>
-#include <dali/devel-api/actors/layer-devel.h>
#include <dali/devel-api/common/capabilities.h>
#include <dali/integration-api/debug.h>
+#include <dali/internal/event/actors/actor-coords.h>
#include <dali/internal/event/actors/actor-parent.h>
#include <dali/internal/event/actors/actor-property-handler.h>
#include <dali/internal/event/actors/actor-relayouter.h>
#include <dali/internal/event/actors/camera-actor-impl.h>
#include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/common/property-helper.h>
#include <dali/internal/event/common/scene-impl.h>
#include <dali/internal/event/common/stage-impl.h>
DALI_PROPERTY("captureAllTouchAfterStart", BOOLEAN, true, false, false, Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START)
DALI_PROPERTY("touchAreaOffset", RECTANGLE, true, false, false, Dali::DevelActor::Property::TOUCH_AREA_OFFSET)
DALI_PROPERTY("blendEquation", INTEGER, true, false, false, Dali::DevelActor::Property::BLEND_EQUATION)
+DALI_PROPERTY("touchFocusable", BOOLEAN, true, false, false, Dali::DevelActor::Property::TOUCH_FOCUSABLE)
+DALI_PROPERTY("keyboardFocusableChildren", BOOLEAN, true, false, false, Dali::DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN)
DALI_PROPERTY_TABLE_END(DEFAULT_ACTOR_PROPERTY_START_INDEX, ActorDefaultProperties)
// Signals
}
}
-bool ScreenToLocalInternal(
- const Matrix& viewMatrix,
- const Matrix& projectionMatrix,
- const Matrix& worldMatrix,
- const Viewport& viewport,
- const Vector3& currentSize,
- float& localX,
- float& localY,
- float screenX,
- float screenY)
-{
- // Get the ModelView matrix
- Matrix modelView;
- Matrix::Multiply(modelView, worldMatrix, viewMatrix);
-
- // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
- Matrix invertedMvp(false /*don't init*/);
- Matrix::Multiply(invertedMvp, modelView, projectionMatrix);
- bool success = invertedMvp.Invert();
-
- // Convert to GL coordinates
- Vector4 screenPos(screenX - static_cast<float>(viewport.x), static_cast<float>(viewport.height) - screenY - static_cast<float>(viewport.y), 0.f, 1.f);
-
- Vector4 nearPos;
- if(success)
- {
- success = Unproject(screenPos, invertedMvp, static_cast<float>(viewport.width), static_cast<float>(viewport.height), nearPos);
- }
-
- Vector4 farPos;
- if(success)
- {
- screenPos.z = 1.0f;
- success = Unproject(screenPos, invertedMvp, static_cast<float>(viewport.width), static_cast<float>(viewport.height), farPos);
- }
-
- if(success)
- {
- Vector4 local;
- if(XyPlaneIntersect(nearPos, farPos, local))
- {
- Vector3 size = currentSize;
- localX = local.x + size.x * 0.5f;
- localY = local.y + size.y * 0.5f;
- }
- else
- {
- success = false;
- }
- }
-
- return success;
-}
-
} // unnamed namespace
ActorPtr Actor::New()
{
mTargetSize = size;
+ // Update the preferred size after relayoutting
+ // It should be used in the next relayoutting
+ if(mUseAnimatedSize & AnimatedSizeFlag::WIDTH && mRelayoutData)
+ {
+ mRelayoutData->preferredSize.width = mAnimatedSize.width;
+ }
+
+ if(mUseAnimatedSize & AnimatedSizeFlag::HEIGHT && mRelayoutData)
+ {
+ mRelayoutData->preferredSize.height = mAnimatedSize.height;
+ }
+
// node is being used in a separate thread; queue a message to set the value & base value
SceneGraph::NodeTransformPropertyMessage<Vector3>::Send(GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize);
{
if(!mRenderers)
{
- mRenderers = new RendererContainer;
- }
-
- if(mIsBlendEquationSet)
- {
- renderer.SetBlendEquation(static_cast<DevelBlendEquation::Type>(mBlendEquation));
+ mRenderers = new RendererContainer(GetEventThreadServices());
}
-
- uint32_t index = static_cast<uint32_t>(mRenderers->size()); // 4,294,967,295 renderers per actor
- RendererPtr rendererPtr = RendererPtr(&renderer);
- mRenderers->push_back(rendererPtr);
- AttachRendererMessage(GetEventThreadServices().GetUpdateManager(), GetNode(), renderer.GetRendererSceneObject());
- return index;
+ return mRenderers->Add(GetNode(), renderer, mIsBlendEquationSet, mBlendEquation);
}
uint32_t Actor::GetRendererCount() const
{
- uint32_t rendererCount(0);
- if(mRenderers)
- {
- rendererCount = static_cast<uint32_t>(mRenderers->size()); // 4,294,967,295 renderers per actor
- }
-
- return rendererCount;
+ return mRenderers ? mRenderers->GetCount() : 0u;
}
RendererPtr Actor::GetRendererAt(uint32_t index)
{
- RendererPtr renderer;
- if(index < GetRendererCount())
- {
- renderer = (*mRenderers)[index];
- }
-
- return renderer;
+ return mRenderers ? mRenderers->GetRendererAt(index) : nullptr;
}
void Actor::RemoveRenderer(Renderer& renderer)
{
if(mRenderers)
{
- RendererIter end = mRenderers->end();
- for(RendererIter iter = mRenderers->begin(); iter != end; ++iter)
- {
- if((*iter).Get() == &renderer)
- {
- mRenderers->erase(iter);
- DetachRendererMessage(GetEventThreadServices(), GetNode(), renderer.GetRendererSceneObject());
- break;
- }
- }
+ mRenderers->Remove(GetNode(), renderer);
}
}
void Actor::RemoveRenderer(uint32_t index)
{
- if(index < GetRendererCount())
+ if(mRenderers)
{
- RendererPtr renderer = (*mRenderers)[index];
- DetachRendererMessage(GetEventThreadServices(), GetNode(), renderer.Get()->GetRendererSceneObject());
- mRenderers->erase(mRenderers->begin() + index);
+ mRenderers->Remove(GetNode(), index);
}
}
{
if(mBlendEquation != blendEquation)
{
- mBlendEquation = blendEquation;
- uint32_t rendererCount = GetRendererCount();
- for(uint32_t i = 0; i < rendererCount; ++i)
+ mBlendEquation = blendEquation;
+ if(mRenderers)
{
- RendererPtr renderer = GetRendererAt(i);
- renderer->SetBlendEquation(static_cast<DevelBlendEquation::Type>(blendEquation));
+ mRenderers->SetBlending(blendEquation);
}
}
mIsBlendEquationSet = true;
return mBlendEquation;
}
+void Actor::SetTransparent(bool transparent)
+{
+ SetTransparentMessage(GetEventThreadServices(), GetNode(), transparent);
+}
+
+bool Actor::IsTransparent() const
+{
+ return GetNode().IsTransparent();
+}
+
void Actor::SetDrawMode(DrawMode::Type drawMode)
{
// this flag is not animatable so keep the value
bool Actor::ScreenToLocal(float& localX, float& localY, float screenX, float screenY) const
{
- // only valid when on-stage
- if(mScene && OnScene())
- {
- const RenderTaskList& taskList = mScene->GetRenderTaskList();
-
- Vector2 converted(screenX, screenY);
-
- // do a reverse traversal of all lists (as the default onscreen one is typically the last one)
- uint32_t taskCount = taskList.GetTaskCount();
- for(uint32_t i = taskCount; i > 0; --i)
- {
- RenderTaskPtr task = taskList.GetTask(i - 1);
- if(ScreenToLocal(*task, localX, localY, screenX, screenY))
- {
- // found a task where this conversion was ok so return
- return true;
- }
- }
- }
- return false;
+ return mScene && OnScene() && ConvertScreenToLocalRenderTaskList(mScene->GetRenderTaskList(), GetNode().GetWorldMatrix(0), GetCurrentSize(), localX, localY, screenX, screenY);
}
bool Actor::ScreenToLocal(const RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY) const
{
- bool retval = false;
- // only valid when on-stage
- if(OnScene())
- {
- CameraActor* camera = renderTask.GetCameraActor();
- if(camera)
- {
- Viewport viewport;
- renderTask.GetViewport(viewport);
-
- // need to translate coordinates to render tasks coordinate space
- Vector2 converted(screenX, screenY);
- if(renderTask.TranslateCoordinates(converted))
- {
- retval = ScreenToLocal(camera->GetViewMatrix(), camera->GetProjectionMatrix(), viewport, localX, localY, converted.x, converted.y);
- }
- }
- }
- return retval;
+ return OnScene() && ConvertScreenToLocalRenderTask(renderTask, GetNode().GetWorldMatrix(0), GetCurrentSize(), localX, localY, screenX, screenY);
}
bool Actor::ScreenToLocal(const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY) const
{
- return OnScene() && ScreenToLocalInternal(viewMatrix, projectionMatrix, GetNode().GetWorldMatrix(0), viewport, GetCurrentSize(), localX, localY, screenX, screenY);
+ return OnScene() && ConvertScreenToLocal(viewMatrix, projectionMatrix, GetNode().GetWorldMatrix(0), GetCurrentSize(), viewport, localX, localY, screenX, screenY);
}
ActorGestureData& Actor::GetGestureData()
mSensitive(true),
mLeaveRequired(false),
mKeyboardFocusable(false),
+ mKeyboardFocusableChildren(true),
+ mTouchFocusable(false),
mOnSceneSignalled(false),
mInsideOnSizeSet(false),
mInheritPosition(true),
mVisible(true),
mInheritLayoutDirection(true),
mCaptureAllTouchAfterStart(false),
+ mIsBlendEquationSet(false),
+ mNeedGesturePropagation(false),
mLayoutDirection(LayoutDirection::LEFT_TO_RIGHT),
mDrawMode(DrawMode::NORMAL),
mColorMode(Node::DEFAULT_COLOR_MODE),
mClippingMode(ClippingMode::DISABLED),
- mBlendEquation(DevelBlendEquation::ADD),
- mIsBlendEquationSet(false)
+ mBlendEquation(DevelBlendEquation::ADD)
{
}
delete mRelayoutData;
}
-void Actor::Add(Actor& child)
+void Actor::Add(Actor& child, bool notify)
+{
+ mParentImpl.Add(child, notify);
+}
+
+void Actor::Remove(Actor& child, bool notify)
{
- mParentImpl.Add(child);
+ mParentImpl.Remove(child, notify);
}
-void Actor::Remove(Actor& child)
+void Actor::SwitchParent(Actor& newParent)
{
- mParentImpl.Remove(child);
+ if(this == &newParent)
+ {
+ DALI_LOG_ERROR("Cannot add actor to itself");
+ return;
+ }
+
+ if(!this->OnScene() || !newParent.OnScene())
+ {
+ DALI_LOG_ERROR("Both of current parent and new parent must be on Scene");
+ return;
+ }
+
+ newParent.Add(*this, false);
}
uint32_t Actor::GetChildCount() const
mParentImpl.UnparentChildren();
}
-void Actor::ConnectToScene(uint32_t parentDepth)
+void Actor::ConnectToScene(uint32_t parentDepth, bool notify)
{
// This container is used instead of walking the Actor hierarchy.
// It protects us when the Actor hierarchy is modified during OnSceneConnectionExternal callbacks.
mScene->RequestRebuildDepthTree();
}
- // This stage is atomic i.e. not interrupted by user callbacks.
- RecursiveConnectToScene(connectionList, parentDepth + 1);
+ // This stage is not interrupted by user callbacks.
+ mParentImpl.RecursiveConnectToScene(connectionList, parentDepth + 1);
// Notify applications about the newly connected actors.
for(const auto& actor : connectionList)
{
- actor->NotifyStageConnection();
+ actor->NotifyStageConnection(notify);
}
RelayoutRequest();
}
-void Actor::RecursiveConnectToScene(ActorContainer& connectionList, uint32_t depth)
-{
- DALI_ASSERT_ALWAYS(!OnScene());
-
- mIsOnScene = true;
- mDepth = static_cast<uint16_t>(depth); // overflow ignored, not expected in practice
-
- ConnectToSceneGraph();
-
- // Notification for internal derived classes
- OnSceneConnectionInternal();
-
- // This stage is atomic; avoid emitting callbacks until all Actors are connected
- connectionList.push_back(ActorPtr(this));
-
- // Recursively connect children
- if(GetChildCount() > 0)
- {
- for(const auto& child : mParentImpl.GetChildrenInternal())
- {
- child->SetScene(*mScene);
- child->RecursiveConnectToScene(connectionList, depth + 1);
- }
- }
-}
-
/**
* This method is called when the Actor is connected to the Stage.
* The parent must have added its Node to the scene-graph.
OnSceneObjectAdd();
}
-void Actor::NotifyStageConnection()
+void Actor::NotifyStageConnection(bool notify)
{
// Actors can be removed (in a callback), before the on-stage stage is reported.
// The actor may also have been reparented, in which case mOnSceneSignalled will be true.
if(OnScene() && !mOnSceneSignalled)
{
- // Notification for external (CustomActor) derived classes
- OnSceneConnectionExternal(mDepth);
-
- if(!mOnSceneSignal.Empty())
+ if(notify)
{
- Dali::Actor handle(this);
- mOnSceneSignal.Emit(handle);
+ // Notification for external (CustomActor) derived classes
+ OnSceneConnectionExternal(mDepth);
+
+ if(!mOnSceneSignal.Empty())
+ {
+ Dali::Actor handle(this);
+ mOnSceneSignal.Emit(handle);
+ }
}
// Guard against Remove during callbacks
}
}
-void Actor::DisconnectFromStage()
+void Actor::DisconnectFromStage(bool notify)
{
// This container is used instead of walking the Actor hierachy.
// It protects us when the Actor hierachy is modified during OnSceneDisconnectionExternal callbacks.
mScene->RequestRebuildDepthTree();
}
- // This stage is atomic i.e. not interrupted by user callbacks
- RecursiveDisconnectFromStage(disconnectionList);
+ // This stage is not interrupted by user callbacks
+ mParentImpl.RecursiveDisconnectFromScene(disconnectionList);
// Notify applications about the newly disconnected actors.
for(const auto& actor : disconnectionList)
{
- actor->NotifyStageDisconnection();
+ actor->NotifyStageDisconnection(notify);
}
}
-void Actor::RecursiveDisconnectFromStage(ActorContainer& disconnectionList)
-{
- // need to change state first so that internals relying on IsOnScene() inside OnSceneDisconnectionInternal() get the correct value
- mIsOnScene = false;
-
- // Recursively disconnect children
- if(GetChildCount() > 0)
- {
- for(const auto& child : mParentImpl.GetChildrenInternal())
- {
- child->RecursiveDisconnectFromStage(disconnectionList);
- }
- }
-
- // This stage is atomic; avoid emitting callbacks until all Actors are disconnected
- disconnectionList.push_back(ActorPtr(this));
-
- // Notification for internal derived classes
- OnSceneDisconnectionInternal();
-
- DisconnectFromSceneGraph();
-}
-
/**
* This method is called by an actor or its parent, before a node removal message is sent.
* This is recursive; the child calls DisconnectFromStage() for its children.
OnSceneObjectRemove();
}
-void Actor::NotifyStageDisconnection()
+void Actor::NotifyStageDisconnection(bool notify)
{
// Actors can be added (in a callback), before the off-stage state is reported.
// Also if the actor was added & removed before mOnSceneSignalled was set, then we don't notify here.
// only do this step if there is a stage, i.e. Core is not being shut down
if(EventThreadServices::IsCoreRunning() && !OnScene() && mOnSceneSignalled)
{
- // Notification for external (CustomeActor) derived classes
- OnSceneDisconnectionExternal();
-
- if(!mOffSceneSignal.Empty())
+ if(notify)
{
- Dali::Actor handle(this);
- mOffSceneSignal.Emit(handle);
+ // Notification for external (CustomeActor) derived classes
+ OnSceneDisconnectionExternal();
+
+ if(!mOffSceneSignal.Empty())
+ {
+ Dali::Actor handle(this);
+ mOffSceneSignal.Emit(handle);
+ }
}
// Guard against Add during callbacks
bool Actor::IsNodeConnected() const
{
- bool connected(false);
-
- if(OnScene())
- {
- if(IsRoot() || GetNode().GetParent())
- {
- connected = true;
- }
- }
-
- return connected;
+ return OnScene() && (IsRoot() || GetNode().GetParent());
}
// This method initiates traversal of the actor tree using depth-first
OwnerPointer<SceneGraph::NodeDepths> sceneGraphNodeDepths(new SceneGraph::NodeDepths());
int32_t depthIndex = 1;
- DepthTraverseActorTree(sceneGraphNodeDepths, depthIndex);
+ mParentImpl.DepthTraverseActorTree(sceneGraphNodeDepths, depthIndex);
SetDepthIndicesMessage(GetEventThreadServices().GetUpdateManager(), sceneGraphNodeDepths);
DALI_LOG_TIMER_END(depthTimer, gLogFilter, Debug::Concise, "Depth tree traversal time: ");
}
-void Actor::DepthTraverseActorTree(OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int32_t& depthIndex)
-{
- mSortedDepth = depthIndex * DevelLayer::SIBLING_ORDER_MULTIPLIER;
- sceneGraphNodeDepths->Add(const_cast<SceneGraph::Node*>(&GetNode()), mSortedDepth);
-
- // Create/add to children of this node
- if(GetChildCount() > 0)
- {
- for(const auto& child : mParentImpl.GetChildrenInternal())
- {
- Actor* childActor = child.Get();
- ++depthIndex;
- childActor->DepthTraverseActorTree(sceneGraphNodeDepths, depthIndex);
- }
- }
-}
-
void Actor::SetDefaultProperty(Property::Index index, const Property::Value& property)
{
PropertyHandler::SetDefaultProperty(*this, index, property);
}
}
-void Actor::SetParent(ActorParent* parent)
+void Actor::SetParent(ActorParent* parent, bool notify)
{
if(parent)
{
parentActor->OnScene())
{
// Instruct each actor to create a corresponding node in the scene graph
- ConnectToScene(parentActor->GetHierarchyDepth());
+ ConnectToScene(parentActor->GetHierarchyDepth(), notify);
}
// Resolve the name and index for the child properties if any
DisconnectNodeMessage(GetEventThreadServices().GetUpdateManager(), GetNode());
// Instruct each actor to discard pointers to the scene-graph
- DisconnectFromStage();
+ DisconnectFromStage(notify);
}
mScene = nullptr;
return {position.x, position.y, size.x, size.y};
}
+void Actor::SetNeedGesturePropagation(bool propagation)
+{
+ mNeedGesturePropagation = propagation;
+}
+
+bool Actor::NeedGesturePropagation()
+{
+ return mNeedGesturePropagation;
+}
+
bool Actor::GetCachedPropertyValue(Property::Index index, Property::Value& value) const
{
return PropertyHandler::GetCachedPropertyValue(*this, index, value);
float Actor::GetHeightForWidthBase(float width)
{
- float height = 0.0f;
-
const Vector3 naturalSize = GetNaturalSize();
- if(naturalSize.width > 0.0f)
- {
- height = naturalSize.height * width / naturalSize.width;
- }
- else // we treat 0 as 1:1 aspect ratio
- {
- height = width;
- }
-
- return height;
+ return naturalSize.width > 0.0f ? naturalSize.height * width / naturalSize.width : width;
}
float Actor::GetWidthForHeightBase(float height)
{
- float width = 0.0f;
-
const Vector3 naturalSize = GetNaturalSize();
- if(naturalSize.height > 0.0f)
- {
- width = naturalSize.width * height / naturalSize.height;
- }
- else // we treat 0 as 1:1 aspect ratio
- {
- width = height;
- }
-
- return width;
+ return naturalSize.height > 0.0f ? naturalSize.width * height / naturalSize.height : height;
}
float Actor::CalculateChildSizeBase(const Dali::Actor& child, Dimension::Type dimension)
Dali::Actor handle(this);
mOnRelayoutSignal.Emit(handle);
}
+
+ mRelayoutData->relayoutRequested = false;
}
void Actor::NegotiateSize(const Vector2& allocatedSize, RelayoutContainer& container)
{
Dali::Actor self(this);
relayoutController->RequestRelayout(self, dimension);
+
+ if(mRelayoutData)
+ {
+ mRelayoutData->relayoutRequested = true;
+ }
}
}
Vector2 Actor::GetPreferredSize() const
{
- if(mRelayoutData)
- {
- return Vector2(mRelayoutData->preferredSize);
- }
-
- return Relayouter::DEFAULT_PREFERRED_SIZE;
+ return mRelayoutData ? Vector2(mRelayoutData->preferredSize) : Relayouter::DEFAULT_PREFERRED_SIZE;
}
void Actor::SetMinimumSize(float size, Dimension::Type dimension)
float Actor::GetMinimumSize(Dimension::Type dimension) const
{
- if(mRelayoutData)
- {
- return mRelayoutData->GetMinimumSize(dimension);
- }
-
- return 0.0f; // Default
+ return mRelayoutData ? mRelayoutData->GetMinimumSize(dimension) : 0.0f;
}
void Actor::SetMaximumSize(float size, Dimension::Type dimension)
float Actor::GetMaximumSize(Dimension::Type dimension) const
{
- if(mRelayoutData)
- {
- return mRelayoutData->GetMaximumSize(dimension);
- }
-
- return FLT_MAX; // Default
+ return mRelayoutData ? mRelayoutData->GetMaximumSize(dimension) : FLT_MAX;
}
void Actor::SetVisibleInternal(bool visible, SendMessage::Type sendMessage)
mVisible = visible;
// Emit the signal on this actor and all its children
- EmitVisibilityChangedSignalRecursively(visible, DevelActor::VisibilityChange::SELF);
+ mParentImpl.EmitVisibilityChangedSignalRecursively(visible, DevelActor::VisibilityChange::SELF);
}
}
if(inherit && mParent)
{
- InheritLayoutDirectionRecursively(GetParent()->mLayoutDirection);
- }
- }
-}
-
-void Actor::InheritLayoutDirectionRecursively(Dali::LayoutDirection::Type direction, bool set)
-{
- if(mInheritLayoutDirection || set)
- {
- if(mLayoutDirection != direction)
- {
- mLayoutDirection = direction;
- EmitLayoutDirectionChangedSignal(direction);
- RelayoutRequest();
- }
-
- if(GetChildCount() > 0)
- {
- for(const auto& child : mParentImpl.GetChildrenInternal())
- {
- child->InheritLayoutDirectionRecursively(direction);
- }
+ mParentImpl.InheritLayoutDirectionRecursively(GetParent()->mLayoutDirection);
}
}
}
SceneGraph::NodePropertyMessage<Vector3>::Send(GetEventThreadServices(), &GetNode(), &GetNode().mUpdateSizeHint, &AnimatableProperty<Vector3>::Bake, Vector3(updateSizeHint.width, updateSizeHint.height, 0.f));
}
-void Actor::EmitVisibilityChangedSignalRecursively(bool visible,
- DevelActor::VisibilityChange::Type type)
-{
- EmitVisibilityChangedSignal(visible, type);
-
- if(GetChildCount() > 0)
- {
- for(auto& child : mParentImpl.GetChildrenInternal())
- {
- child->EmitVisibilityChangedSignalRecursively(visible, DevelActor::VisibilityChange::PARENT);
- }
- }
-}
-
} // namespace Internal
} // namespace Dali