application.Render(10);
HitTestAlgorithm::Results results;
- HitTest(stage, Vector2( 240.0f, 400.0f ), results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == blue );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 5.0f/6.0f, TEST_LOCATION );
+ HitTest(stage, stageSize / 2.0f, results, &DefaultIsActorTouchableFunction);
+ DALI_TEST_CHECK( results.actor == green );
+ DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 1.0f/6.0f, TEST_LOCATION );
HitTest(stage, stageSize / 3.0f, results, &DefaultIsActorTouchableFunction);
DALI_TEST_CHECK( results.actor == blue );
END_TEST;
}
-int UtcDaliActorInsert(void)
-{
- tet_infoline("Testing Actor::Insert");
- TestApplication application;
-
- Actor parent = Actor::New();
- Stage::GetCurrent().Add( parent );
- Actor first = Actor::New();
- Actor second = Actor::New();
- Actor third = Actor::New();
-
- parent.Insert(1, first); // test insert beyond range
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
- parent.Insert(0, second);
- DALI_TEST_EQUALS( parent.GetChildCount(), 2u, TEST_LOCATION );
- parent.Insert(1, third);
-
- DALI_TEST_EQUALS( parent.GetChildCount(), 3u, TEST_LOCATION );
-
- DALI_TEST_CHECK(parent.GetChildAt(0) == second);
- DALI_TEST_CHECK(parent.GetChildAt(1) == third);
- DALI_TEST_CHECK(parent.GetChildAt(2) == first);
-
- END_TEST;
-}
-
-
int UtcDaliActorRemoveN(void)
{
tet_infoline("Testing Actor::Remove");
$(platform_abstraction_src_dir)/debug.cpp \
$(platform_abstraction_src_dir)/profiling.cpp \
$(platform_abstraction_src_dir)/input-options.cpp \
- $(platform_abstraction_src_dir)/shader-data.cpp \
$(platform_abstraction_src_dir)/system-overlay.cpp \
$(platform_abstraction_src_dir)/lockless-buffer.cpp \
$(platform_abstraction_src_dir)/events/event.cpp \
$(platform_abstraction_src_dir)/gesture-manager.h \
$(platform_abstraction_src_dir)/render-controller.h \
$(platform_abstraction_src_dir)/platform-abstraction.h \
- $(platform_abstraction_src_dir)/shader-data.h \
$(platform_abstraction_src_dir)/system-overlay.h \
$(platform_abstraction_src_dir)/lockless-buffer.h
+++ /dev/null
-/*
- * Copyright (c) 2015 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include <dali/integration-api/shader-data.h>
-
-namespace Dali
-{
-
-namespace Integration
-{
-
-const size_t ShaderData::UNINITIALISED_HASH_VALUE = size_t(0) - 1;
-
-}
-}
-#ifndef __DALI_INTEGRATION_SHADER_DATA_H__
-#define __DALI_INTEGRATION_SHADER_DATA_H__
+#ifndef __DALI_INTERNAL_SHADER_DATA_H__
+#define __DALI_INTERNAL_SHADER_DATA_H__
/*
* Copyright (c) 2015 Samsung Electronics Co., Ltd.
// INTERNAL INCLUDES
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/common/dali-vector.h>
-#include <dali/integration-api/resource-declarations.h>
namespace Dali
{
-namespace Integration
+namespace Internal
{
class ShaderData;
-
typedef IntrusivePtr<ShaderData> ShaderDataPtr;
/**
{
public:
- static const size_t UNINITIALISED_HASH_VALUE;
-
/**
* Constructor
* @param[in] vertexSource Source code for vertex program
* @param[in] fragmentSource Source code for fragment program
*/
ShaderData(const std::string& vertexSource, const std::string& fragmentSource)
- : mShaderHash( UNINITIALISED_HASH_VALUE ),
+ : mShaderHash( -1 ),
mVertexShader(vertexSource),
mFragmentShader(fragmentSource)
{ }
*/
void SetHashValue(size_t shaderHash)
{
- DALI_ASSERT_DEBUG( shaderHash != 0 );
+ DALI_ASSERT_DEBUG( shaderHash != size_t(-1) );
mShaderHash = shaderHash;
}
*/
size_t GetHashValue() const
{
- DALI_ASSERT_DEBUG( mShaderHash != UNINITIALISED_HASH_VALUE );
+ DALI_ASSERT_DEBUG( mShaderHash != size_t(-1) );
return mShaderHash;
}
} // namespace Dali
-#endif // __DALI_INTEGRATION_SHADER_DATA_H__
+#endif // __DALI_INTERNAL_SHADER_DATA_H__
namespace Dali
{
-namespace Integration
+namespace Internal
{
class ShaderData;
typedef IntrusivePtr<ShaderData> ShaderDataPtr;
-}
-
-namespace Internal
-{
/**
* Abstract interface for passing a ShaderData object towards being saved.
* A function saving the binary from a ShaderDataPtr or passing it on to where it can be saved.
* @param[in] shaderData A smart pointer to a ShaderData for which the program binary should be saved.
*/
- virtual void SaveBinary( Integration::ShaderDataPtr shaderData ) = 0;
+ virtual void SaveBinary( Internal::ShaderDataPtr shaderData ) = 0;
protected:
/**
}
}
-void Actor::Insert( unsigned int index, Actor& child )
-{
- DALI_ASSERT_ALWAYS( this != &child && "Cannot add actor to itself" );
- DALI_ASSERT_ALWAYS( !child.IsRoot() && "Cannot add root actor" );
-
- if( !mChildren )
- {
- mChildren = new ActorContainer;
- }
-
- Actor* const oldParent( child.mParent );
-
- // since an explicit position has been given, always insert, even if already a child
- if( oldParent )
- {
- oldParent->Remove( child ); // This causes OnChildRemove callback
-
- // Old parent may need to readjust to missing child
- if( oldParent->RelayoutDependentOnChildren() )
- {
- oldParent->RelayoutRequest();
- }
- }
-
- // Guard against Add() during previous OnChildRemove callback
- if( !child.mParent )
- {
- // Do this first, since user callbacks from within SetParent() may need to remove child
- if( index < GetChildCount() )
- {
- ActorIter it = mChildren->begin();
- std::advance( it, index );
- mChildren->insert( it, ActorPtr( &child ) );
- }
- else
- {
- mChildren->push_back( ActorPtr( &child ) );
- }
- // SetParent asserts that child can be added
- child.SetParent( this, index );
-
- // Notification for derived classes
- OnChildAdd( child );
-
- // Only put in a relayout request if there is a suitable dependency
- if( RelayoutDependentOnChildren() )
- {
- RelayoutRequest();
- }
-
- if( child.RelayoutDependentOnParent() )
- {
- child.RelayoutRequest();
- }
- }
-}
-
void Actor::Remove( Actor& child )
{
if( (this == &child) || (!mChildren) )
void Add( Actor& child );
/**
- * Inserts a child Actor to this Actor's child list
- * @pre The child actor is not the same as the parent actor.
- * @pre The child actor does not already have a parent.
- * @param [in] index in childlist to insert child at
- * @param [in] child The child.
- * @post The child will be referenced by its parent.
- */
- void Insert( unsigned int index, Actor& child );
-
- /**
* Removes a child Actor from this Actor.
* @param [in] child The child.
* @post The child will be unreferenced.
mLayerList(NULL),
mClippingBox(0,0,0,0),
mSortFunction(Layer::ZValue),
+ mBehavior(Dali::Layer::LAYER_2D),
mIsClipping(false),
mDepthTestDisabled(false),
mTouchConsumed(false),
ShaderFactory& shaderFactory = tls.GetShaderFactory();
size_t shaderHash;
- Integration::ShaderDataPtr shaderData = shaderFactory.Load( vertexSource, fragmentSource, shaderHash );
+ Internal::ShaderDataPtr shaderData = shaderFactory.Load( vertexSource, fragmentSource, shaderHash );
DALI_ASSERT_DEBUG( shaderHash != 0U );
// Add shader program to scene-object using a message to the UpdateManager
- SetShaderProgramMessage( mEventThreadServices.GetUpdateManager(), *mSceneObject, shaderData, false );
+ SetShaderProgramMessage( mEventThreadServices.GetUpdateManager(), *mSceneObject, shaderData, modifiesGeometry );
}
void ShaderEffect::Connect()
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
#include <dali/integration-api/debug.h>
#include <dali/integration-api/platform-abstraction.h>
#include <dali/internal/event/common/thread-local-storage.h>
-#include <dali/internal/event/resources/resource-client.h>
#include <dali/internal/event/effects/shader-effect-impl.h>
#include <dali/internal/event/effects/shader-declarations.h>
const char* SHADER_SUFFIX = ".dali-bin";
}
-// Use pre-compiler constants in order to utilize string concatenation
-#define SHADER_DEF_USE_BONES "#define USE_BONES\n"
-#define SHADER_DEF_USE_COLOR "#define USE_COLOR\n"
-#define SHADER_DEF_USE_GRADIENT "#define USE_GRADIENT\n"
-
-using namespace Dali::Integration;
-
namespace Dali
{
return shaderData;
}
-void ShaderFactory::SaveBinary( Integration::ShaderDataPtr shaderData )
+void ShaderFactory::SaveBinary( Internal::ShaderDataPtr shaderData )
{
// Save the binary to the file system:
std::string binaryShaderFilename;
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-vector.h>
-#include <dali/internal/event/resources/resource-ticket.h>
#include <dali/internal/event/effects/shader-declarations.h>
#include <dali/internal/common/message.h>
#include <dali/internal/common/shader-saver.h>
namespace Dali
{
-namespace Integration
-{
-
-class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
-
-}
namespace Internal
{
-class ResourceClient;
-class MessageController;
+class ShaderData;
+typedef IntrusivePtr<ShaderData> ShaderDataPtr;
/**
* ShaderFactory is an object which manages shader binary resource load requests,
* a compiled shader program binary if one could be found, else an
* empty binary buffer cleared to size zero.
*/
- Integration::ShaderDataPtr Load( const std::string& vertexSource, const std::string& fragmentSource, size_t& shaderHash );
+ Internal::ShaderDataPtr Load( const std::string& vertexSource, const std::string& fragmentSource, size_t& shaderHash );
/**
* @brief Saves shader to memory cache and filesystem.
* @param[in] shader The data to be saved.
* @sa Load
*/
- virtual void SaveBinary( Integration::ShaderDataPtr shader );
+ virtual void SaveBinary( Internal::ShaderDataPtr shader );
/**
* Called during Core initialization to load the default shader.
private:
- void MemoryCacheInsert( Integration::ShaderData& shaderData );
+ void MemoryCacheInsert( Internal::ShaderData& shaderData );
// Undefined
ShaderFactory( const ShaderFactory& );
private:
ShaderEffectPtr mDefaultShader;
- Dali::Vector< Integration::ShaderData* > mShaderBinaryCache; ///< Cache of pre-compiled shaders.
+ Dali::Vector< Internal::ShaderData* > mShaderBinaryCache; ///< Cache of pre-compiled shaders.
}; // class ShaderFactory
-inline MessageBase* ShaderCompiledMessage( ShaderSaver& factory, Integration::ShaderDataPtr shaderData )
+inline MessageBase* ShaderCompiledMessage( ShaderSaver& factory, Internal::ShaderDataPtr shaderData )
{
- return new MessageValue1< ShaderSaver, Integration::ShaderDataPtr >( &factory,
+ return new MessageValue1< ShaderSaver, Internal::ShaderDataPtr >( &factory,
&ShaderSaver::SaveBinary,
shaderData );
}
hit.x = hitPointLocal.x;
hit.y = hitPointLocal.y;
hit.distance = distance;
+ hit.depth = actor.GetHierarchyDepth() * Dali::Layer::TREE_DEPTH_MULTIPLIER;
// Is this actor an Image Actor or contains a renderer?
if ( ImageActor* imageActor = dynamic_cast< ImageActor* >( &actor ) )
{
- hit.depth = imageActor->GetDepthIndex();
+ hit.depth += imageActor->GetDepthIndex();
}
- else
+ else if ( actor.GetRendererCount() )
{
- if ( actor.GetRendererCount() )
- {
- hit.depth = actor.GetHierarchyDepth() * Dali::Layer::TREE_DEPTH_MULTIPLIER + actor.GetRendererAt( 0 ).GetDepthIndex();
- }
- else
- {
- hit.depth = 0;
- }
+ hit.depth += actor.GetRendererAt( 0 ).GetDepthIndex();
}
}
}
layerIs3d) );
bool updateChildHit = false;
- // If our ray casting hit, then check then if the hit actor's depth is greater that the favorite, it will be preferred
if ( currentHit.distance >= 0.0f )
{
- if ( currentHit.depth > childHit.depth )
+ if( layerIs3d )
{
- updateChildHit = true;
+ updateChildHit = ( ( currentHit.depth > childHit.depth ) ||
+ ( ( currentHit.depth == childHit.depth ) && ( currentHit.distance < childHit.distance ) ) );
}
-
- // In a 3D layer, if the hit actor's depth is equal to current favorite, then we check the distance and prefer the closer
- else if ( layerIs3d && currentHit.depth == childHit.depth )
+ else
{
- if ( currentHit.distance < childHit.distance )
- {
- updateChildHit = true;
- }
+ updateChildHit = currentHit.depth >= childHit.depth;
}
}
ThreadLocalStorage& tls = ThreadLocalStorage::Get();
ShaderFactory& shaderFactory = tls.GetShaderFactory();
size_t shaderHash;
- Integration::ShaderDataPtr shaderData = shaderFactory.Load( vertexSource, fragmentSource, shaderHash );
+ Internal::ShaderDataPtr shaderData = shaderFactory.Load( vertexSource, fragmentSource, shaderHash );
// Add shader program to scene-object using a message to the UpdateManager
- SetShaderProgramMessage( updateManager, *mSceneObject, shaderData, false );
+ SetShaderProgramMessage( updateManager, *mSceneObject, shaderData, (hints & Dali::Shader::HINT_MODIFIES_GEOMETRY) != 0x0 );
eventThreadServices.RegisterObject( this );
}
*/
#include "scene-graph-renderer-debug.h"
-#include <dali/integration-api/shader-data.h>
+#include <dali/internal/common/shader-data.h>
#include <dali/integration-api/resource-declarations.h>
#include <dali/internal/render/shaders/program.h>
#include <dali/internal/render/gl-resources/context.h>
#if defined ( DEBUG_ENABLED )
if( gDebugProgram == NULL )
{
- Integration::ShaderDataPtr shaderData( new Integration::ShaderData( DEBUG_DRAW_VERTEX_SHADER, DEBUG_DRAW_FRAGMENT_SHADER ) );
+ Internal::ShaderDataPtr shaderData( new Internal::ShaderData( DEBUG_DRAW_VERTEX_SHADER, DEBUG_DRAW_FRAGMENT_SHADER ) );
gDebugProgram = Program::New( shaderData.Get(), context, true );
}
/**
* @param programData to store/save
*/
- virtual void StoreBinary( Integration::ShaderDataPtr programData ) = 0;
+ virtual void StoreBinary( Internal::ShaderDataPtr programData ) = 0;
private: // not implemented as non-copyable
return mProgramBinaryFormat;
}
-void ProgramController::StoreBinary( Integration::ShaderDataPtr programData )
+void ProgramController::StoreBinary( Internal::ShaderDataPtr programData )
{
DALI_ASSERT_DEBUG( programData->GetBufferSize() > 0 );
- DALI_ASSERT_DEBUG( programData->GetHashValue() != 0 );
DALI_ASSERT_DEBUG( mShaderSaver && "SetShaderSaver() should have been called during startup." );
if( mShaderSaver != NULL )
/**
* @copydoc ProgramCache::StoreBinary
*/
- virtual void StoreBinary( Integration::ShaderDataPtr programData );
+ virtual void StoreBinary( Internal::ShaderDataPtr programData );
private: // not implemented as non-copyable
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/common/constants.h>
#include <dali/integration-api/debug.h>
-#include <dali/integration-api/shader-data.h>
+#include <dali/internal/common/shader-data.h>
#include <dali/integration-api/gl-defines.h>
#include <dali/internal/render/common/performance-monitor.h>
#include <dali/internal/render/shaders/program-cache.h>
// IMPLEMENTATION
-Program* Program::New( ProgramCache& cache, Integration::ShaderDataPtr shaderData, bool modifiesGeometry )
+Program* Program::New( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
{
size_t shaderHash = shaderData->GetHashValue();
Program* program = cache.GetProgram( shaderHash );
return mModifiesGeometry;
}
-Program::Program( ProgramCache& cache, Integration::ShaderDataPtr shaderData, bool modifiesGeometry )
+Program::Program( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
: mCache( cache ),
mGlAbstraction( mCache.GetGlAbstraction() ),
mProjectionMatrix( NULL ),
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/object/ref-object.h>
#include <dali/integration-api/gl-abstraction.h>
-#include <dali/integration-api/shader-data.h>
+#include <dali/internal/common/shader-data.h>
namespace Dali
{
* @param[in] modifiesGeometry True if the shader modifies geometry
* @return pointer to the program
*/
- static Program* New( ProgramCache& cache, Integration::ShaderDataPtr shaderData, bool modifiesGeometry );
+ static Program* New( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool modifiesGeometry );
/**
* Takes this program into use
* @param[in] shaderData A smart pointer to a data structure containing the program source and binary
* @param[in] modifiesGeometry True if the vertex shader changes geometry
*/
- Program( ProgramCache& cache, Integration::ShaderDataPtr shaderData, bool modifiesGeometry );
+ Program( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool modifiesGeometry );
public:
GLuint mVertexShaderId; ///< GL identifier for vertex shader
GLuint mFragmentShaderId; ///< GL identifier for fragment shader
GLuint mProgramId; ///< GL identifier for program
- Integration::ShaderDataPtr mProgramData; ///< Shader program source and binary (when compiled & linked or loaded)
+ Internal::ShaderDataPtr mProgramData; ///< Shader program source and binary (when compiled & linked or loaded)
// location caches
std::vector< std::pair< std::string, GLint > > mAttributeLocations; ///< attribute location cache
mUniformMetadata[ index ]->SetCoordinateType( type );
}
-void Shader::SetProgram( Integration::ShaderDataPtr shaderData,
+void Shader::SetProgram( Internal::ShaderDataPtr shaderData,
ProgramCache* programCache,
bool modifiesGeometry )
{
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-#include <dali/integration-api/shader-data.h>
+#include <dali/internal/common/shader-data.h>
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/common/type-abstraction-enums.h>
* @param[in] modifiesGeometry True if the vertex shader changes the positions of vertexes such that
* they might exceed the bounding box of vertexes passing through the default transformation.
*/
- void SetProgram( Integration::ShaderDataPtr shaderData,
+ void SetProgram( Internal::ShaderDataPtr shaderData,
ProgramCache* programCache,
bool modifiesGeometry );
#include <dali/integration-api/core.h>
#include <dali/integration-api/render-controller.h>
-#include <dali/integration-api/shader-data.h>
+#include <dali/internal/common/shader-data.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/common/core-impl.h>
typedef ShaderContainer::Iterator ShaderIter;
typedef ShaderContainer::ConstIterator ShaderConstIter;
-typedef std::vector<Integration::ShaderDataPtr> ShaderDataBatchedQueue;
+typedef std::vector<Internal::ShaderDataPtr> ShaderDataBatchedQueue;
typedef ShaderDataBatchedQueue::iterator ShaderDataBatchedQueueIterator;
typedef OwnerContainer<PanGesture*> GestureContainer;
}
void UpdateManager::SetShaderProgram( Shader* shader,
- Integration::ShaderDataPtr shaderData, bool modifiesGeometry )
+ Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
{
if( shaderData )
{
- typedef MessageValue3< Shader, Integration::ShaderDataPtr, ProgramCache*, bool> DerivedType;
+ typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
}
}
-void UpdateManager::SaveBinary( Integration::ShaderDataPtr shaderData )
+void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
{
DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." );
DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." );
* @param[in] shaderData Source code, hash over source, and optional compiled binary for the shader program
* @param[in] modifiesGeometry True if the vertex shader modifies geometry
*/
- void SetShaderProgram( Shader* shader, Integration::ShaderDataPtr shaderData, bool modifiesGeometry );
+ void SetShaderProgram( Shader* shader, Internal::ShaderDataPtr shaderData, bool modifiesGeometry );
/**
* @brief Accept compiled shaders passed back on render thread for saving.
* @param[in] shaderData Source code, hash over source, and corresponding compiled binary to be saved.
*/
- virtual void SaveBinary( Integration::ShaderDataPtr shaderData );
+ virtual void SaveBinary( Internal::ShaderDataPtr shaderData );
/**
* @brief Set the destination for compiled shader binaries to be passed on to.
inline void SetShaderProgramMessage( UpdateManager& manager,
Shader& shader,
- Integration::ShaderDataPtr shaderData,
+ Internal::ShaderDataPtr shaderData,
bool modifiesGeometry )
{
- typedef MessageValue3< UpdateManager, Shader*, Integration::ShaderDataPtr, bool > LocalType;
+ typedef MessageValue3< UpdateManager, Shader*, Internal::ShaderDataPtr, bool > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
GetImplementation(*this).Add(GetImplementation(actor));
}
-void Actor::Insert(unsigned int index, Actor actor)
-{
- GetImplementation(*this).Insert(index, GetImplementation(actor));
-}
-
void Actor::Remove(Actor actor)
{
GetImplementation(*this).Remove(GetImplementation(actor));
void Add(Actor child);
/**
- * @brief Inserts a child Actor to this actor's list of children at the given index
- *
- * NOTE! if the child already has a parent, it will be removed from old parent
- * and reparented to this actor. This may change childs position, color,
- * scale etc as it now inherits them from this actor
- * @pre This Actor (the parent) has been initialized.
- * @pre The child actor has been initialized.
- * @pre The child actor is not the same as the parent actor.
- * @pre The actor is not the Root actor
- * @param [in] index of actor to insert before
- * @param [in] child The child.
- * @post The child will be referenced by its parent. This means that the child will be kept alive,
- * even if the handle passed into this method is reset or destroyed.
- * @post If the index is greater than the current child count, it will be ignored and added at the end.
- */
- void Insert(unsigned int index, Actor child);
-
- /**
* @brief Removes a child Actor from this Actor.
*
* If the actor was not a child of this actor, this is a no-op.
const unsigned int CORE_MAJOR_VERSION = 1;
const unsigned int CORE_MINOR_VERSION = 0;
-const unsigned int CORE_MICRO_VERSION = 48;
+const unsigned int CORE_MICRO_VERSION = 49;
const char * const CORE_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali
Summary: The OpenGLES Canvas Core Library
-Version: 1.0.48
+Version: 1.0.49
Release: 1
Group: System/Libraries
License: Apache-2.0
projects / platform / core / uifw / dali-core.git / commitdiff