From 3c9803cd084251fcfec3482969fcd24f33d99647 Mon Sep 17 00:00:00 2001 From: "jk7744.park" Date: Fri, 4 Mar 2016 19:50:15 +0900 Subject: [PATCH] Tizen 2.4.0 rev3 SDK Public Release --- build/scripts/dali_env | 2 - dali/integration-api/platform-abstraction.h | 25 +-- dali/internal/common/core-impl.cpp | 1 - .../event/events/long-press-gesture-processor.cpp | 19 +- .../event/events/pan-gesture-processor.cpp | 19 +- .../event/events/tap-gesture-processor.cpp | 19 +- dali/internal/render/common/render-manager.cpp | 25 +++ dali/internal/render/common/render-manager.h | 17 ++ .../render/data-providers/render-data-provider.cpp | 12 +- .../render/data-providers/render-data-provider.h | 14 ++ dali/internal/render/renderers/render-renderer.cpp | 8 +- dali/internal/render/renderers/render-renderer.h | 2 + .../renderers/scene-graph-image-renderer.cpp | 71 ++++++ .../render/renderers/scene-graph-image-renderer.h | 31 +++ .../render/renderers/scene-graph-renderer.cpp | 54 +---- .../render/renderers/scene-graph-renderer.h | 30 +-- .../controllers/render-message-dispatcher.cpp | 22 ++ .../update/controllers/render-message-dispatcher.h | 14 ++ .../update/controllers/scene-controller-impl.cpp | 31 +++ .../update/controllers/scene-controller-impl.h | 12 ++ .../internal/update/controllers/scene-controller.h | 15 ++ .../update/gestures/scene-graph-pan-gesture.cpp | 7 +- .../update/manager/prepare-render-algorithms.cpp | 2 +- .../scene-graph-image-attachment.cpp | 74 ++++--- .../scene-graph-image-attachment.h | 8 + .../scene-graph-renderable-attachment.cpp | 25 --- .../scene-graph-renderable-attachment.h | 12 +- .../scene-graph-renderer-attachment.cpp | 9 + .../scene-graph-renderer-attachment.h | 2 +- dali/public-api/actors/actor-enumerations.h | 64 +++--- dali/public-api/actors/actor.h | 214 +++++++++--------- dali/public-api/actors/blending.h | 63 +++--- dali/public-api/actors/camera-actor.h | 68 +++--- dali/public-api/actors/custom-actor-impl.h | 62 +++--- dali/public-api/actors/custom-actor.h | 9 +- dali/public-api/actors/draw-mode.h | 12 +- dali/public-api/actors/image-actor.h | 238 ++++++++++----------- dali/public-api/actors/layer.h | 131 ++++++++---- dali/public-api/actors/sampling.h | 15 +- dali/public-api/animation/alpha-function.h | 39 ++-- dali/public-api/animation/animation.h | 85 ++++---- dali/public-api/animation/constraint-source.h | 6 +- dali/public-api/animation/constraint.h | 22 +- dali/public-api/animation/constraints.h | 51 +++-- dali/public-api/animation/key-frames.h | 16 +- dali/public-api/animation/linear-constrainer.h | 23 +- dali/public-api/animation/path.h | 20 +- dali/public-api/common/compile-time-assert.h | 6 +- dali/public-api/common/dali-common.h | 4 +- dali/public-api/common/dali-vector.h | 90 ++++---- dali/public-api/common/intrusive-ptr.h | 62 +++--- dali/public-api/common/loading-state.h | 6 +- dali/public-api/common/stage.h | 40 ++-- dali/public-api/common/type-traits.h | 25 ++- dali/public-api/common/view-mode.h | 8 +- dali/public-api/events/gesture-detector.h | 14 +- dali/public-api/events/gesture.h | 23 +- dali/public-api/events/key-event.h | 12 +- .../events/long-press-gesture-detector.h | 16 +- dali/public-api/events/long-press-gesture.h | 9 +- dali/public-api/events/pan-gesture-detector.h | 36 ++-- dali/public-api/events/pan-gesture.h | 11 +- dali/public-api/events/pinch-gesture-detector.h | 14 +- dali/public-api/events/pinch-gesture.h | 11 +- dali/public-api/events/tap-gesture-detector.h | 22 +- dali/public-api/events/tap-gesture.h | 3 + dali/public-api/events/touch-event.h | 2 +- dali/public-api/events/touch-point.h | 6 +- dali/public-api/events/wheel-event.h | 12 +- dali/public-api/images/buffer-image.h | 104 ++++----- dali/public-api/images/encoded-buffer-image.h | 24 +-- dali/public-api/images/frame-buffer-image.h | 46 ++-- dali/public-api/images/image-operations.h | 89 +++++--- dali/public-api/images/image.h | 40 ++-- dali/public-api/images/native-image-interface.h | 8 +- dali/public-api/images/native-image.h | 3 +- dali/public-api/images/nine-patch-image.h | 28 +-- dali/public-api/images/pixel.h | 75 ++++--- dali/public-api/images/resource-image.h | 40 ++-- dali/public-api/math/compile-time-math.h | 30 +-- dali/public-api/math/degree.h | 2 +- dali/public-api/math/matrix.h | 112 +++++----- dali/public-api/math/matrix3.h | 53 +++-- dali/public-api/math/quaternion.h | 96 ++++----- dali/public-api/math/radian.h | 8 +- dali/public-api/math/random.h | 8 +- dali/public-api/math/uint-16-pair.h | 22 +- dali/public-api/math/vector2.h | 76 +++---- dali/public-api/math/vector3.h | 124 +++++------ dali/public-api/math/vector4.h | 126 ++++++----- dali/public-api/object/base-handle.h | 2 +- dali/public-api/object/handle.h | 6 + dali/public-api/object/object-registry.h | 7 +- dali/public-api/object/property-array.h | 2 +- dali/public-api/object/property-index-ranges.h | 24 +-- dali/public-api/object/property-map.h | 4 +- dali/public-api/object/property-notification.h | 14 +- dali/public-api/object/property.h | 40 ++-- dali/public-api/object/type-info.h | 4 +- dali/public-api/render-tasks/render-task.h | 16 +- dali/public-api/shader-effects/shader-effect.h | 34 +-- dali/public-api/signals/base-signal.h | 4 +- dali/public-api/signals/callback.h | 3 +- .../signals/connection-tracker-interface.h | 4 +- dali/public-api/signals/connection-tracker.h | 4 +- dali/public-api/signals/dali-signal.h | 33 +-- dali/public-api/signals/signal-slot-connections.h | 8 +- dali/public-api/signals/slot-delegate.h | 4 +- doc/dali_doc.h | 71 +++++- 109 files changed, 1987 insertions(+), 1563 deletions(-) diff --git a/build/scripts/dali_env b/build/scripts/dali_env index d0a9416..832d889 100755 --- a/build/scripts/dali_env +++ b/build/scripts/dali_env @@ -37,8 +37,6 @@ my @system_packages = ( "pkg-config", "libtool", "ccache", - "libboost-dev", - "libboost-thread-dev", "libelementary-dev", "libexif-dev", "libgles2-mesa-dev", diff --git a/dali/integration-api/platform-abstraction.h b/dali/integration-api/platform-abstraction.h index 3b3f460..0cb64a1 100644 --- a/dali/integration-api/platform-abstraction.h +++ b/dali/integration-api/platform-abstraction.h @@ -97,7 +97,7 @@ public: bool orientationCorrection = true) = 0; /** - @brief Determine the size of an image the resource loaders will provide when + * @brief Determine the size of an image the resource loaders will provide when * given the same image loading parameters. * * This is a synchronous request. @@ -161,13 +161,6 @@ public: virtual void CancelLoad(ResourceId id, ResourceTypeId typeId) = 0; /** - * Query whether any asynchronous LoadResource() requests are ongoing. - * Multi-threading note: this method may be called from either the main or rendering thread. - * @return True if resources are being loaded. - */ - virtual bool IsLoading() = 0; - - /** * Retrieve newly loaded resources. * If no resources have finished loading, then this method returns immediately. * Multi-threading note: this method will be called from the update thread, from within @@ -196,13 +189,6 @@ public: virtual int GetDefaultFontSize() const = 0; /** - * Sets horizontal and vertical pixels per inch value that is used by the display - * @param[in] dpiHorizontal horizontal dpi value - * @param[in] dpiVertical vertical dpi value - */ - virtual void SetDpi (unsigned int dpiHorizontal, unsigned int dpiVertical) = 0; - - /** * Load a file into a buffer * @param[in] filename The filename to load * @param[out] buffer A buffer to receive the file. @@ -211,15 +197,6 @@ public: virtual bool LoadFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const = 0; /** - * Load a file into a buffer - * @param[in] filename The filename to save - * @param[out] buffer A buffer containing some data - * The buffer is implemeneted with a Dali::Vector. The size() member specifies the buffer length. - * @result true if the file is saved. - */ - virtual bool SaveFile( const std::string& filename, const unsigned char * buffer, unsigned int numBytes ) const = 0; - - /** * Load a shader binary file into a buffer * @param[in] filename The shader binary filename to load * @param[out] buffer A buffer to receive the file. diff --git a/dali/internal/common/core-impl.cpp b/dali/internal/common/core-impl.cpp index 0489dcf..829d2f7 100644 --- a/dali/internal/common/core-impl.cpp +++ b/dali/internal/common/core-impl.cpp @@ -245,7 +245,6 @@ void Core::SurfaceResized( unsigned int width, unsigned int height ) void Core::SetDpi( unsigned int dpiHorizontal, unsigned int dpiVertical ) { - mPlatform.SetDpi( dpiHorizontal, dpiVertical ); mStage->SetDpi( Vector2( dpiHorizontal , dpiVertical) ); } diff --git a/dali/internal/event/events/long-press-gesture-processor.cpp b/dali/internal/event/events/long-press-gesture-processor.cpp index 6fc846a..f5aecee 100644 --- a/dali/internal/event/events/long-press-gesture-processor.cpp +++ b/dali/internal/event/events/long-press-gesture-processor.cpp @@ -270,16 +270,19 @@ void LongPressGestureProcessor::UpdateDetection() { LongPressGestureDetector* current(*iter); - unsigned int minimum = current->GetMinimumTouchesRequired(); - if (minimum < minimumRequired) + if( current ) { - minimumRequired = minimum; - } + unsigned int minimum = current->GetMinimumTouchesRequired(); + if (minimum < minimumRequired) + { + minimumRequired = minimum; + } - unsigned int maximum = current->GetMaximumTouchesRequired(); - if ( maximum > maximumRequired ) - { - maximumRequired = maximum; + unsigned int maximum = current->GetMaximumTouchesRequired(); + if ( maximum > maximumRequired ) + { + maximumRequired = maximum; + } } } diff --git a/dali/internal/event/events/pan-gesture-processor.cpp b/dali/internal/event/events/pan-gesture-processor.cpp index 7f44778..c93071e 100644 --- a/dali/internal/event/events/pan-gesture-processor.cpp +++ b/dali/internal/event/events/pan-gesture-processor.cpp @@ -413,16 +413,19 @@ void PanGestureProcessor::UpdateDetection() { PanGestureDetector* detector(*iter); - unsigned int minimum = detector->GetMinimumTouchesRequired(); - if (minimum < minimumRequired) + if( detector ) { - minimumRequired = minimum; - } + unsigned int minimum = detector->GetMinimumTouchesRequired(); + if (minimum < minimumRequired) + { + minimumRequired = minimum; + } - unsigned int maximum = detector->GetMaximumTouchesRequired(); - if (maximum > maximumRequired) - { - maximumRequired = maximum; + unsigned int maximum = detector->GetMaximumTouchesRequired(); + if (maximum > maximumRequired) + { + maximumRequired = maximum; + } } } diff --git a/dali/internal/event/events/tap-gesture-processor.cpp b/dali/internal/event/events/tap-gesture-processor.cpp index 2814208..4cdb920 100644 --- a/dali/internal/event/events/tap-gesture-processor.cpp +++ b/dali/internal/event/events/tap-gesture-processor.cpp @@ -253,14 +253,17 @@ void TapGestureProcessor::UpdateDetection() { TapGestureDetector* detector(*iter); - const unsigned int minTapsRequired = detector->GetMinimumTapsRequired(); - const unsigned int maxTapsRequired = detector->GetMaximumTapsRequired(); - const unsigned int touchesRequired = detector->GetTouchesRequired(); - - minTaps = minTapsRequired < minTaps ? minTapsRequired : minTaps; - maxTaps = maxTapsRequired > maxTaps ? maxTapsRequired : maxTaps; - minTouches = touchesRequired < minTouches ? touchesRequired : minTouches; - maxTouches = touchesRequired > maxTouches ? touchesRequired : maxTouches; + if( detector ) + { + const unsigned int minTapsRequired = detector->GetMinimumTapsRequired(); + const unsigned int maxTapsRequired = detector->GetMaximumTapsRequired(); + const unsigned int touchesRequired = detector->GetTouchesRequired(); + + minTaps = minTapsRequired < minTaps ? minTapsRequired : minTaps; + maxTaps = maxTapsRequired > maxTaps ? maxTapsRequired : maxTaps; + minTouches = touchesRequired < minTouches ? touchesRequired : minTouches; + maxTouches = touchesRequired > maxTouches ? touchesRequired : maxTouches; + } } if ( (minTaps != mMinTapsRequired)||(maxTaps != mMaxTapsRequired) || diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp index c3d5a41..49d32a1 100644 --- a/dali/internal/render/common/render-manager.cpp +++ b/dali/internal/render/common/render-manager.cpp @@ -35,6 +35,7 @@ #include #include #include +#include #include #include #include @@ -288,6 +289,30 @@ void RenderManager::RemoveRenderer( Renderer* renderer ) } } +void RenderManager::AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider ) +{ + // Initialize the renderer as we are now in render thread + renderer->Initialize( mImpl->context, mImpl->textureCache ); + renderer->SetDataProvider( dataProvider ); + + if( !mImpl->renderersAdded ) + { + mImpl->renderersAdded = true; + } + + // Note - ImageRenderers are not owned by RenderManager +} + +void RenderManager::RemoveImageRenderer( ImageRenderer* renderer ) +{ + DALI_ASSERT_DEBUG( NULL != renderer ); + + // GL cleanup + renderer->OnRemove(); + + // Note - ImageRenderers are not owned by RenderManager +} + void RenderManager::AddGeometry( RenderGeometry* renderGeometry ) { mImpl->renderGeometryContainer.PushBack( renderGeometry ); diff --git a/dali/internal/render/common/render-manager.h b/dali/internal/render/common/render-manager.h index 9a6003e..7185209 100644 --- a/dali/internal/render/common/render-manager.h +++ b/dali/internal/render/common/render-manager.h @@ -46,6 +46,8 @@ class ShaderSaver; namespace SceneGraph { class Renderer; +class ImageRenderer; +class NodeDataProvider; class RenderQueue; class TextureCache; class RenderInstruction; @@ -153,6 +155,21 @@ public: void RemoveRenderer( Renderer* renderer ); /** + * Add an image renderer in the render-thread. + * ImageRenderers are not owned by render-manager; this is just for initialization. + * @param[in] renderer The renderer to add. + * @param[in] dataProvider The Node using this image renderer. + */ + void AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider ); + + /** + * Remove an image renderer in the render-thread. + * ImageRenderers are not owned by render-manager; this is just for GL cleanup. + * @param[in] renderer The renderer to remove. + */ + void RemoveImageRenderer( ImageRenderer* renderer ); + + /** * Add a geometry to the render manager. * @param[in] geometry The geometry to add. * @post geometry is owned by RenderManager diff --git a/dali/internal/render/data-providers/render-data-provider.cpp b/dali/internal/render/data-providers/render-data-provider.cpp index f78af39..d4b031b 100644 --- a/dali/internal/render/data-providers/render-data-provider.cpp +++ b/dali/internal/render/data-providers/render-data-provider.cpp @@ -27,7 +27,8 @@ namespace SceneGraph RenderDataProvider::RenderDataProvider() : mMaterialDataProvider( NULL ), mUniformMapDataProvider( NULL ), - mShader( NULL ) + mShader( NULL ), + mUseBlend( false ) { } @@ -75,6 +76,15 @@ const RenderDataProvider::Samplers& RenderDataProvider::GetSamplers() const return mSamplers; } +void RenderDataProvider::SetUseBlend( bool useBlend ) +{ + mUseBlend = useBlend; +} + +bool RenderDataProvider::GetUseBlend( BufferIndex bufferIndex ) const +{ + return mUseBlend; +} } // SceneGraph } // Internal diff --git a/dali/internal/render/data-providers/render-data-provider.h b/dali/internal/render/data-providers/render-data-provider.h index cf3aeb6..fc15eb8 100644 --- a/dali/internal/render/data-providers/render-data-provider.h +++ b/dali/internal/render/data-providers/render-data-provider.h @@ -110,11 +110,25 @@ public: */ const Samplers& GetSamplers() const; + /** + * Set the use blend flag to decide if the renderer will perform blending + * @param[in] useBlend The flag to decide if the renderer will perform blending + */ + void SetUseBlend( bool useBlend ); + + /** + * Get the use blend flag that decides if the renderer will perform blending + * @param[in] buffer index + * @return The use blend flag that decides if the renderer will perform blending + */ + bool GetUseBlend( BufferIndex bufferIndex ) const; + private: const MaterialDataProvider* mMaterialDataProvider; const UniformMapDataProvider* mUniformMapDataProvider; Shader* mShader; Samplers mSamplers; + bool mUseBlend; // Give RendererAttachment access to our private data to reduce copying vectors on construction. friend class RendererAttachment; diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp index 5783f3e..b98aa4c 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -100,9 +100,9 @@ void NewRenderer::DoSetCullFaceMode( Context& context, BufferIndex bufferIndex ) void NewRenderer::DoSetBlending( Context& context, BufferIndex bufferIndex ) { - context.SetBlend(mUseBlend); // @todo MESH_REWORK Should use a RendererDataProvider - - if( mUseBlend ) + bool blend = mRenderDataProvider->GetUseBlend( bufferIndex ); + context.SetBlend( blend ); + if( blend ) { const MaterialDataProvider& material = mRenderDataProvider->GetMaterial(); @@ -181,7 +181,7 @@ void NewRenderer::SetUniforms( BufferIndex bufferIndex, Program& program ) GLint sizeLoc = program.GetUniformLocation( Program::UNIFORM_SIZE ); if( -1 != sizeLoc ) { - Vector3 size = mDataProvider.GetRenderSize( bufferIndex ); + Vector3 size = mDataProvider->GetRenderSize( bufferIndex ); program.SetUniform3f( sizeLoc, size.x, size.y, size.z ); } } diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h index 4756ea0..2a3ee8c 100644 --- a/dali/internal/render/renderers/render-renderer.h +++ b/dali/internal/render/renderers/render-renderer.h @@ -220,6 +220,8 @@ private: Vector mAttributesLocation; bool mUpdateAttributesLocation; + + bool mUseBlend:1; ///< True if blending should be enabled, 1 bit is enough }; diff --git a/dali/internal/render/renderers/scene-graph-image-renderer.cpp b/dali/internal/render/renderers/scene-graph-image-renderer.cpp index 8d31438..af670d2 100644 --- a/dali/internal/render/renderers/scene-graph-image-renderer.cpp +++ b/dali/internal/render/renderers/scene-graph-image-renderer.cpp @@ -121,12 +121,34 @@ ImageRenderer* ImageRenderer::New( NodeDataProvider& dataProvider ) ImageRenderer::~ImageRenderer() { + // Note - GL cleanup is done from render-thread in OnRemove() +} + +void ImageRenderer::OnRemove() +{ if ( mTextureId > 0 ) { mTextureCacheDELETEME->RemoveObserver(mTextureId, this); } GlCleanup(); + + // Set back to defaults + mDataProvider = NULL; + mShader = NULL; + mTexture = NULL; + mBorder = Vector4( 0.45, 0.45, 0.1, 0.1 ); + mPixelArea = PixelArea(); + mGeometrySize = Vector2(); + mTextureId = 0; + mBlendingOptions.SetBlendFunc( DEFAULT_BLENDING_SRC_FACTOR_RGB, DEFAULT_BLENDING_DEST_FACTOR_RGB, DEFAULT_BLENDING_SRC_FACTOR_ALPHA, DEFAULT_BLENDING_DEST_FACTOR_ALPHA ); + mBlendingOptions.SetBlendEquation( DEFAULT_BLENDING_EQUATION_RGB, DEFAULT_BLENDING_EQUATION_ALPHA ); + mBlendingOptions.SetBlendColor( Vector4::ZERO ); + mMeshType = ImageRenderer::QUAD; + mIsMeshGenerated = false; + mBorderInPixels = false; + mUseBlend = false; + mUsePixelArea = false; } void ImageRenderer::SetTextureId( ResourceId textureId ) @@ -159,6 +181,21 @@ void ImageRenderer::SetNinePatchBorder( const Vector4& border, bool inPixels ) mIsMeshGenerated = false; } +void ImageRenderer::SetUseBlend( bool useBlend ) +{ + mUseBlend = useBlend; +} + +void ImageRenderer::SetBlendingOptions( unsigned int options ) +{ + mBlendingOptions.SetBitmask( options ); +} + +void ImageRenderer::SetBlendColor( const Vector4& color ) +{ + mBlendingOptions.SetBlendColor( color ); +} + void ImageRenderer::CalculateMeshData( MeshType type, const Vector2& targetSize, bool usePixelArea ) { mMeshType = type; @@ -204,6 +241,11 @@ bool ImageRenderer::RequiresDepthTest() const bool ImageRenderer::CheckResources() { + if( mDataProvider == NULL ) + { + return false; + } + if( mTexture == NULL ) { if ( mTextureCacheDELETEME ) @@ -354,6 +396,34 @@ void ImageRenderer::DoRender( Context& context, TextureCache& textureCache, Buff } } +void ImageRenderer::DoSetBlending(Context& context, BufferIndex bufferIndex ) +{ + // Enables/disables blending mode. + context.SetBlend( mUseBlend ); + + // Set the blend color + const Vector4* const customColor = mBlendingOptions.GetBlendColor(); + if( customColor ) + { + context.SetCustomBlendColor( *customColor ); + } + else + { + context.SetDefaultBlendColor(); + } + + // Set blend source & destination factors + context.BlendFuncSeparate( mBlendingOptions.GetBlendSrcFactorRgb(), + mBlendingOptions.GetBlendDestFactorRgb(), + mBlendingOptions.GetBlendSrcFactorAlpha(), + mBlendingOptions.GetBlendDestFactorAlpha() ); + + // Set blend equations + context.BlendEquationSeparate( mBlendingOptions.GetBlendEquationRgb(), + mBlendingOptions.GetBlendEquationAlpha() ); + +} + void ImageRenderer::UpdateVertexBuffer( Context& context, GLsizeiptr size, const GLvoid *data ) { // create/destroy if needed/not needed. @@ -930,6 +1000,7 @@ ImageRenderer::ImageRenderer( NodeDataProvider& dataProvider ) mMeshType( ImageRenderer::QUAD ), mIsMeshGenerated( false ), mBorderInPixels( false ), + mUseBlend( false ), mUsePixelArea( false ) { } diff --git a/dali/internal/render/renderers/scene-graph-image-renderer.h b/dali/internal/render/renderers/scene-graph-image-renderer.h index 226501b..54da3dc 100644 --- a/dali/internal/render/renderers/scene-graph-image-renderer.h +++ b/dali/internal/render/renderers/scene-graph-image-renderer.h @@ -69,6 +69,11 @@ public: virtual ~ImageRenderer(); /** + * Called in the render-thread when the renderer is removed + */ + void OnRemove(); + + /** * Set the texture used to render. * @param[in] textureId The id of the texture used to render. */ @@ -88,6 +93,24 @@ public: void SetNinePatchBorder( const Vector4& border, bool inPixels ); /** + * Set whether the ImageRenderer should use blending + * @param[in] useBlend True if blending should be used. + */ + void SetUseBlend( bool useBlend ); + + /** + * Set the blending options. + * @param[in] options A bitmask of blending options. + */ + void SetBlendingOptions( unsigned int options ); + + /** + * Set the blend color. + * @param[in] color The new blend-color. + */ + void SetBlendColor( const Vector4& color ); + + /** * Calculate the mesh data used by the ImageRenderer. * @param[in] type The type of mesh data required; either quad, nine-patch or grid. * @param[in] targetSize The size which the mesh data should fit inside. @@ -125,6 +148,11 @@ public: */ virtual void DoRender( Context& context, TextureCache& textureCache, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix ); + /** + * @copydoc Dali::Internal::SceneGraph::Renderer::DoSetBlending() + */ + virtual void DoSetBlending( Context& context, BufferIndex bufferIndex ); + protected: // TextureObserver implementation /** @@ -214,10 +242,13 @@ private: Vector2 mGeometrySize; ResourceId mTextureId; + BlendingOptions mBlendingOptions; + // flags MeshType mMeshType : 3; // 4 values fits in 3 bits just fine bool mIsMeshGenerated : 1; bool mBorderInPixels : 1; + bool mUseBlend : 1; ///< True if blending should be enabled, 1 bit is enough bool mUsePixelArea : 1; }; diff --git a/dali/internal/render/renderers/scene-graph-renderer.cpp b/dali/internal/render/renderers/scene-graph-renderer.cpp index e612695..cfcc08a 100644 --- a/dali/internal/render/renderers/scene-graph-renderer.cpp +++ b/dali/internal/render/renderers/scene-graph-renderer.cpp @@ -118,24 +118,14 @@ Renderer::~Renderer() { } -void Renderer::SetShader( Shader* shader ) -{ - mShader = shader; -} - -void Renderer::SetUseBlend( bool useBlend ) +void Renderer::SetDataProvider( NodeDataProvider* dataProvider ) { - mUseBlend = useBlend; + mDataProvider = dataProvider; } -void Renderer::SetBlendingOptions( unsigned int options ) -{ - mBlendingOptions.SetBitmask( options ); -} - -void Renderer::SetBlendColor( const Vector4& color ) +void Renderer::SetShader( Shader* shader ) { - mBlendingOptions.SetBlendColor( color ); + mShader = shader; } void Renderer::SetCullFace( CullFaceMode mode ) @@ -181,7 +171,7 @@ void Renderer::Render( Context& context, } // Calculate the MVP matrix first so we can do the culling test - const Matrix& modelMatrix = mDataProvider.GetModelMatrix( bufferIndex ); + const Matrix& modelMatrix = mDataProvider->GetModelMatrix( bufferIndex ); Matrix::Multiply( gModelViewProjectionMatrix, modelViewMatrix, projectionMatrix ); // Get the program to use: @@ -224,7 +214,7 @@ void Renderer::Render( Context& context, GLint loc = program->GetUniformLocation( Program::UNIFORM_COLOR ); if( Program::UNIFORM_UNKNOWN != loc ) { - const Vector4& color = mDataProvider.GetRenderColor( bufferIndex ); + const Vector4& color = mDataProvider->GetRenderColor( bufferIndex ); program->SetUniform4f( loc, color.r, color.g, color.b, color.a ); } loc = program->GetUniformLocation(Program::UNIFORM_TIME_DELTA); @@ -253,42 +243,12 @@ void Renderer::DoSetCullFaceMode(Context& context, BufferIndex bufferIndex ) context.CullFace( mCullFaceMode ); } -// can be overridden by deriving class -void Renderer::DoSetBlending(Context& context, BufferIndex bufferIndex ) -{ - // Enables/disables blending mode. - context.SetBlend( mUseBlend ); - - // Set the blend color - const Vector4* const customColor = mBlendingOptions.GetBlendColor(); - if( customColor ) - { - context.SetCustomBlendColor( *customColor ); - } - else - { - context.SetDefaultBlendColor(); - } - - // Set blend source & destination factors - context.BlendFuncSeparate( mBlendingOptions.GetBlendSrcFactorRgb(), - mBlendingOptions.GetBlendDestFactorRgb(), - mBlendingOptions.GetBlendSrcFactorAlpha(), - mBlendingOptions.GetBlendDestFactorAlpha() ); - - // Set blend equations - context.BlendEquationSeparate( mBlendingOptions.GetBlendEquationRgb(), - mBlendingOptions.GetBlendEquationAlpha() ); - -} - Renderer::Renderer( NodeDataProvider& dataprovider ) -: mDataProvider( dataprovider ), +: mDataProvider( &dataprovider ), mContextDELETEME(NULL), mTextureCacheDELETEME( NULL ), mShader( NULL ), mSamplerBitfield( ImageSampler::PackBitfield( FilterMode::DEFAULT, FilterMode::DEFAULT ) ), - mUseBlend( false ), mCullFaceMode( CullNone ) { } diff --git a/dali/internal/render/renderers/scene-graph-renderer.h b/dali/internal/render/renderers/scene-graph-renderer.h index c5ebb7c..3dc63a0 100644 --- a/dali/internal/render/renderers/scene-graph-renderer.h +++ b/dali/internal/render/renderers/scene-graph-renderer.h @@ -67,28 +67,16 @@ public: virtual ~Renderer(); /** - * Set the Shader used to render. - * @param[in] shader The shader used to render. - */ - void SetShader( Shader* shader ); - - /** - * Set whether the ImageRenderer should use blending - * @param[in] useBlend True if blending should be used. + * Set the NodeDataProvider. + * @param[in] dataProvider The node data provider. */ - void SetUseBlend( bool useBlend ); + void SetDataProvider( NodeDataProvider* dataProvider ); /** - * Set the blending options. - * @param[in] options A bitmask of blending options. - */ - void SetBlendingOptions( unsigned int options ); - - /** - * Set the blend color. - * @param[in] color The new blend-color. + * Set the Shader used to render. + * @param[in] shader The shader used to render. */ - void SetBlendColor( const Vector4& color ); + void SetShader( Shader* shader ); /** * Set the face-culling mode. @@ -176,7 +164,7 @@ private: * Called from Render prior to DoRender(). Default method to set blending options * @todo MESH_REWORK Remove after merge */ - virtual void DoSetBlending( Context& context, BufferIndex bufferIndex ); + virtual void DoSetBlending( Context& context, BufferIndex bufferIndex ) = 0; /** * Called from Render; implemented in derived classes. @@ -191,17 +179,15 @@ private: protected: - NodeDataProvider& mDataProvider; // @todo MESH_REWORK rename to mNodeDataProvider. Shouldn't it be const? + NodeDataProvider* mDataProvider; // @todo MESH_REWORK rename to mNodeDataProvider. Shouldn't it be const? Context* mContextDELETEME; // TODO: MESH_REWORK DELETE THIS TextureCache* mTextureCacheDELETEME; // TODO: MESH_REWORK DELETE THIS Shader* mShader; unsigned int mSamplerBitfield; ///< Sampler options used for texture filtering - bool mUseBlend:1; ///< True if blending should be enabled, 1 bit is enough private: - BlendingOptions mBlendingOptions; CullFaceMode mCullFaceMode:3; ///< cullface enum, 3 bits is enough }; diff --git a/dali/internal/update/controllers/render-message-dispatcher.cpp b/dali/internal/update/controllers/render-message-dispatcher.cpp index ec1a2eb..4f9c66c 100644 --- a/dali/internal/update/controllers/render-message-dispatcher.cpp +++ b/dali/internal/update/controllers/render-message-dispatcher.cpp @@ -65,6 +65,28 @@ void RenderMessageDispatcher::RemoveRenderer( Renderer& renderer ) new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveRenderer, &renderer ); } +void RenderMessageDispatcher::AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider ) +{ + typedef MessageValue2< RenderManager, ImageRenderer*, NodeDataProvider* > DerivedType; + + // Reserve some memory inside the render queue + unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + + // Construct message in the render queue memory; note that delete should not be called on the return value + new (slot) DerivedType( &mRenderManager, &RenderManager::AddImageRenderer, renderer, dataProvider ); +} + +void RenderMessageDispatcher::RemoveImageRenderer( ImageRenderer* renderer ) +{ + typedef MessageValue1< RenderManager, ImageRenderer* > DerivedType; + + // Reserve some memory inside the render queue + unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) ); + + // Construct message in the render queue memory; note that delete should not be called on the return value + new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveImageRenderer, renderer ); +} + void RenderMessageDispatcher::AddGeometry( RenderGeometry& renderGeometry ) { typedef MessageValue1< RenderManager, RenderGeometry* > DerivedType; diff --git a/dali/internal/update/controllers/render-message-dispatcher.h b/dali/internal/update/controllers/render-message-dispatcher.h index 7980606..652ada3 100644 --- a/dali/internal/update/controllers/render-message-dispatcher.h +++ b/dali/internal/update/controllers/render-message-dispatcher.h @@ -32,6 +32,8 @@ class MessageBase; namespace SceneGraph { class Renderer; +class ImageRenderer; +class NodeDataProvider; class RenderManager; class RenderQueue; class RenderTracker; @@ -69,6 +71,18 @@ public: void RemoveRenderer( Renderer& renderer ); /** + * Add an image renderer in the render-thread. + * @param[in] renderer The renderer to add. + */ + void AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider ); + + /** + * Remove an image renderer in the render-thread. + * @param[in] renderer The renderer to remove. + */ + void RemoveImageRenderer( ImageRenderer* renderer ); + + /** * Add a Geometry * @param[in] renderGeometry The geometry to add. * @post RenderGeometry ownership is transferred. diff --git a/dali/internal/update/controllers/scene-controller-impl.cpp b/dali/internal/update/controllers/scene-controller-impl.cpp index eab7d85..b5ca61f 100644 --- a/dali/internal/update/controllers/scene-controller-impl.cpp +++ b/dali/internal/update/controllers/scene-controller-impl.cpp @@ -19,6 +19,7 @@ #include // INTERNAL INCLUDES +#include namespace Dali { @@ -44,6 +45,36 @@ SceneControllerImpl::SceneControllerImpl( RenderMessageDispatcher& renderMessage SceneControllerImpl::~SceneControllerImpl() { + // Clean-up renderers + const unsigned int count( mRendererPool.Count() ); + for( unsigned int i=0; i +#include namespace Dali { @@ -61,6 +62,16 @@ public: public: // from SceneController /** + * @copydoc SceneController::NewImageRenderer() + */ + virtual ImageRenderer* NewImageRenderer( NodeDataProvider& dataProvider ); + + /** + * @copydoc SceneController::FreeImageRenderer() + */ + virtual void FreeImageRenderer( ImageRenderer& renderer ); + + /** * @copydoc SceneController::GetRenderMessageDispatcher() */ virtual RenderMessageDispatcher& GetRenderMessageDispatcher() { return mRenderMessageDispatcher; } @@ -101,6 +112,7 @@ private: TextureCache& mTextureCache; ///< texture cache CompleteStatusManager& mCompleteStatusManager; ///< Complete Status manager + Dali::Vector< ImageRenderer* > mRendererPool; }; } // namespace SceneGraph diff --git a/dali/internal/update/controllers/scene-controller.h b/dali/internal/update/controllers/scene-controller.h index 247f273..5396cad 100644 --- a/dali/internal/update/controllers/scene-controller.h +++ b/dali/internal/update/controllers/scene-controller.h @@ -33,6 +33,8 @@ class RenderMessageDispatcher; class RenderQueue; class DiscardQueue; class TextureCache; +class ImageRenderer; +class NodeDataProvider; /** * Abstract interface for the scene controller @@ -56,6 +58,19 @@ public: } /** + * Get a reusable renderer from the pool + * @param[in] dataProvider The node using this renderer + * @return The renderer + */ + virtual ImageRenderer* NewImageRenderer( NodeDataProvider& dataProvider ) = 0; + + /** + * Return reusable renderer to the pool + * @param[in] The renderer + */ + virtual void FreeImageRenderer( ImageRenderer& renderer ) = 0; + + /** * Return the render message dispatcher * @return A reference to the render message dispatcher */ diff --git a/dali/internal/update/gestures/scene-graph-pan-gesture.cpp b/dali/internal/update/gestures/scene-graph-pan-gesture.cpp index 58be2b6..af0726e 100644 --- a/dali/internal/update/gestures/scene-graph-pan-gesture.cpp +++ b/dali/internal/update/gestures/scene-graph-pan-gesture.cpp @@ -893,6 +893,7 @@ bool PanGesture::InterpolatePoint( PanInfoHistory& history, unsigned int current PanInfoHistoryIter historyBegin = history.begin(); PanInfoHistoryIter lastIt = history.end(); bool pointGenerated = false; + bool havePreviousPoint = false; RelativeVectors newAcceleration; // Iterate through point history to perform interpolation. @@ -939,7 +940,7 @@ bool PanGesture::InterpolatePoint( PanInfoHistory& history, unsigned int current divisor += 1.0f / timeDelta; // Acceleration requires a previous point. - if( lastIt != history.end() ) + if( havePreviousPoint ) { // Time delta of input. float timeDifference( GetDivisibleTimeDifference( it->time, lastIt->time, 1.0f, OUTPUT_TIME_DIFFERENCE ) ); @@ -949,6 +950,10 @@ bool PanGesture::InterpolatePoint( PanInfoHistory& history, unsigned int current accelerationDivisor += 1.0f / timeDelta; } + else + { + havePreviousPoint = true; + } tapsUsed++; lastIt = it; diff --git a/dali/internal/update/manager/prepare-render-algorithms.cpp b/dali/internal/update/manager/prepare-render-algorithms.cpp index c213f95..c88b873 100644 --- a/dali/internal/update/manager/prepare-render-algorithms.cpp +++ b/dali/internal/update/manager/prepare-render-algorithms.cpp @@ -63,7 +63,7 @@ void PrepareRenderables( BufferIndex updateBufferIndex, RenderableAttachmentCont for ( RenderableAttachmentIter iter = renderableList.begin(); iter != endIter; ++iter ) { RenderableAttachment& renderable = **iter; - renderable.PrepareRender( updateBufferIndex ); + renderable.DoPrepareRender( updateBufferIndex ); } } diff --git a/dali/internal/update/node-attachments/scene-graph-image-attachment.cpp b/dali/internal/update/node-attachments/scene-graph-image-attachment.cpp index 59cb27d..8c48965 100644 --- a/dali/internal/update/node-attachments/scene-graph-image-attachment.cpp +++ b/dali/internal/update/node-attachments/scene-graph-image-attachment.cpp @@ -65,7 +65,8 @@ ImageAttachment::ImageAttachment( unsigned int textureId ) mIsPixelAreaSet( false ), mPreviousRefreshHints( 0 ), mStyle( Dali::ImageActor::STYLE_QUAD ), - mCullFaceMode( CullNone ) + mCullFaceMode( CullNone ), + mUseBlend( false ) { } @@ -73,10 +74,10 @@ void ImageAttachment::Initialize2( BufferIndex updateBufferIndex ) { DALI_ASSERT_DEBUG( NULL != mSceneController ); - // Create main renderer, passing ownership to the render-thread - mImageRenderer = ImageRenderer::New( *mParent ); + // Get a reusable renderer from the pool + mImageRenderer = mSceneController->NewImageRenderer( *mParent ); - mSceneController->GetRenderMessageDispatcher().AddRenderer( *mImageRenderer ); + mSceneController->GetRenderMessageDispatcher().AddImageRenderer( mImageRenderer, mParent ); ATTACHMENT_LOG_FMT(Debug::General, " renderer: %p\n", mImageRenderer); @@ -91,21 +92,25 @@ void ImageAttachment::Initialize2( BufferIndex updateBufferIndex ) new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetTextureId, mTextureId ); } - // After derived classes have (potentially) created their renderer - Renderer& renderer = GetRenderer(); - renderer.SetCullFace( mCullFaceMode ); - - // set the default shader here as well - renderer.SetShader( mShader ); + // send messages to renderer + SendCullFaceChangeMessage( updateBufferIndex ); + SendShaderChangeMessage( updateBufferIndex ); } void ImageAttachment::OnDestroy2() { DALI_ASSERT_DEBUG( NULL != mSceneController ); - // Request deletion in the next Render - mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mImageRenderer ); - mImageRenderer = NULL; + if( NULL != mImageRenderer ) + { + // Request GL cleanup in the next Render + mSceneController->GetRenderMessageDispatcher().RemoveImageRenderer( mImageRenderer ); + + // Return reusable renderer to the pool + mSceneController->FreeImageRenderer( *mImageRenderer ); + + mImageRenderer = NULL; + } } void ImageAttachment::ConnectedToSceneGraph() @@ -209,25 +214,25 @@ void ImageAttachment::SetBorder( BufferIndex updateBufferIndex, const Vector4& b void ImageAttachment::SetBlendingOptions( BufferIndex updateBufferIndex, unsigned int options ) { // Blending options are forwarded to renderer in render-thread - typedef MessageValue1< Renderer, unsigned int > DerivedType; + typedef MessageValue1< ImageRenderer, unsigned int > DerivedType; // Reserve some memory inside the render queue unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &GetRenderer(), &Renderer::SetBlendingOptions, options ); + new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetBlendingOptions, options ); } void ImageAttachment::SetBlendColor( BufferIndex updateBufferIndex, const Vector4& color ) { // Blend color is forwarded to renderer in render-thread - typedef MessageValue1< Renderer, Vector4 > DerivedType; + typedef MessageValue1< ImageRenderer, Vector4 > DerivedType; // Reserve some memory inside the render queue unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &GetRenderer(), &Renderer::SetBlendColor, color ); + new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetBlendColor, color ); } void ImageAttachment::SetCullFace( BufferIndex updateBufferIndex, CullFaceMode mode ) @@ -237,13 +242,7 @@ void ImageAttachment::SetCullFace( BufferIndex updateBufferIndex, CullFaceMode m mCullFaceMode = mode; - typedef MessageValue1< Renderer, CullFaceMode > DerivedType; - - // Reserve some memory inside the render queue - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - - // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &GetRenderer(), &Renderer::SetCullFace, mode ); + SendCullFaceChangeMessage( updateBufferIndex ); } void ImageAttachment::SetSampler( BufferIndex updateBufferIndex, unsigned int samplerBitfield ) @@ -428,6 +427,22 @@ void ImageAttachment::DoPrepareRender( BufferIndex updateBufferIndex ) mRefreshMeshData = false; } + + bool blend = !IsFullyOpaque( updateBufferIndex ); + + if ( mUseBlend != blend ) + { + mUseBlend = blend; + + // Enable/disable blending in the next render + typedef MessageValue1< ImageRenderer, bool > DerivedType; + + // Reserve some memory inside the render queue + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + + // Construct message in the render queue memory; note that delete should not be called on the return value + new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetUseBlend, blend ); + } } void RenderableAttachment::SetBlendingMode( BlendingMode::Type mode ) @@ -481,6 +496,17 @@ bool ImageAttachment::IsFullyOpaque( BufferIndex updateBufferIndex ) return fullyOpaque; } +void ImageAttachment::SendCullFaceChangeMessage( BufferIndex updateBufferIndex ) +{ + typedef MessageValue1< Renderer, CullFaceMode > DerivedType; + + // Reserve some memory inside the render queue + unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); + + // Construct message in the render queue memory; note that delete should not be called on the return value + new (slot) DerivedType( &GetRenderer(), &Renderer::SetCullFace, mCullFaceMode ); +} + void ImageAttachment::SendShaderChangeMessage( BufferIndex updateBufferIndex ) { typedef MessageValue1< Renderer, Shader* > DerivedType; diff --git a/dali/internal/update/node-attachments/scene-graph-image-attachment.h b/dali/internal/update/node-attachments/scene-graph-image-attachment.h index 1523d10..56710c4 100644 --- a/dali/internal/update/node-attachments/scene-graph-image-attachment.h +++ b/dali/internal/update/node-attachments/scene-graph-image-attachment.h @@ -199,6 +199,13 @@ protected: ImageAttachment( unsigned int textureId ); private: + + /** + * Sends the cull-face mode to the renderer + * @param updateBufferIndex for the message buffer + */ + void SendCullFaceChangeMessage( BufferIndex updateBufferIndex ); + /** * Sends the shader to the renderer * @param updateBufferIndex for the message buffer @@ -253,6 +260,7 @@ private: // Data int mPreviousRefreshHints : 4; ///< The shader geometry hints, when the vertex buffer was last refreshed, 4 bits is enough as there's 4 flags Style mStyle : 2; ///< rendering style, 2 bits is enough as only 2 values in the enum CullFaceMode mCullFaceMode : 3; ///< Cullface mode, 3 bits is enough for 4 values + bool mUseBlend : 1; ///< True if the attachment & renderer should be considered opaque for sorting and blending. BitmapMetadata mBitmapMetadata;///< The bitmap metadata Vector2 mGeometrySize; ///< The size of the currently used geometry diff --git a/dali/internal/update/node-attachments/scene-graph-renderable-attachment.cpp b/dali/internal/update/node-attachments/scene-graph-renderable-attachment.cpp index a27e960..b4a30ea 100644 --- a/dali/internal/update/node-attachments/scene-graph-renderable-attachment.cpp +++ b/dali/internal/update/node-attachments/scene-graph-renderable-attachment.cpp @@ -48,7 +48,6 @@ RenderableAttachment::RenderableAttachment( bool usesGeometryScaling ) mBlendingMode( Dali::ImageActor::DEFAULT_BLENDING_MODE ), mUsesGeometryScaling( usesGeometryScaling ), mScaleForSizeDirty( true ), - mUseBlend( false ), mHasSizeAndColorFlag( false ), mResourcesReady( false ), mFinishedResourceAcquisition( false ), @@ -211,30 +210,6 @@ void RenderableAttachment::GetReadyAndComplete(bool& ready, bool& complete) cons } } -void RenderableAttachment::PrepareRender( BufferIndex updateBufferIndex ) -{ - // call the derived class first as it might change its state regarding blending - DoPrepareRender( updateBufferIndex ); - - // @todo MESH_REWORK Remove remainder of method after removing ImageAttachment - - bool blend = !IsFullyOpaque( updateBufferIndex ); - - if ( mUseBlend != blend ) - { - mUseBlend = blend; - - // Enable/disable blending in the next render - typedef MessageValue1< Renderer, bool > DerivedType; - - // Reserve some memory inside the render queue - unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) ); - - // Construct message in the render queue memory; note that delete should not be called on the return value - new (slot) DerivedType( &GetRenderer(), &Renderer::SetUseBlend, blend ); - } -} - RenderableAttachment* RenderableAttachment::GetRenderable() { return this; diff --git a/dali/internal/update/node-attachments/scene-graph-renderable-attachment.h b/dali/internal/update/node-attachments/scene-graph-renderable-attachment.h index 0f01208..d4ba11c 100644 --- a/dali/internal/update/node-attachments/scene-graph-renderable-attachment.h +++ b/dali/internal/update/node-attachments/scene-graph-renderable-attachment.h @@ -176,13 +176,6 @@ public: // For use during in the update algorithm only */ void GetReadyAndComplete(bool& ready, bool& complete) const; - /** - * Prepare the object for rendering. - * This is called by the UpdateManager when an object is due to be rendered in the current frame. - * @param[in] updateBufferIndex The current update buffer index. - */ - void PrepareRender( BufferIndex updateBufferIndex ); - public: // API for derived classes /** @@ -212,7 +205,9 @@ public: // API for derived classes virtual bool DoPrepareResources( BufferIndex updateBufferIndex, ResourceManager& resourceManager ) = 0; /** - * @copydoc RenderableAttachment::PrepareRender() + * Prepare the object for rendering. + * This is called by the UpdateManager when an object is due to be rendered in the current frame. + * @param[in] updateBufferIndex The current update buffer index. */ virtual void DoPrepareRender( BufferIndex updateBufferIndex ) = 0; @@ -283,7 +278,6 @@ protected: bool mUsesGeometryScaling:1; ///< True if the derived renderer uses scaling. bool mScaleForSizeDirty:1; ///< True if mScaleForSize has changed in the current frame. - bool mUseBlend:1; ///< True if the attachment & renderer should be considered opaque for sorting and blending. bool mHasSizeAndColorFlag:1; ///< Set during the update algorithm to tell whether this renderer can potentially be seen bool mResourcesReady:1; ///< Set during the Update algorithm; true if the attachment has resources ready for the current frame. bool mFinishedResourceAcquisition:1; ///< Set during DoPrepareResources; true if ready & all resource acquisition has finished (successfully or otherwise) diff --git a/dali/internal/update/node-attachments/scene-graph-renderer-attachment.cpp b/dali/internal/update/node-attachments/scene-graph-renderer-attachment.cpp index eac06ef..8bb714e 100644 --- a/dali/internal/update/node-attachments/scene-graph-renderer-attachment.cpp +++ b/dali/internal/update/node-attachments/scene-graph-renderer-attachment.cpp @@ -70,6 +70,7 @@ RendererAttachment::RendererAttachment() mRegenerateUniformMap(REGENERATE_UNIFORM_MAP), mResendDataProviders(false), mResendGeometry(false), + mUseBlend( false ), mDepthIndex(0) { mUniformMapChanged[0]=false; @@ -384,6 +385,13 @@ void RendererAttachment::DoPrepareRender( BufferIndex updateBufferIndex ) mRegenerateUniformMap--; } + bool blend = !IsFullyOpaque( updateBufferIndex ); + if( mUseBlend != blend ) + { + mUseBlend = blend; + mResendDataProviders = true; + } + if( mResendDataProviders ) { RenderDataProvider* dataProvider = NewRenderDataProvider(); @@ -494,6 +502,7 @@ RenderDataProvider* RendererAttachment::NewRenderDataProvider() dataProvider->mMaterialDataProvider = mMaterial; dataProvider->mUniformMapDataProvider = this; dataProvider->mShader = mMaterial->GetShader(); + dataProvider->mUseBlend = mUseBlend; Vector& samplers = mMaterial->GetSamplers(); dataProvider->mSamplers.Reserve( samplers.Count() ); diff --git a/dali/internal/update/node-attachments/scene-graph-renderer-attachment.h b/dali/internal/update/node-attachments/scene-graph-renderer-attachment.h index b7c4e7a..3fd48dd 100644 --- a/dali/internal/update/node-attachments/scene-graph-renderer-attachment.h +++ b/dali/internal/update/node-attachments/scene-graph-renderer-attachment.h @@ -234,7 +234,7 @@ private: bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame bool mResendDataProviders : 1; ///< True if the data providers should be resent to the renderer bool mResendGeometry : 1; ///< True if geometry should be resent to the renderer - + bool mUseBlend : 1; ///< True if the attachment & renderer should be considered opaque for sorting and blending. public: // Properties int mDepthIndex; ///< Used only in PrepareRenderInstructions diff --git a/dali/public-api/actors/actor-enumerations.h b/dali/public-api/actors/actor-enumerations.h index 23aa9d2..0fdf60c 100644 --- a/dali/public-api/actors/actor-enumerations.h +++ b/dali/public-api/actors/actor-enumerations.h @@ -34,10 +34,10 @@ namespace Dali */ enum ColorMode { - USE_OWN_COLOR, ///< Actor will use its own color - USE_PARENT_COLOR, ///< Actor will use its parent color - USE_OWN_MULTIPLY_PARENT_COLOR, ///< Actor will blend its color with its parents color. - USE_OWN_MULTIPLY_PARENT_ALPHA ///< Actor will blend its alpha with its parents alpha. This means when parent fades in or out child does as well. This is the default. + USE_OWN_COLOR, ///< Actor will use its own color @since_tizen 2.4 + USE_PARENT_COLOR, ///< Actor will use its parent color @since_tizen 2.4 + USE_OWN_MULTIPLY_PARENT_COLOR, ///< Actor will blend its color with its parents color. @since_tizen 2.4 + USE_OWN_MULTIPLY_PARENT_ALPHA ///< Actor will blend its alpha with its parents alpha. This means when parent fades in or out child does as well. This is the default. @since_tizen 2.4 }; /** @@ -46,10 +46,10 @@ enum ColorMode */ enum PositionInheritanceMode { - INHERIT_PARENT_POSITION, ///< Actor will inherit its parent position. This is the default - USE_PARENT_POSITION, ///< Actor will copy its parent position. This is useful if many actors are stacked together in the same place. This option ignores parent origin and anchor point. - USE_PARENT_POSITION_PLUS_LOCAL_POSITION, ///< Actor will copy its parent position and add local position. This is useful if many actors are stacked together in the same place with an offset. This option ignores parent origin and anchor point. - DONT_INHERIT_POSITION ///< Actor will not inherit position. Local position is treated as world position. This is useful if a constraint is used to override local position or if an actor is positioned globally. This option ignores parent origin, anchor point and local position. + INHERIT_PARENT_POSITION, ///< Actor will inherit its parent position. This is the default @since_tizen 2.4 + USE_PARENT_POSITION, ///< Actor will copy its parent position. This is useful if many actors are stacked together in the same place. This option ignores parent origin and anchor point. @since_tizen 2.4 + USE_PARENT_POSITION_PLUS_LOCAL_POSITION, ///< Actor will copy its parent position and add local position. This is useful if many actors are stacked together in the same place with an offset. This option ignores parent origin and anchor point. @since_tizen 2.4 + DONT_INHERIT_POSITION ///< Actor will not inherit position. Local position is treated as world position. This is useful if a constraint is used to override local position or if an actor is positioned globally. This option ignores parent origin, anchor point and local position. @since_tizen 2.4 }; /** @@ -60,15 +60,15 @@ namespace Dimension { enum Type { - WIDTH = 0x1, ///< Width dimension - HEIGHT = 0x2, ///< Height dimension + WIDTH = 0x1, ///< Width dimension @since_tizen 2.4 + HEIGHT = 0x2, ///< Height dimension @since_tizen 2.4 - ALL_DIMENSIONS = 0x3 ///< Mask to cover all flags + ALL_DIMENSIONS = 0x3 ///< Mask to cover all flags @since_tizen 2.4 }; enum Meta { - DIMENSION_COUNT = 2 ///< Number of dimensions - update this if adding new dimension + DIMENSION_COUNT = 2 ///< Number of dimensions - update this if adding new dimension @since_tizen 2.4 }; } @@ -80,14 +80,14 @@ namespace ResizePolicy { enum Type { - FIXED, ///< Size is fixed as set by SetSize - USE_NATURAL_SIZE, ///< Size is to use the actor's natural size - FILL_TO_PARENT, ///< Size is to fill up to the actor's parent's bounds. Aspect ratio not maintained. - SIZE_RELATIVE_TO_PARENT, ///< The actors size will be ( ParentSize * SizeRelativeToParentFactor ). - SIZE_FIXED_OFFSET_FROM_PARENT, ///< The actors size will be ( ParentSize + SizeRelativeToParentFactor ). - FIT_TO_CHILDREN, ///< Size will adjust to wrap around all children - DIMENSION_DEPENDENCY, ///< One dimension is dependent on the other - USE_ASSIGNED_SIZE ///< The size will be assigned to the actor + FIXED, ///< Size is fixed as set by SetSize @since_tizen 2.4 + USE_NATURAL_SIZE, ///< Size is to use the actor's natural size @since_tizen 2.4 + FILL_TO_PARENT, ///< Size is to fill up to the actor's parent's bounds. Aspect ratio not maintained. @since_tizen 2.4 + SIZE_RELATIVE_TO_PARENT, ///< The actors size will be ( ParentSize * SizeRelativeToParentFactor ). @since_tizen 2.4 + SIZE_FIXED_OFFSET_FROM_PARENT, ///< The actors size will be ( ParentSize + SizeRelativeToParentFactor ). @since_tizen 2.4 + FIT_TO_CHILDREN, ///< Size will adjust to wrap around all children @since_tizen 2.4 + DIMENSION_DEPENDENCY, ///< One dimension is dependent on the other @since_tizen 2.4 + USE_ASSIGNED_SIZE ///< The size will be assigned to the actor @since_tizen 2.4 }; const Type DEFAULT = USE_NATURAL_SIZE; ///< Default resize policy } @@ -100,33 +100,37 @@ namespace SizeScalePolicy { enum Type { - USE_SIZE_SET, ///< Use the size that was set - FIT_WITH_ASPECT_RATIO, ///< Fit within the size set maintaining natural size aspect ratio - FILL_WITH_ASPECT_RATIO ///< Fill up the size set maintaining natural size aspect ratio. May exceed size bounds in one dimension. + USE_SIZE_SET, ///< Use the size that was set @since_tizen 2.4 + FIT_WITH_ASPECT_RATIO, ///< Fit within the size set maintaining natural size aspect ratio @since_tizen 2.4 + FILL_WITH_ASPECT_RATIO ///< Fill up the size set maintaining natural size aspect ratio. May exceed size bounds in one dimension. @since_tizen 2.4 }; } /** - * @brief Different types of alignment. + * @brief Horizontal alignment types. * @since_tizen 2.4 */ namespace HorizontalAlignment { enum Type { - LEFT, ///< Align horizontally left - CENTER, ///< Align horizontally center - RIGHT ///< Align horiztonally right + LEFT, ///< Align horizontally left @since_tizen 2.4 + CENTER, ///< Align horizontally center @since_tizen 2.4 + RIGHT ///< Align horiztonally right @since_tizen 2.4 }; } +/** + * @brief Vertical alignment types. + * @since_tizen 2.4 + */ namespace VerticalAlignment { enum Type { - TOP, ///< Align vertically top - CENTER, ///< Align vertically center - BOTTOM ///< Align vertically bottom + TOP, ///< Align vertically top @since_tizen 2.4 + CENTER, ///< Align vertically center @since_tizen 2.4 + BOTTOM ///< Align vertically bottom @since_tizen 2.4 }; } diff --git a/dali/public-api/actors/actor.h b/dali/public-api/actors/actor.h index 1ca112e..897e6a3 100644 --- a/dali/public-api/actors/actor.h +++ b/dali/public-api/actors/actor.h @@ -53,7 +53,7 @@ struct Vector2; struct Vector3; struct Vector4; -typedef Rect Padding; ///< Padding definition +typedef Rect Padding; ///< Padding definition @since_tizen 2.4 /** * @brief Actor is the primary object with which Dali applications interact. @@ -216,26 +216,14 @@ typedef Rect Padding; ///< Padding definition * touch signals are also emitted from the touch-down actor with an "Interrupted" state. * - If the consumed actor on hover-start is not the same as the consumed actor on hover-finished, then * hover signals are also emitted from the hover-started actor with an "Interrupted" state. + * *

Key Events:

* * Key events are received by an actor once set to grab key events, only one actor can be set as focused. * * @nosubgrouping * - * Signals - * | %Signal Name | Method | - * |-------------------|------------------------------| - * | touched | @ref TouchedSignal() | - * | hovered | @ref HoveredSignal() | - * | wheel-event | @ref WheelEventSignal() | - * | on-stage | @ref OnStageSignal() | - * | off-stage | @ref OffStageSignal() | * - * Actions - * | %Action Name | %Actor method called | - * |-------------------|------------------------------| - * | show | %SetVisible( true ) | - * | hide | %SetVisible( false ) | * @since_tizen 2.4 */ @@ -251,76 +239,76 @@ public: { enum { - PARENT_ORIGIN = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< name "parent-origin", type Vector3 - PARENT_ORIGIN_X, ///< name "parent-origin-x", type float - PARENT_ORIGIN_Y, ///< name "parent-origin-y", type float - PARENT_ORIGIN_Z, ///< name "parent-origin-z", type float - ANCHOR_POINT, ///< name "anchor-point", type Vector3 - ANCHOR_POINT_X, ///< name "anchor-point-x", type float - ANCHOR_POINT_Y, ///< name "anchor-point-y", type float - ANCHOR_POINT_Z, ///< name "anchor-point-z", type float - SIZE, ///< name "size", type Vector3 - SIZE_WIDTH, ///< name "size-width", type float - SIZE_HEIGHT, ///< name "size-height", type float - SIZE_DEPTH, ///< name "size-depth", type float - POSITION, ///< name "position", type Vector3 - POSITION_X, ///< name "position-x", type float - POSITION_Y, ///< name "position-y", type float - POSITION_Z, ///< name "position-z", type float - WORLD_POSITION, ///< name "world-position", type Vector3 (read-only) - WORLD_POSITION_X, ///< name "world-position-x", type float (read-only) - WORLD_POSITION_Y, ///< name "world-position-y", type float (read-only) - WORLD_POSITION_Z, ///< name "world-position-z", type float (read-only) - ORIENTATION, ///< name "orientation", type Quaternion - WORLD_ORIENTATION, ///< name "world-orientation", type Quaternion (read-only) - SCALE, ///< name "scale", type Vector3 - SCALE_X, ///< name "scale-x", type float - SCALE_Y, ///< name "scale-y", type float - SCALE_Z, ///< name "scale-z", type float - WORLD_SCALE, ///< name "world-scale", type Vector3 (read-only) - VISIBLE, ///< name "visible", type bool - COLOR, ///< name "color", type Vector4 - COLOR_RED, ///< name "color-red", type float - COLOR_GREEN, ///< name "color-green", type float - COLOR_BLUE, ///< name "color-blue", type float - COLOR_ALPHA, ///< name "color-alpha", type float - WORLD_COLOR, ///< name "world-color", type Vector4 (read-only) - WORLD_MATRIX, ///< name "world-matrix", type Matrix (read-only) - NAME, ///< name "name", type std::string - SENSITIVE, ///< name "sensitive", type bool - LEAVE_REQUIRED, ///< name "leave-required", type bool - INHERIT_ORIENTATION, ///< name "inherit-orientation", type bool - INHERIT_SCALE, ///< name "inherit-scale", type bool - COLOR_MODE, ///< name "color-mode", type std::string - POSITION_INHERITANCE, ///< name "position-inheritance", type std::string - DRAW_MODE, ///< name "draw-mode", type std::string - SIZE_MODE_FACTOR, ///< name "size-mode-factor", type Vector3 - WIDTH_RESIZE_POLICY, ///< name "width-resize-policy", type String - HEIGHT_RESIZE_POLICY, ///< name "height-resize-policy", type String - SIZE_SCALE_POLICY, ///< name "size-scale-policy", type String - WIDTH_FOR_HEIGHT, ///< name "width-for-height", type Boolean - HEIGHT_FOR_WIDTH, ///< name "height-for-width", type Boolean - PADDING, ///< name "padding", type Vector4 - MINIMUM_SIZE, ///< name "minimum-size", type Vector2 - MAXIMUM_SIZE, ///< name "maximum-size", type Vector2 + PARENT_ORIGIN = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< type Vector3 @since_tizen 2.4 + PARENT_ORIGIN_X, ///< type float @since_tizen 2.4 + PARENT_ORIGIN_Y, ///< type float @since_tizen 2.4 + PARENT_ORIGIN_Z, ///< type float @since_tizen 2.4 + ANCHOR_POINT, ///< type Vector3 @since_tizen 2.4 + ANCHOR_POINT_X, ///< type float @since_tizen 2.4 + ANCHOR_POINT_Y, ///< type float @since_tizen 2.4 + ANCHOR_POINT_Z, ///< type float @since_tizen 2.4 + SIZE, ///< type Vector3 @since_tizen 2.4 + SIZE_WIDTH, ///< type float @since_tizen 2.4 + SIZE_HEIGHT, ///< type float @since_tizen 2.4 + SIZE_DEPTH, ///< type float @since_tizen 2.4 + POSITION, ///< type Vector3 @since_tizen 2.4 + POSITION_X, ///< type float @since_tizen 2.4 + POSITION_Y, ///< type float @since_tizen 2.4 + POSITION_Z, ///< type float @since_tizen 2.4 + WORLD_POSITION, ///< type Vector3 (read-only) @since_tizen 2.4 + WORLD_POSITION_X, ///< type float (read-only) @since_tizen 2.4 + WORLD_POSITION_Y, ///< type float (read-only) @since_tizen 2.4 + WORLD_POSITION_Z, ///< type float (read-only) @since_tizen 2.4 + ORIENTATION, ///< type Quaternion @since_tizen 2.4 + WORLD_ORIENTATION, ///< type Quaternion (read-only) @since_tizen 2.4 + SCALE, ///< type Vector3 @since_tizen 2.4 + SCALE_X, ///< type float @since_tizen 2.4 + SCALE_Y, ///< type float @since_tizen 2.4 + SCALE_Z, ///< type float @since_tizen 2.4 + WORLD_SCALE, ///< type Vector3 (read-only) @since_tizen 2.4 + VISIBLE, ///< type bool @since_tizen 2.4 + COLOR, ///< type Vector4 @since_tizen 2.4 + COLOR_RED, ///< type float @since_tizen 2.4 + COLOR_GREEN, ///< type float @since_tizen 2.4 + COLOR_BLUE, ///< type float @since_tizen 2.4 + COLOR_ALPHA, ///< type float @since_tizen 2.4 + WORLD_COLOR, ///< type Vector4 (read-only) @since_tizen 2.4 + WORLD_MATRIX, ///< type Matrix (read-only) @since_tizen 2.4 + NAME, ///< type std::string @since_tizen 2.4 + SENSITIVE, ///< type bool @since_tizen 2.4 + LEAVE_REQUIRED, ///< type bool @since_tizen 2.4 + INHERIT_ORIENTATION, ///< type bool @since_tizen 2.4 + INHERIT_SCALE, ///< type bool @since_tizen 2.4 + COLOR_MODE, ///< type std::string @since_tizen 2.4 + POSITION_INHERITANCE, ///< type std::string @since_tizen 2.4 + DRAW_MODE, ///< type std::string @since_tizen 2.4 + SIZE_MODE_FACTOR, ///< type Vector3 @since_tizen 2.4 + WIDTH_RESIZE_POLICY, ///< type String @since_tizen 2.4 + HEIGHT_RESIZE_POLICY, ///< type String @since_tizen 2.4 + SIZE_SCALE_POLICY, ///< type String @since_tizen 2.4 + WIDTH_FOR_HEIGHT, ///< type Boolean @since_tizen 2.4 + HEIGHT_FOR_WIDTH, ///< type Boolean @since_tizen 2.4 + PADDING, ///< type Vector4 @since_tizen 2.4 + MINIMUM_SIZE, ///< type Vector2 @since_tizen 2.4 + MAXIMUM_SIZE, ///< type Vector2 @since_tizen 2.4 }; }; // Typedefs - typedef Signal< bool (Actor, const TouchEvent&)> TouchSignalType; ///< Touch signal type - typedef Signal< bool (Actor, const HoverEvent&)> HoverSignalType; ///< Hover signal type - typedef Signal< bool (Actor, const WheelEvent&) > WheelEventSignalType; ///< Wheel signal type - typedef Signal< void (Actor) > OnStageSignalType; ///< Stage connection signal type - typedef Signal< void (Actor) > OffStageSignalType; ///< Stage disconnection signal type - typedef Signal< void (Actor) > OnRelayoutSignalType; ///< Called when the actor is relaid out + typedef Signal< bool (Actor, const TouchEvent&)> TouchSignalType; ///< Touch signal type @since_tizen 2.4 + typedef Signal< bool (Actor, const HoverEvent&)> HoverSignalType; ///< Hover signal type @since_tizen 2.4 + typedef Signal< bool (Actor, const WheelEvent&) > WheelEventSignalType; ///< Wheel signal type @since_tizen 2.4 + typedef Signal< void (Actor) > OnStageSignalType; ///< Stage connection signal type @since_tizen 2.4 + typedef Signal< void (Actor) > OffStageSignalType; ///< Stage disconnection signal type @since_tizen 2.4 + typedef Signal< void (Actor) > OnRelayoutSignalType; ///< Called when the actor is relaid out @since_tizen 2.4 // Creation /** * @brief Create an uninitialized Actor; this can be initialized with Actor::New(). * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an uninitialized Actor handle is not allowed. * @since_tizen 2.4 */ Actor(); @@ -334,7 +322,7 @@ public: static Actor New(); /** - * @brief Downcast an Object handle to Actor handle. + * @brief Downcast a handle to Actor handle. * * If handle points to a Actor object the downcast produces valid * handle. If not the returned handle is left uninitialized. @@ -366,6 +354,7 @@ public: * * @since_tizen 2.4 * @param [in] rhs The actor to copy. + * @return A reference to this */ Actor& operator=(const Actor& rhs); @@ -439,9 +428,6 @@ public: /** * @brief Adds a child Actor to this Actor. * - * 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 * @since_tizen 2.4 * @param [in] child The child. * @pre This Actor (the parent) has been initialized. @@ -450,6 +436,9 @@ public: * @pre The actor is not the Root actor * @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. + * @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 */ void Add(Actor child); @@ -469,7 +458,7 @@ public: * * If the actor has no parent, this method does nothing. * @since_tizen 2.4 - * @pre The (child) actor has been initialized. + * @pre The (child) Actor has been initialized. */ void Unparent(); @@ -519,7 +508,7 @@ public: * * @since_tizen 2.4 * @return A handle to the actor's parent. If the actor has no parent, this handle will be invalid. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. */ Actor GetParent() const; @@ -586,7 +575,7 @@ public: * @since_tizen 2.4 * @param [in] width The new width. * @param [in] height The new height. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This is an asynchronous method; the value written may not match a value subsequently read with GetCurrentSize(). */ void SetSize(float width, float height); @@ -600,7 +589,7 @@ public: * @param [in] width The size of the actor along the x-axis. * @param [in] height The size of the actor along the y-axis. * @param [in] depth The size of the actor along the z-axis. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This is an asynchronous method; the value written may not match a value subsequently read with GetCurrentSize(). */ void SetSize(float width, float height, float depth); @@ -613,7 +602,7 @@ public: * The actors default depth is the minimum of width & height. * @since_tizen 2.4 * @param [in] size The new size. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This is an asynchronous method; the value written may not match a value subsequently read with GetCurrentSize(). */ void SetSize(const Vector2& size); @@ -625,7 +614,7 @@ public: * This does not interfere with the actors scale factor. * @since_tizen 2.4 * @param [in] size The new size. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This is an asynchronous method; the value written may not match a value subsequently read with GetCurrentSize(). */ void SetSize(const Vector3& size); @@ -635,7 +624,7 @@ public: * * @since_tizen 2.4 * @return The actor's current size. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This return is the value that was set using SetSize or the target size of an animation */ Vector3 GetTargetSize() const; @@ -645,7 +634,7 @@ public: * * @since_tizen 2.4 * @return The actor's current size. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This property can be animated; the return value may not match the value written with SetSize(). */ Vector3 GetCurrentSize() const; @@ -729,7 +718,7 @@ public: * * @since_tizen 2.4 * @param[in] distance The actor will move by this distance. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. */ void TranslateBy(const Vector3& distance); @@ -769,7 +758,7 @@ public: * @brief Returns the actors position inheritance mode. * * @since_tizen 2.4 - * @return true if the actor inherit's it's parent orientation, false if it uses world orientation. + * @return True if the actor inherit's it's parent orientation, false if it uses world orientation. * @pre The Actor has been initialized. */ PositionInheritanceMode GetPositionInheritanceMode() const; @@ -818,7 +807,7 @@ public: * @since_tizen 2.4 * @param[in] angle The angle to the rotation to combine with the existing orientation. * @param[in] axis The axis of the rotation to combine with the existing orientation. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. */ void RotateBy( const Degree& angle, const Vector3& axis ) { @@ -831,7 +820,7 @@ public: * @since_tizen 2.4 * @param[in] angle The angle to the rotation to combine with the existing orientation. * @param[in] axis The axis of the rotation to combine with the existing orientation. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. */ void RotateBy(const Radian& angle, const Vector3& axis); @@ -840,7 +829,7 @@ public: * * @since_tizen 2.4 * @param[in] relativeRotation The rotation to combine with the existing orientation. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. */ void RotateBy(const Quaternion& relativeRotation); @@ -869,7 +858,7 @@ public: * @brief Returns whether the actor inherit's it's parent's orientation. * * @since_tizen 2.4 - * @return true if the actor inherit's it's parent orientation, false if it uses world orientation. + * @return True if the actor inherit's it's parent orientation, false if it uses world orientation. * @pre The Actor has been initialized. */ bool IsOrientationInherited() const; @@ -921,7 +910,7 @@ public: * * @since_tizen 2.4 * @param[in] relativeScale The scale to combine with the actors existing scale. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. */ void ScaleBy(const Vector3& relativeScale); @@ -960,7 +949,7 @@ public: * @brief Returns whether the actor inherit's it's parent's scale. * * @since_tizen 2.4 - * @return true if the actor inherit's it's parent scale, false if it uses world scale. + * @return True if the actor inherit's it's parent scale, false if it uses world scale. * @pre The Actor has been initialized. */ bool IsScaleInherited() const; @@ -982,7 +971,7 @@ public: * * @since_tizen 2.4 * @param [in] visible The new visibility flag. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This is an asynchronous method; the value written may not match a value subsequently read with IsVisible(). * @note If an actor's visibility flag is set to false, then the actor and its children will not be rendered. * This is regardless of the individual visibility values of the children i.e. an actor will only be @@ -995,7 +984,7 @@ public: * * @since_tizen 2.4 * @return The visibility flag. - * @pre The actor has been initialized. + * @pre The Actor has been initialized. * @note This property can be animated; the return value may not match the value written with SetVisible(). * @note If an actor is not visible, then the actor and its children will not be rendered. * This is regardless of the individual visibility values of the children i.e. an actor will only be @@ -1084,7 +1073,7 @@ public: * * If DrawMode::OVERLAY_2D is used, the actor and its children will be drawn as a 2D overlay. * Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer. - * For overlay actors, the drawing order is with respect to depth-index property of Renderers, + * For overlay actors, the drawing order is with respect to depth-index property of Actors, * and depth-testing will not be used. * * If DrawMode::STENCIL is used, the actor and its children will be used to stencil-test other actors @@ -1131,7 +1120,7 @@ public: * @note If an actor's sensitivity is set to false, then it's children will not be hittable either. * This is regardless of the individual sensitivity values of the children i.e. an actor will only be * hittable if all of its parents have sensitivity set to true. - * @see @see SignalTouch() and SignalHover(). + * @see @see TouchedSignal() and HoveredSignal(). */ void SetSensitive(bool sensitive); @@ -1139,7 +1128,7 @@ public: * @brief Query whether an actor emits touch or hover event signals. * * @since_tizen 2.4 - * @return true, if emission of touch or hover event signals is enabled, false otherwise. + * @return True, if emission of touch or hover event signals is enabled, false otherwise. * @pre The Actor has been initialized. * @note If an actor is not sensitive, then it's children will not be hittable either. * This is regardless of the individual sensitivity values of the children i.e. an actor will only be @@ -1169,7 +1158,7 @@ public: * @param[in] required Should be set to true if a Leave event is required * @pre The Actor has been initialized. * @note By default, this is set to false as most actors do not require this. - * @note Need to connect to the SignalTouch or SignalHover to actually receive this event. + * @note Need to connect to the TouchedSignal() or HoveredSignal() to actually receive this event. * */ void SetLeaveRequired(bool required); @@ -1179,7 +1168,7 @@ public: * the boundary of the actor. * * @since_tizen 2.4 - * @return true if a Leave event is required, false otherwise. + * @return True if a Leave event is required, false otherwise. * @pre The Actor has been initialized. */ bool GetLeaveRequired() const; @@ -1199,7 +1188,7 @@ public: * @brief Returns whether the actor is focusable by keyboard navigation. * * @since_tizen 2.4 - * @return true if the actor is focusable by keyboard navigation, false if not. + * @return True if the actor is focusable by keyboard navigation, false if not. * @pre The Actor has been initialized. */ bool IsKeyboardFocusable() const; @@ -1246,7 +1235,7 @@ public: * This factor is only used when ResizePolicy is set to either: * ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT. * This actor's size is set to the actor's size multipled by or added to this factor, - * depending on ResizePolicy (See SetResizePolicy). + * depending on ResizePolicy ( See SetResizePolicy() ). * * @since_tizen 2.4 * @param [in] factor A Vector3 representing the relative factor to be applied to each axis. @@ -1409,15 +1398,17 @@ public: // Signals * * @note When the parent of a set of actors is connected to the stage, then all of the children * will received this callback. - * * For the following actor tree, the callback order will be A, B, D, E, C, and finally F. * + * @code + * * A (parent) * / \ * B C * / \ \ * D E F * + * @endcode */ OnStageSignalType& OnStageSignal(); @@ -1430,15 +1421,18 @@ public: // Signals * @return The signal * @note When the parent of a set of actors is disconnected to the stage, then all of the children * will received this callback, starting with the leaf actors. - * * For the following actor tree, the callback order will be D, E, B, F, C, and finally A. * + * @code + * * A (parent) * / \ * B C * / \ \ * D E F * + * @endcode + * */ OffStageSignalType& OffStageSignal(); @@ -1448,6 +1442,7 @@ public: // Renderer * @brief Add a renderer to this actor. * * @since_tizen 2.4 + * @remarks Not implemented yet. This will be supported in future version. * @param[in] renderer Renderer to add to the actor * @return The index of the Renderer that was added * @pre The renderer must be initialized. @@ -1459,7 +1454,8 @@ public: // Renderer * @brief Get the number of renderers on this actor. * * @since_tizen 2.4 - * @return the number of renderers on this actor + * @remarks Not implemented yet. This will be supported in future version + * @return The number of renderers on this actor */ unsigned int GetRendererCount() const; @@ -1467,6 +1463,7 @@ public: // Renderer * @brief Get a Renderer by index. * * @since_tizen 2.4 + * @remarks Not implemented yet. This will be supported in future version. * @param[in] index The index of the renderer to fetch * @return The renderer at the specified index * @pre The index must be between 0 and GetRendererCount()-1 @@ -1478,6 +1475,7 @@ public: // Renderer * @brief Remove an renderer from the actor. * * @since_tizen 2.4 + * @remarks Not implemented yet. This will be supported in future version. * @param[in] renderer Handle to the renderer that is to be removed */ void RemoveRenderer( Renderer& renderer ); @@ -1486,11 +1484,13 @@ public: // Renderer * @brief Remove an renderer from the actor by index. * * @since_tizen 2.4 + * @remarks Not implemented yet. This will be supported in future version. * @param[in] index Index of the renderer that is to be removed * @pre The index must be between 0 and GetRendererCount()-1 * */ void RemoveRenderer( unsigned int index ); + /** * @brief This signal is emitted after the size has been set on the actor during relayout * @@ -1502,7 +1502,7 @@ public: // Renderer public: // Not intended for application developers /** - * @brief This constructor is used by Dali New() methods. + * @brief This constructor is used by Actor::New() methods. * * @since_tizen 2.4 * @param [in] actor A pointer to a newly allocated Dali resource @@ -1514,7 +1514,7 @@ public: // Not intended for application developers * @brief Helper for discarding an actor handle. * * If the handle is empty, this method does nothing. Otherwise - * actor.Unparent() will be called, followed by actor.Reset(). + * Actor::Unparent() will be called, followed by Actor::Reset(). * @since_tizen 2.4 * @param[in,out] actor A handle to an actor, or an empty handle. */ diff --git a/dali/public-api/actors/blending.h b/dali/public-api/actors/blending.h index aab2aa1..7423a8b 100644 --- a/dali/public-api/actors/blending.h +++ b/dali/public-api/actors/blending.h @@ -28,64 +28,67 @@ namespace Dali * @{ */ -namespace BlendingMode -{ /** * @brief Blending mode. * @since_tizen 2.4 - * @see Dali::RenderableActor::SetBlendMode() and Dali::RenderableActor::GetBlendMode() + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. */ +namespace BlendingMode +{ enum Type { - OFF, ///< Blending is disabled. - AUTO, ///< Blending is enabled if there is alpha channel. - ON ///< Blending is enabled. + OFF, ///< Blending is disabled. @since_tizen 2.4 + AUTO, ///< Blending is enabled if there is alpha channel. @since_tizen 2.4 + ON ///< Blending is enabled. @since_tizen 2.4 }; } //namespace BlendingMode -namespace BlendingFactor -{ /** * @brief Blending Factor. * * @since_tizen 2.4 - * @see Dali::RenderableActor::SetBlendFunc() and Dali::RenderableActor::GetBlendFunc() + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. */ +namespace BlendingFactor +{ enum Type { - ZERO = 0, - ONE = 1, - SRC_COLOR = 0x0300, - ONE_MINUS_SRC_COLOR = 0x0301, - SRC_ALPHA = 0x0302, - ONE_MINUS_SRC_ALPHA = 0x0303, - DST_ALPHA = 0x0304, - ONE_MINUS_DST_ALPHA = 0x0305, - DST_COLOR = 0x0306, - ONE_MINUS_DST_COLOR = 0x0307, - SRC_ALPHA_SATURATE = 0x0308, - CONSTANT_COLOR = 0x8001, - ONE_MINUS_CONSTANT_COLOR = 0x8002, - CONSTANT_ALPHA = 0x8003, - ONE_MINUS_CONSTANT_ALPHA = 0x8004 + ZERO = 0, ///< ZERO @since_tizen 2.4 + ONE = 1, ///< ONE @since_tizen 2.4 + SRC_COLOR = 0x0300, ///< SRC_COLOR @since_tizen 2.4 + ONE_MINUS_SRC_COLOR = 0x0301, ///< ONE_MINUS_SRC_COLOR @since_tizen 2.4 + SRC_ALPHA = 0x0302, ///< SRC_ALPHA @since_tizen 2.4 + ONE_MINUS_SRC_ALPHA = 0x0303, ///< ONE_MINUS_SRC_ALPHA @since_tizen 2.4 + DST_ALPHA = 0x0304, ///< DST_ALPHA @since_tizen 2.4 + ONE_MINUS_DST_ALPHA = 0x0305, ///< ONE_MINUS_DST_ALPHA @since_tizen 2.4 + DST_COLOR = 0x0306, ///< DST_COLOR @since_tizen 2.4 + ONE_MINUS_DST_COLOR = 0x0307, ///< ONE_MINUS_DST_COLOR @since_tizen 2.4 + SRC_ALPHA_SATURATE = 0x0308, ///< SRC_ALPHA_SATURATE @since_tizen 2.4 + CONSTANT_COLOR = 0x8001, ///< CONSTANT_COLOR @since_tizen 2.4 + ONE_MINUS_CONSTANT_COLOR = 0x8002, ///< ONE_MINUS_CONSTANT_COLOR @since_tizen 2.4 + CONSTANT_ALPHA = 0x8003, ///< CONSTANT_ALPHA @since_tizen 2.4 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 ///< ONE_MINUS_CONSTANT_ALPHA @since_tizen 2.4 }; } // namespace BlendingFactor -namespace BlendingEquation -{ /** * @brief Blending Equation. * * @since_tizen 2.4 - * @see Dali::RenderableActor::SetBlendEquation() and Dali::RenderableActor::GetBlendEquation() + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. */ +namespace BlendingEquation +{ enum Type { - ADD = 0x8006, - SUBTRACT = 0x800A, - REVERSE_SUBTRACT = 0x800B + ADD = 0x8006, ///< ADD @since_tizen 2.4 + SUBTRACT = 0x800A, ///< SUBTRACT @since_tizen 2.4 + REVERSE_SUBTRACT = 0x800B ///< REVERSE_SUBTRACT @since_tizen 2.4 }; } // namespace BlendingEquation diff --git a/dali/public-api/actors/camera-actor.h b/dali/public-api/actors/camera-actor.h index 432b157..74afa6e 100644 --- a/dali/public-api/actors/camera-actor.h +++ b/dali/public-api/actors/camera-actor.h @@ -32,6 +32,10 @@ namespace Internal DALI_INTERNAL class CameraActor; } +/** + * @brief Camera enumerations. + * @since_tizen 2.4 + */ namespace Camera { /** @@ -40,8 +44,8 @@ namespace Camera */ enum Type { - FREE_LOOK, ///< Camera orientation is taken from CameraActor - LOOK_AT_TARGET, ///< Camera is oriented to always look at a target + FREE_LOOK, ///< Camera orientation is taken from CameraActor @since_tizen 2.4 + LOOK_AT_TARGET, ///< Camera is oriented to always look at a target @since_tizen 2.4 }; /** @@ -50,8 +54,8 @@ enum Type */ enum ProjectionMode { - PERSPECTIVE_PROJECTION, ///< Distance causes foreshortening; objects further from the camera appear smaller - ORTHOGRAPHIC_PROJECTION, ///< Relative distance from the camera does not affect the size of objects + PERSPECTIVE_PROJECTION, ///< Distance causes foreshortening; objects further from the camera appear smaller @since_tizen 2.4 + ORTHOGRAPHIC_PROJECTION, ///< Relative distance from the camera does not affect the size of objects @since_tizen 2.4 }; } // namespace Camera @@ -78,6 +82,7 @@ public: /** * @brief An enumeration of properties belonging to the CameraActor class. + * * Properties additional to Actor. * @since_tizen 2.4 */ @@ -85,28 +90,28 @@ public: { enum { - TYPE = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "type", type std::string - PROJECTION_MODE, ///< name "projection-mode", type std::string - FIELD_OF_VIEW, ///< name "field-of-view", type float - ASPECT_RATIO, ///< name "aspect-ratio", type float - NEAR_PLANE_DISTANCE, ///< name "near-plane-distance", type float - FAR_PLANE_DISTANCE, ///< name "far-plane-distance", type float - LEFT_PLANE_DISTANCE, ///< name "left-plane-distance", type float - RIGHT_PLANE_DISTANCE, ///< name "right-plane-distance", type float - TOP_PLANE_DISTANCE, ///< name "top-plane-distance", type float - BOTTOM_PLANE_DISTANCE, ///< name "bottom-plane-distance", type float - TARGET_POSITION, ///< name "target-position", type Vector3 - PROJECTION_MATRIX, ///< name "projection-matrix", type Matrix - VIEW_MATRIX, ///< name "view-matrix", type Matrix - INVERT_Y_AXIS, ///< name "invert-y-axis", type bool + TYPE = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< type std::string @since_tizen 2.4 + PROJECTION_MODE, ///< type std::string @since_tizen 2.4 + FIELD_OF_VIEW, ///< type float @since_tizen 2.4 + ASPECT_RATIO, ///< type float @since_tizen 2.4 + NEAR_PLANE_DISTANCE, ///< type float @since_tizen 2.4 + FAR_PLANE_DISTANCE, ///< type float @since_tizen 2.4 + LEFT_PLANE_DISTANCE, ///< type float @since_tizen 2.4 + RIGHT_PLANE_DISTANCE, ///< type float @since_tizen 2.4 + TOP_PLANE_DISTANCE, ///< type float @since_tizen 2.4 + BOTTOM_PLANE_DISTANCE, ///< type float @since_tizen 2.4 + TARGET_POSITION, ///< type Vector3 @since_tizen 2.4 + PROJECTION_MATRIX, ///< type Matrix @since_tizen 2.4 + VIEW_MATRIX, ///< type Matrix @since_tizen 2.4 + INVERT_Y_AXIS, ///< type bool @since_tizen 2.4 }; }; /** * @brief Create an uninitialized CameraActor handle. * - * Initialise it using CameraActor::New(). Calling member functions - * with an uninitialized Dali::Object is not allowed. + * Initialise it using CameraActor::New(). + * Calling member functions with an uninitialized CameraActor handle is not allowed. * @since_tizen 2.4 */ CameraActor(); @@ -116,7 +121,7 @@ public: * * Sets the default camera perspective projection for the stage's size. @see SetPerspectiveProjection(). * @since_tizen 2.4 - * @return the newly created camera actor. + * @return The newly created camera actor. */ static CameraActor New(); @@ -127,18 +132,18 @@ public: * * @since_tizen 2.4 * @param[in] size The canvas size. - * @return the newly created camera actor. + * @return The newly created camera actor. */ static CameraActor New( const Size& size ); /** - * @brief Downcast an Object handle to CameraActor. + * @brief Downcast a handle to CameraActor handle. * * If handle points to a CameraActor the downcast produces valid * handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 * @param[in] handle to An object - * @return handle to a CameraActor or an uninitialized handle + * @return Handle to a CameraActor or an uninitialized handle */ static CameraActor DownCast( BaseHandle handle ); @@ -163,6 +168,7 @@ public: * * @since_tizen 2.4 * @param [in] rhs The actor to copy. + * @return A reference to this */ CameraActor& operator=(const CameraActor& rhs); @@ -178,7 +184,7 @@ public: * @brief Get the type of the camera. * * @since_tizen 2.4 - * @return the type of camera + * @return The type of camera */ Dali::Camera::Type GetType() const; @@ -228,7 +234,7 @@ public: * * The default aspect ratio is 4.0f/3.0f * @since_tizen 2.4 - * @return the aspect ratio + * @return The aspect ratio */ float GetAspectRatio( ); @@ -236,7 +242,7 @@ public: * @brief Sets the near clipping plane distance. * * @since_tizen 2.4 - * @param[in] nearClippingPlane distance of the near clipping plane + * @param[in] nearClippingPlane Distance of the near clipping plane */ void SetNearClippingPlane( float nearClippingPlane ); @@ -246,7 +252,7 @@ public: * The default near clipping plane is 800.0f, to match the default screen height * Reduce this value to see objects closer to the camera * @since_tizen 2.4 - * @return the near clipping plane value + * @return The near clipping plane value */ float GetNearClippingPlane( ); @@ -254,7 +260,7 @@ public: * @brief Sets the far clipping plane distance. * * @since_tizen 2.4 - * @param[in] farClippingPlane distance of the far clipping plane + * @param[in] farClippingPlane Distance of the far clipping plane */ void SetFarClippingPlane( float farClippingPlane ); @@ -263,7 +269,7 @@ public: * * The default value is the default near clipping plane + (0xFFFF>>4) * @since_tizen 2.4 - * @return the far clipping plane value + * @return The far clipping plane value */ float GetFarClippingPlane( ); @@ -353,7 +359,7 @@ public: public: // Not intended for use by Application developers /** - * @brief This constructor is used by Dali New() methods. + * @brief This constructor is used by CameraActor::New() methods. * * @since_tizen 2.4 * @param [in] actor A pointer to a newly allocated Dali resource diff --git a/dali/public-api/actors/custom-actor-impl.h b/dali/public-api/actors/custom-actor-impl.h index ef281fc..3297e91 100644 --- a/dali/public-api/actors/custom-actor-impl.h +++ b/dali/public-api/actors/custom-actor-impl.h @@ -58,7 +58,7 @@ typedef IntrusivePtr CustomActorImplPtr; * @brief CustomActorImpl is an abstract base class for custom control implementations. * * This provides a series of pure virtual methods, which are called when actor-specific events occur. - * An CustomActorImpl is typically owned by a single CustomActor instance; see also CustomActor::New(CustomActorImplPtr). + * An CustomActorImpl is typically owned by a single CustomActor instance; see also CustomActor::CustomActor( CustomActorImpl &implementation ). * @since_tizen 2.4 */ class DALI_IMPORT_API CustomActorImpl : public Dali::RefObject @@ -86,39 +86,44 @@ public: * * When an actor is connected, it will be directly or indirectly parented to the root Actor. * @since_tizen 2.4 - * @note The root Actor is provided automatically by Dali::Stage, and is always considered to be connected. + * @param[in] depth The depth in the hierarchy for the actor * - * @note When the parent of a set of actors is connected to the stage, then all of the children + * @note The root Actor is provided automatically by Dali::Stage, and is always considered to be connected. + * When the parent of a set of actors is connected to the stage, then all of the children * will received this callback. - * * For the following actor tree, the callback order will be A, B, D, E, C, and finally F. * + * @code + * * A (parent) * / \ * B C * / \ \ * D E F * - * @param[in] depth The depth in the hierarchy for the actor + * @endcode */ virtual void OnStageConnection( int depth ) = 0; /** - * @brief Called after the actor has been disconnected from the stage. + * @brief Called after the actor has been disconnected from Stage. * * If an actor is disconnected it either has no parent, or is parented to a disconnected actor. * * @since_tizen 2.4 * @note When the parent of a set of actors is disconnected to the stage, then all of the children * will received this callback, starting with the leaf actors. - * * For the following actor tree, the callback order will be D, E, B, F, C, and finally A. * + * @code + * * A (parent) * / \ * B C * / \ \ * D E F + * + * @endcode */ virtual void OnStageDisconnection() = 0; @@ -151,7 +156,7 @@ public: * @brief Called when the owning actor's size is set e.g. using Actor::SetSize(). * * @since_tizen 2.4 - * @param[in] targetSize The target size. Note that this target size may not match the size returned via Actor::GetSize(). + * @param[in] targetSize The target size. Note that this target size may not match the size returned via @ref Actor::GetSize. */ virtual void OnSizeSet(const Vector3& targetSize) = 0; @@ -160,7 +165,7 @@ public: * * @since_tizen 2.4 * @param[in] animation The object which is animating the owning actor. - * @param[in] targetSize The target size. Note that this target size may not match the size returned via Actor::GetSize(). + * @param[in] targetSize The target size. Note that this target size may not match the size returned via @ref Actor::GetSize. */ virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize) = 0; @@ -170,7 +175,7 @@ public: * @since_tizen 2.4 * @param[in] event The touch event. * @return True if the event should be consumed. - * @note This must be enabled during construction; see CustomActorImpl::CustomActorImpl(bool) + * @note This must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ). */ virtual bool OnTouchEvent(const TouchEvent& event) = 0; @@ -180,7 +185,7 @@ public: * @since_tizen 2.4 * @param[in] event The hover event. * @return True if the event should be consumed. - * @note This must be enabled during construction; see CustomActorImpl::SetRequiresHoverEvents(bool) + * @note This must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ). */ virtual bool OnHoverEvent(const HoverEvent& event) = 0; @@ -199,7 +204,7 @@ public: * @since_tizen 2.4 * @param[in] event The wheel event. * @return True if the event should be consumed. - * @note This must be enabled during construction; see CustomActorImpl::SetRequiresWheelEvents(bool) + * @note This must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ). */ virtual bool OnWheelEvent(const WheelEvent& event) = 0; @@ -212,9 +217,6 @@ public: * actors differently after certain operations like add or remove * actors, resize or after changing specific properties. * - * Note! As this function is called from inside the size negotiation algorithm, you cannot - * call RequestRelayout (the call would just be ignored) - * * @since_tizen 2.4 * @param[in] size The allocated size. * @param[in,out] container The control should add actors to this container that it is not able @@ -255,8 +257,8 @@ public: * Derived classes should override this if they wish to customize the height returned. * * @since_tizen 2.4 - * @param width to use. - * @return the height based on the width. + * @param width Width to use. + * @return The height based on the width. */ virtual float GetHeightForWidth( float width ) = 0; @@ -266,8 +268,8 @@ public: * Derived classes should override this if they wish to customize the width returned. * * @since_tizen 2.4 - * @param height to use. - * @return the width based on the width. + * @param height Height to use. + * @return The width based on the width. */ virtual float GetWidthForHeight( float height ) = 0; @@ -316,12 +318,12 @@ protected: // For derived classes enum ActorFlags { ACTOR_BEHAVIOUR_NONE = 0, - DISABLE_SIZE_NEGOTIATION = 1 << 0, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm - REQUIRES_TOUCH_EVENTS = 1 << 1, ///< True if the OnTouchEvent() callback is required. - REQUIRES_HOVER_EVENTS = 1 << 2, ///< True if the OnHoverEvent() callback is required. - REQUIRES_WHEEL_EVENTS = 1 << 3, ///< True if the OnWheelEvent() callback is required. + DISABLE_SIZE_NEGOTIATION = 1 << 0, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm @since_tizen 2.4 + REQUIRES_TOUCH_EVENTS = 1 << 1, ///< True if the OnTouchEvent() callback is required. @since_tizen 2.4 + REQUIRES_HOVER_EVENTS = 1 << 2, ///< True if the OnHoverEvent() callback is required. @since_tizen 2.4 + REQUIRES_WHEEL_EVENTS = 1 << 3, ///< True if the OnWheelEvent() callback is required. @since_tizen 2.4 - LAST_ACTOR_FLAG ///< Special marker for last actor flag + LAST_ACTOR_FLAG ///< Special marker for last actor flag @since_tizen 2.4 }; static const int ACTOR_FLAG_COUNT = Log< LAST_ACTOR_FLAG - 1 >::value + 1; ///< Value for deriving classes to continue on the flag enum @@ -351,16 +353,16 @@ protected: // For derived classes /** * @brief provides the Actor implementation of GetHeightForWidth * @since_tizen 2.4 - * @param width to use. - * @return the height based on the width. + * @param width Width to use. + * @return The height based on the width. */ float GetHeightForWidthBase( float width ); /** - * @brief provides the Actor implementation of GetWidthForHeight + * @brief Provides the Actor implementation of GetWidthForHeight * @since_tizen 2.4 - * @param height to use. - * @return the width based on the height. + * @param height Height to use. + * @return The width based on the height. */ float GetWidthForHeightBase( float height ); @@ -400,7 +402,7 @@ public: // Not intended for application developers * Owner is the Dali::Internal::CustomActor that owns the implementation of the custom actor * inside core. Creation of a handle to Dali public API Actor requires this pointer. * @since_tizen 2.4 - * @return a pointer to the Actor implementation that owns this custom actor implementation + * @return A pointer to the Actor implementation that owns this custom actor implementation */ Internal::CustomActor* GetOwner() const; diff --git a/dali/public-api/actors/custom-actor.h b/dali/public-api/actors/custom-actor.h index 6276b3b..7ffb96c 100644 --- a/dali/public-api/actors/custom-actor.h +++ b/dali/public-api/actors/custom-actor.h @@ -48,20 +48,20 @@ public: * @brief Create an uninitialized CustomActor handle. * * Only derived versions can be instantiated. - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an uninitialized CustomActor handle is not allowed. * @since_tizen 2.4 */ CustomActor(); /** - * @brief Downcast an Object handle to CustomActor. + * @brief Downcast a handle to CustomActor handle. * * If handle points to a CustomActor the downcast produces valid * handle. If not the returned handle is left uninitialized. * * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a CustomActor or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a CustomActor or an uninitialized handle */ static CustomActor DownCast( BaseHandle handle ); @@ -111,6 +111,7 @@ public: * * @since_tizen 2.4 * @param [in] rhs The actor to copy. + * @return A reference to this */ CustomActor& operator=(const CustomActor& rhs); diff --git a/dali/public-api/actors/draw-mode.h b/dali/public-api/actors/draw-mode.h index d4b489d..dc3747e 100644 --- a/dali/public-api/actors/draw-mode.h +++ b/dali/public-api/actors/draw-mode.h @@ -27,20 +27,20 @@ namespace Dali * @{ */ -namespace DrawMode -{ - /** * @brief How the actor and it's children will be drawn. * * @since_tizen 2.4 * @see Dali::Actor::SetDrawMode() */ +namespace DrawMode +{ + enum Type { - NORMAL = 0, ///< binary 00. The default draw-mode - OVERLAY_2D = 1, ///< binary 01. Draw the actor and its children as an overlay - STENCIL = 3 ///< binary 11. Draw the actor and its children into the stencil buffer + NORMAL = 0, ///< binary 00. The default draw-mode @since_tizen 2.4 + OVERLAY_2D = 1, ///< binary 01. Draw the actor and its children as an overlay @since_tizen 2.4 + STENCIL = 3 ///< binary 11. Draw the actor and its children into the stencil buffer @since_tizen 2.4 }; } // namespace DrawMode diff --git a/dali/public-api/actors/image-actor.h b/dali/public-api/actors/image-actor.h index b0ad736..9f3345f 100644 --- a/dali/public-api/actors/image-actor.h +++ b/dali/public-api/actors/image-actor.h @@ -32,7 +32,6 @@ namespace Dali { /** - * @internal * @addtogroup dali_core_actors * @{ */ @@ -43,7 +42,6 @@ class ImageActor; } /** - * @deprecated Use ImageView instead. * @brief An actor for displaying images. * * Allows the developer to add an actor to stage which displays the content of an Image object. @@ -52,19 +50,13 @@ class ImageActor; * * If an ImageActor is created without setting size, then the actor takes the size of the image - * this is the natural size. - * Setting a size on the ImageActor, e.g through the SetSize api or through an animation will + * Setting a size on the ImageActor, e.g through the @ref Actor::SetSize api or through an animation will * stop the natural size being used. * - * If a pixel area is set on an ImageActor with natural size, the actor size will change - * to match the pixel area. If a pixel area is set on an ImageActor that has had it's size set, - * then the size doesn't change, and the partial image will be stretched to fill the set size. - * - * Clearing the pixel area on an Image actor with natural size will cause the actor to show the - * whole image again, and will change size back to that of the image. - * - * Clearing the pixel area on an Image actor with a set size will cause the actor to show the - * whole image again, but will not change the image size. * @since_tizen 2.4 + * @remarks Use of ImageActor should be avoided unless shader effects need to be applied. + * For general purpose, use Toolkit::ImageView which has much better performance. + * @see Toolkit::ImageView */ class DALI_IMPORT_API ImageActor : public Actor { @@ -72,94 +64,71 @@ public: /** * @brief An enumeration of properties belonging to the ImageActor class. - * Properties additional to RenderableActor. * @since_tizen 2.4 */ struct Property { enum { - PIXEL_AREA = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "pixel-area", type Rect - STYLE, ///< name "style", type std::string - BORDER, ///< name "border", type Vector4 - IMAGE, ///< name "image", type Map {"filename":"", "load-policy":...} + /** + * @brief name "pixel-area", type Rect + * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. + */ + PIXEL_AREA = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, + /** + * @brief name "style", type std::string + * @since_tizen 2.4 + */ + STYLE, + /** + * @brief name "border", type Vector4 + * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. + */ + BORDER, + /** + * @brief name "image", type Map {"filename":"", "load-policy":...} + * @since_tizen 2.4 + */ + IMAGE, }; }; /** * @brief Style determines how the Image is rendered. - * - * @code - * STYLE_QUAD: - * - * 0---------2 0-----------------2 - * | /| | /| - * | A / | | A / | - * | / | | / | - * | / | SCALE (X) | / | - * | / | --------> | / | - * | / | | / | - * | / | | / | - * | / B | | / B | - * |/ | |/ | - * 1---------3 1-----------------3 - * - * Image is rendered as a textured rectangle. The texture - * is scaled uniformly as the quad is resized. - * - * STYLE_NINE_PATCH: - * - * |---|---------------|---| |---|-----------------------------|---| - * | 1 | 2 | 3 | | 1 | 2 | 3 | - * |---|---------------|---| |---|-----------------------------|---| - * | | | | | | | | - * | | | | | | | | - * | 4 | 5 | 6 | SCALE | | | | - * | | | | ----> | | | | - * | | | | | 4 | 5 | 6 | - * |-------------------|---| | | | | - * | 7 | 8 | 9 | | | | | - * |---|---------------|---| | | | | - * |---------------------------------|---| - * | 7 | 8 | 9 | - * |---|-----------------------------|---| - * - * Image is rendered as a textured rectangle. The texture - * is scaled differently over each of the 9 sections. - * - * STYLE_NINE_PATCH_NO_CENTER: - * - * Image is rendered in the same way as STYLE_NINE_PATCH, - * but the Center Section (5) is not rendered. - * @endcode - * - * Visualise a Picture Frame: - * - * - Corner sections (1,3,7,9) are not scaled, regardless - * of how big the Image is. - * - Horizontal edge sections (2,8) are scaled only in the - * X axis as the image increases in width. - * - Vertical edge sections (4,6) are scaled only in the - * Y axis as the image increases in height. - * - Center section (5) is scaled in both X and Y axes as - * the image increases in width and/or height. - * - * Note: If GRID hints are enabled (via a Shader that requires it), - * the above geometry will be further subdivided into rectangles of - * approx. 40x40 in size. STYLE_NINE_PATCH_NO_CENTER is not supported - * yet when GRID hints are enabled. * @since_tizen 2.4 */ enum Style { - STYLE_QUAD, ///< As a simple quad. - STYLE_NINE_PATCH, ///< As a nine-patch. - STYLE_NINE_PATCH_NO_CENTER ///< As a nine-patch without center section being rendered. + /** + * @brief As a simple quad. + * @since_tizen 2.4 + */ + STYLE_QUAD, + /** + * @brief As a nine-patch. + * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. + */ + STYLE_NINE_PATCH, + /** + * @brief As a nine-patch without center section being rendered. + * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. + */ + STYLE_NINE_PATCH_NO_CENTER }; /** * @brief Pixel area is relative to the top-left (0,0) of the image. * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. */ typedef Rect PixelArea; @@ -168,8 +137,8 @@ public: /** * @brief Create an uninitialized ImageActor handle. * - * This can be initialized with ImageActor::New(...) - * Calling member functions with an uninitialized Dali::Object is not allowed. + * This can be initialized with ImageActor::New(...). + * Calling member functions with an unintialized ImageActor handle is not allowed. * @since_tizen 2.4 */ ImageActor(); @@ -211,15 +180,15 @@ public: static ImageActor New(Image image, PixelArea pixelArea); /** - * @brief Downcast an Object handle to ImageActor. + * @brief Downcast a handle to ImageActor handle. * * * If handle points to a ImageActor the downcast produces valid * handle. If not the returned handle is left uninitialized. * * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a ImageActor or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a ImageActor or an uninitialized handle */ static ImageActor DownCast( BaseHandle handle ); @@ -244,17 +213,19 @@ public: * * @since_tizen 2.4 * @param [in] rhs The actor to copy. + * @return A reference to this */ ImageActor& operator=(const ImageActor& rhs); /** * @brief Set the image rendered by the actor. + * * Set the image rendered by the actor. * If actor was already displaying a different image, the old image is dropped and actor may * temporarily display nothing. Setting an empty image (handle) causes the current image to be * dropped and actor displays nothing. * The actor will take the image's natural size unless a custom size - * is chosen, e.g. via Actor:SetSize() + * is chosen, e.g. via Actor::SetSize() * * @since_tizen 2.4 * @param [in] image The image to display. @@ -275,12 +246,14 @@ public: * @brief Set a region of the image to display, in pixels. * * When the image is loaded the actor's size will be reset to the pixelArea, - * unless a custom size was chosen, e.g. via Actor:SetSize(). - * Note! PixelArea should be inside the image data size. It gets clamped by GL + * unless a custom size was chosen, e.g. via Actor::SetSize(). * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param [in] pixelArea The area of the image to display. * This in pixels, relative to the top-left (0,0) of the image. - * @pre image must be initialized. + * @pre Image must be initialized. + * @note PixelArea should be inside the image data size. It gets clamped by GL */ void SetPixelArea(const PixelArea& pixelArea); @@ -288,8 +261,10 @@ public: * @brief Retrieve the region of the image to display, in pixels. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @return The pixel area, or a default-constructed area if none was set. - * @pre image must be initialized. + * @pre Image must be initialized. */ PixelArea GetPixelArea() const; @@ -298,7 +273,7 @@ public: * * @since_tizen 2.4 * @param [in] style The new style. - * @pre image must be initialized. + * @pre Image must be initialized. */ void SetStyle(Style style); @@ -307,24 +282,28 @@ public: * * @since_tizen 2.4 * @return The rendering style. - * @pre image must be initialized. + * @pre Image must be initialized. */ Style GetStyle() const; /** - * @brief Set the border used with STYLE_NINE_PATCH. + * @brief Set the border used with ImageActor::STYLE_NINE_PATCH. * * The values are in pixels from the left, top, right, and bottom of the image respectively. - * i.e. SetNinePatchBorder( Vector4(1,2,3,4) ) sets the left-border to 1, top-border to 2, right-border to 3, and bottom-border to 4 pixels. + * i.e. ImageActor::SetNinePatchBorder( Vector4(1,2,3,4) ) sets the left-border to 1, top-border to 2, right-border to 3, and bottom-border to 4 pixels. * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param [in] border The new nine-patch border. */ void SetNinePatchBorder(const Vector4& border); /** - * @brief Retrieve the border used with STYLE_NINE_PATCH. + * @brief Retrieve the border used with ImageActor::STYLE_NINE_PATCH. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @return The nine-patch border. */ Vector4 GetNinePatchBorder() const; @@ -335,8 +314,11 @@ public: * * The offset can be altered for each coplanar actor hence allowing an order of painting. * @since_tizen 2.4 - * @param [in] depthOffset the offset to be given to the actor. Positive values pushing it further back. + * @remarks Avoid using this method as it's a legacy code. Rendering order of actors on the same z position should be + * determined by the depth level in the scene graph tree, not by this method + * @param [in] depthOffset The offset to be given to the actor. Positive values pushing it further back. * @pre The Actor has been initialized. + * @see Layer::Behavior */ void SetSortModifier(float depthOffset); @@ -345,8 +327,11 @@ public: * * The offset can be altered for each coplanar actor hence allowing an order of painting. * @since_tizen 2.4 - * @return the offset that has been given to the actor. Positive values pushing it further back. + * @remarks Avoid using this method as it's a legacy code. Rendering order of actors on the same z position should be + * determined by the depth level in the scene graph tree, not by this method + * @return The offset that has been given to the actor. Positive values pushing it further back. * @pre The Actor has been initialized. + * @see Layer::Behavior */ float GetSortModifier() const; @@ -364,6 +349,8 @@ public: * * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[in] mode The blending mode. */ void SetBlendMode( BlendingMode::Type mode ); @@ -372,6 +359,8 @@ public: * @brief Retrieves the blending mode. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @return The blending mode, one of BlendingMode::OFF, BlendingMode::AUTO or BlendingMode::ON. */ BlendingMode::Type GetBlendMode() const; @@ -380,15 +369,11 @@ public: * @brief Specify the pixel arithmetic used when the actor is blended. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[in] srcFactorRgba Specifies how the red, green, blue, and alpha source blending factors are computed. - * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR, - * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR, - * GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. * * @param[in] destFactorRgba Specifies how the red, green, blue, and alpha destination blending factors are computed. - * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR, - * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR, - * GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. */ void SetBlendFunc( BlendingFactor::Type srcFactorRgba, BlendingFactor::Type destFactorRgba ); @@ -396,21 +381,15 @@ public: * @brief Specify the pixel arithmetic used when the actor is blended. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[in] srcFactorRgb Specifies how the red, green, and blue source blending factors are computed. - * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR, - * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR, - * GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, and GL_SRC_ALPHA_SATURATE. * * @param[in] destFactorRgb Specifies how the red, green, blue, and alpha destination blending factors are computed. - * The options are BlendingFactor::ZERO, ONE, SRC_COLOR, ONE_MINUS_SRC_COLOR, DST_COLOR, ONE_MINUS_DST_COLOR, - * SRC_ALPHA, ONE_MINUS_SRC_ALPHA, DST_ALPHA, ONE_MINUS_DST_ALPHA, CONSTANT_COLOR, ONE_MINUS_CONSTANT_COLOR, - * GL_CONSTANT_ALPHA, and GL_ONE_MINUS_CONSTANT_ALPHA. * * @param[in] srcFactorAlpha Specifies how the alpha source blending factor is computed. - * The options are the same as for srcFactorRgb. * * @param[in] destFactorAlpha Specifies how the alpha source blending factor is computed. - * The options are the same as for destFactorRgb. */ void SetBlendFunc( BlendingFactor::Type srcFactorRgb, BlendingFactor::Type destFactorRgb, BlendingFactor::Type srcFactorAlpha, BlendingFactor::Type destFactorAlpha ); @@ -419,6 +398,8 @@ public: * @brief Query the pixel arithmetic used when the actor is blended. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[out] srcFactorRgb Specifies how the red, green, blue, and alpha source blending factors are computed. * @param[out] destFactorRgb Specifies how the red, green, blue, and alpha destination blending factors are computed. * @param[out] srcFactorAlpha Specifies how the red, green, blue, and alpha source blending factors are computed. @@ -430,8 +411,10 @@ public: /** * @brief Specify the equation used when the actor is blended. * - * The options are BlendingEquation::ADD, SUBTRACT, or REVERSE_SUBTRACT. + * The options are BlendingEquation::ADD, BlendingEquation::SUBTRACT, or BlendingEquation::REVERSE_SUBTRACT. * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[in] equationRgba The equation used for combining red, green, blue, and alpha components. */ void SetBlendEquation( BlendingEquation::Type equationRgba ); @@ -440,9 +423,11 @@ public: * @brief Specify the equation used when the actor is blended. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[in] equationRgb The equation used for combining red, green, and blue components. * @param[in] equationAlpha The equation used for combining the alpha component. - * The options are BlendingEquation::ADD, SUBTRACT, or REVERSE_SUBTRACT. + * The options are BlendingEquation::ADD, BlendingEquation::SUBTRACT, or BlendingEquation::REVERSE_SUBTRACT. */ void SetBlendEquation( BlendingEquation::Type equationRgb, BlendingEquation::Type equationAlpha ); @@ -450,6 +435,8 @@ public: * @brief Query the equation used when the actor is blended. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[out] equationRgb The equation used for combining red, green, and blue components. * @param[out] equationAlpha The equation used for combining the alpha component. */ @@ -459,6 +446,8 @@ public: * @brief Specify the color used when the actor is blended; the default is Vector4::ZERO. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[in] color The blend color. */ void SetBlendColor( const Vector4& color ); @@ -467,6 +456,8 @@ public: * @brief Query the color used when the actor is blended. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @return The blend color. */ const Vector4& GetBlendColor() const; @@ -482,6 +473,8 @@ public: * * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[in] minFilter The minification filtering mode. * @param[in] magFilter The magnification filtering mode. */ @@ -491,25 +484,28 @@ public: * @brief Retrieves the filtering mode. * * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. * @param[out] minFilter The return minification value * @param[out] magFilter The return magnification value */ void GetFilterMode( FilterMode::Type& minFilter, FilterMode::Type& magFilter) const; /** - * @brief Sets the shader effect for the RenderableActor. + * @brief Sets the shader effect for the ImageActor. * * Shader effects provide special effects like ripple and bend. - * Setting a shader effect removes any shader effect previously set by SetShaderEffect. + * Setting a shader effect removes any shader effect previously set by @ref ImageActor::SetShaderEffect. * @since_tizen 2.4 * @param [in] effect The shader effect. * @pre The actor has been initialized. - * @pre effect has been initialized. + * @pre Effect has been initialized. */ void SetShaderEffect( ShaderEffect effect ); /** - * @brief Retrieve the custom shader effect for the RenderableActor. + * @brief Retrieve the custom shader effect for the ImageActor. + * * If default shader is used an empty handle is returned. * * @since_tizen 2.4 @@ -537,22 +533,22 @@ public: // Not intended for application developers * @brief Sets the shader effect for all ImageActors in a tree of Actors. * * @since_tizen 2.4 - * @param [in] actor root of a tree of actors. + * @param [in] actor Root of a tree of actors. * @param [in] effect The shader effect. * @see ImageActor::SetShaderEffect * */ -DALI_IMPORT_API void SetShaderEffectRecursively( Actor actor, ShaderEffect effect ); +DALI_IMPORT_API void SetShaderEffectRecursively( Dali::Actor actor, Dali::ShaderEffect effect ); /** * @brief Removes the shader effect from all ImageActors in a tree of Actors. * * @since_tizen 2.4 - * @param [in] actor root of a tree of actors. + * @param [in] actor Root of a tree of actors. * @see ImageActor::RemoveShaderEffect * */ -DALI_IMPORT_API void RemoveShaderEffectRecursively( Actor actor ); +DALI_IMPORT_API void RemoveShaderEffectRecursively( Dali::Actor actor ); /** * @} diff --git a/dali/public-api/actors/layer.h b/dali/public-api/actors/layer.h index b0795ae..85d564f 100644 --- a/dali/public-api/actors/layer.h +++ b/dali/public-api/actors/layer.h @@ -49,22 +49,25 @@ typedef Rect ClippingBox; * @brief Layers provide a mechanism for overlaying groups of actors on top of each other. * * When added to the stage, a layer can be ordered relative to other layers. The bottom - * layer is at depth zero. The stage provides a default layer for it's children. + * layer is at depth zero. The stage provides a default layer for it's children (see Stage::GetRootLayer()). * * Layered actors inherit position etc. as normal, but are drawn in an order determined * by the layers. The depth buffer is cleared before each layer is rendered unless depth * test is disabled or there's no need for it based on the layers contents; * actors in lower layers cannot obscure actors in higher layers. * + * A layer has either LAYER_2D or LAYER_3D mode. LAYER_2D has better performance, + * the depth test is disabled, and a child actor hides its parent actor. + * LAYER_3D uses the depth test, thus a close actor hides a farther one. + * LAYER_2D is the default mode and recommended for general cases. + * See Layer::Behavior and SetBehavior() for more information. + * + * Layer is a type of Actor, thus can have parent or children actors. + * A layer influences rendering of its all descendant actors, + * until another layer appears in the actor tree and manages its own subtree. + * * If depth test is disabled, there is no performance overhead from clearing the depth buffer. * - * Actions - * | %Action Name | %Layer method called | - * |-----------------|----------------------| - * | raise | @ref Raise() | - * | lower | @ref Lower() | - * | raise-to-top | @ref RaiseToTop() | - * | lower-to-bottom | @ref LowerToBottom() | * @since_tizen 2.4 */ class DALI_IMPORT_API Layer : public Actor @@ -73,16 +76,18 @@ public: /** * @brief An enumeration of properties belonging to the Layer class. + * * Properties additional to Actor. + * * @since_tizen 2.4 */ struct Property { enum { - CLIPPING_ENABLE = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< name "clipping-enable", type bool - CLIPPING_BOX, ///< name "clipping-box", type Rect - BEHAVIOR, ///< name "behavior", type String + CLIPPING_ENABLE = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< type bool @since_tizen 2.4 + CLIPPING_BOX, ///< type Rect @since_tizen 2.4 + BEHAVIOR, ///< type String @since_tizen 2.4 }; }; @@ -95,27 +100,58 @@ public: enum Behavior { /** - * @brief Layer doesn't make use of the depth test. + * @brief Layer doesn't make use of the depth test (default mode). * * This mode is expected to have better performance than the 3D mode. - * When using this mode any ordering would be with respect to depth-index property of Renderers. + * When using this mode any ordering would be with respect to depth-index property of Actors. + * + * For the following actor tree of the Layer1 object, D and E hide B, B and C hides A, + * and F hides C, regardless of their z positions. + * Rendering order between siblings, such as D & E or B & C, is not determined. + * If you have two overlapped actors, just make them parent-child, not siblings. + * + * @code + * + * Layer1 (parent) + * | + * A + * / \ + * B C + * / \ \ + * D E F + * + * @endcode + * + * @since_tizen 2.4 */ LAYER_2D, /** * @brief Layer will use depth test and do several clears. * - * When using this mode depth depth test will be used. A depth clear will happen for each distinct + * When using this mode depth test will be used. A depth clear will happen for each distinct * depth-index value in the layer, opaque renderers are drawn first and write to the depth buffer. * Then transparent renderers are drawn with depth test enabled but depth write switched off. + * Unlike LAYER_2D, parent-child relationship does not affect rendering order at all. + * + * @since_tizen 2.4 + * @remarks This is an experimental feature. Using 2D UI components of DALi Toolkit + * in LAYER_3D mode has not been enoughly tested yet + * because they are orginally designed for 2D use cases. + * Simple controls such as Toolkit::Control or Toolkit::ImageView might not have any problem with LAYER_3D, + * but more complex one like Toolkit::PushButton, you might get unexpected rendered order in LAYER_3D. + * Although we'll support 2D controls in LAYER_3D soon, we recommend to use 2D controls with LAYER_2D only at this moment. + * Of course, controls rendered in 3D space, such as SpiralLayout of Toolkit::ItemView + * (see Toolkit::DefaultItemLayout::New), should be used with LAYER_3D. */ LAYER_3D, }; - /* - * TREE_DEPTH_MULTIPLIER is used by the rendering sorting algorithm to decide which actors to render first. + /** + * @brief TREE_DEPTH_MULTIPLIER is used by the rendering sorting algorithm to decide which actors to render first. * For 2D layers, this value will be multiplied to the actor depth in the tree and added to the depth index * to obtain the value which will be used for ordering + * @since_tizen 2.4 */ enum TreeDepthMultiplier { @@ -125,7 +161,7 @@ public: * @brief The sort function type. * * @since_tizen 2.4 - * @param[in] position this is the actor translation from camera. + * @param[in] position This is the actor translation from camera. */ typedef float (*SortFunctionType)( const Vector3& position ); @@ -146,13 +182,13 @@ public: static Layer New(); /** - * @brief Downcast an Object handle to Layer. + * @brief Downcast a handle to Layer handle. * * If handle points to a Layer the downcast produces valid * handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a Layer or an uninitialized handle + * @param[in] handle Handle to An object + * @return Handle to a Layer or an uninitialized handle */ static Layer DownCast( BaseHandle handle ); @@ -177,6 +213,7 @@ public: * * @since_tizen 2.4 * @param [in] rhs The actor to copy. + * @return A reference to this */ Layer& operator=(const Layer& rhs); @@ -185,8 +222,8 @@ public: * * 0 is bottom most layer, higher number is on top * @since_tizen 2.4 - * @return the current depth of the layer. - * @pre layer is on the stage + * @return The current depth of the layer. + * @pre Layer is on the stage * If layer is not added to the stage, returns 0. */ unsigned int GetDepth() const; @@ -195,7 +232,7 @@ public: * @brief Increment the depth of the layer. * * @since_tizen 2.4 - * @pre layer is on the stage + * @pre Layer is on the stage */ void Raise(); @@ -203,7 +240,7 @@ public: * @brief Decrement the depth of the layer. * * @since_tizen 2.4 - * @pre layer is on the stage + * @pre Layer is on the stage */ void Lower(); @@ -212,11 +249,11 @@ public: * * If the layer already is above target layer its depth is not changed * If the layer was below target, its new depth will be immediately above target - * Note! All layers between this layer and target get new depth values * @since_tizen 2.4 - * @param target layer to get above of - * @pre layer is on the stage - * @pre target layer is on the stage + * @param target Layer to get above of + * @pre Layer is on the stage + * @pre Target layer is on the stage + * @note All layers between this layer and target get new depth values */ void RaiseAbove( Layer target ); @@ -225,18 +262,18 @@ public: * * If the layer already is below the layer its depth is not changed * If the layer was above target, its new depth will be immediately below target - * Note! All layers between this layer and target get new depth values * @since_tizen 2.4 - * @param target layer to get below of - * @pre layer is on the stage - * @pre target layer is on the stage + * @param target Layer to get below of + * @pre Layer is on the stage + * @pre Target layer is on the stage + * @note All layers between this layer and target get new depth values */ void LowerBelow( Layer target ); /** * @brief Raises the layer to the top. * @since_tizen 2.4 - * @pre layer is on the stage + * @pre Layer is on the stage */ void RaiseToTop(); @@ -251,11 +288,11 @@ public: * @brief Moves the layer directly above the given layer. * * After the call this layers depth will be immediately above target - * Note! All layers between this layer and target get new depth values * @since_tizen 2.4 - * @param target layer to get on top of - * @pre layer is on the stage - * @pre target layer is on the stage + * @param target Layer to get on top of + * @pre Layer is on the stage + * @pre Target layer is on the stage + * @note All layers between this layer and target get new depth values */ void MoveAbove( Layer target ); @@ -263,11 +300,11 @@ public: * @brief Moves the layer directly below the given layer. * * After the call this layers depth will be immediately below target - * Note! All layers between this layer and target get new depth values * @since_tizen 2.4 - * @param target layer to get below of - * @pre layer is on the stage - * @pre target layer is on the stage + * @param target Layer to get below of + * @pre Layer is on the stage + * @pre Target layer is on the stage + * @note All layers between this layer and target get new depth values */ void MoveBelow( Layer target ); @@ -347,7 +384,7 @@ public: * However, it's possible to disable the depth test by calling this method. * * @since_tizen 2.4 - * @param[in] disable \e true disables depth test. \e false sets the default behavior. + * @param[in] disable \e True disables depth test. \e false sets the default behavior. */ void SetDepthTestDisabled( bool disable ); @@ -355,7 +392,7 @@ public: * @brief Retrieves whether depth test is disabled. * * @since_tizen 2.4 - * @return \e true if depth test is disabled. + * @return \e True if depth test is disabled. */ bool IsDepthTestDisabled() const; @@ -374,7 +411,7 @@ public: * * @since_tizen 2.4 * @param[in] function The sort function pointer - * @note If the sort function returns a low number, the actor the data applies to will be + * @note If the sort function returns a low number, the actor with the data will be * drawn in front of an actor whose data yields a high value from the sort function. * * @note All child layers use the same sort function. If a child layer is added to this @@ -397,7 +434,7 @@ public: * @brief Retrieves whether the layer consumes touch (including gestures). * * @since_tizen 2.4 - * @return true if consuming touch, false otherwise. + * @return True if consuming touch, false otherwise. */ bool IsTouchConsumed() const; @@ -415,14 +452,14 @@ public: * @brief Retrieves whether the layer consumes hover. * * @since_tizen 2.4 - * @return true if consuming hover, false otherwise. + * @return True if consuming hover, false otherwise. */ bool IsHoverConsumed() const; public: // Not intended for application developers /** - * @brief This constructor is used by Dali New() methods. + * @brief This constructor is used by Layer::New() methods. * * @since_tizen 2.4 * @param [in] Layer A pointer to a newly allocated Dali resource diff --git a/dali/public-api/actors/sampling.h b/dali/public-api/actors/sampling.h index 65e8051..e15fe58 100644 --- a/dali/public-api/actors/sampling.h +++ b/dali/public-api/actors/sampling.h @@ -28,19 +28,20 @@ namespace Dali * @{ */ -namespace FilterMode -{ /** * @brief Texture filtering mode. * @since_tizen 2.4 - * @see Dali::RenderableActor::SetFilterMode() and Dali::RenderableActor::GetFilterMode() + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. */ +namespace FilterMode +{ enum Type { - NONE, ///< Use GL system defaults (minification NEAREST_MIPMAP_LINEAR, magnification LINEAR) - DEFAULT, ///< Use dali defaults (minification LINEAR, magnification LINEAR) - NEAREST, ///< Filter nearest - LINEAR ///< Filter linear + NONE, ///< Use GL system defaults (minification NEAREST_MIPMAP_LINEAR, magnification LINEAR) @since_tizen 2.4 + DEFAULT, ///< Use dali defaults (minification LINEAR, magnification LINEAR) @since_tizen 2.4 + NEAREST, ///< Filter nearest @since_tizen 2.4 + LINEAR ///< Filter linear @since_tizen 2.4 }; } //namespace FilterMode diff --git a/dali/public-api/animation/alpha-function.h b/dali/public-api/animation/alpha-function.h index f9097c3..ff9b95a 100644 --- a/dali/public-api/animation/alpha-function.h +++ b/dali/public-api/animation/alpha-function.h @@ -33,7 +33,7 @@ namespace Dali * @{ */ -typedef float (*AlphaFunctionPrototype)(float progress); ///< Prototype of an alpha function +typedef float (*AlphaFunctionPrototype)(float progress); ///< Prototype of an alpha function @since_tizen 2.4 /** * @brief Alpha functions are used in animations to specify the rate of change of the animation parameter over time. @@ -52,24 +52,24 @@ public: */ enum BuiltinFunction { - DEFAULT, ///< Linear - LINEAR, ///< No transformation - REVERSE, ///< Reverse linear + DEFAULT, ///< Linear @since_tizen 2.4 + LINEAR, ///< No transformation @since_tizen 2.4 + REVERSE, ///< Reverse linear @since_tizen 2.4 - EASE_IN_SQUARE, ///< Speeds up and comes to a sudden stop (Square) - EASE_OUT_SQUARE, ///< Sudden start and slows to a gradual stop (Square) + EASE_IN_SQUARE, ///< Speeds up and comes to a sudden stop (Square) @since_tizen 2.4 + EASE_OUT_SQUARE, ///< Sudden start and slows to a gradual stop (Square) @since_tizen 2.4 - EASE_IN, ///< Speeds up and comes to a sudden stop (Cubic) - EASE_OUT, ///< Sudden start and slows to a gradual stop (Cubic) - EASE_IN_OUT, ///< Speeds up and slows to a gradual stop (Cubic) + EASE_IN, ///< Speeds up and comes to a sudden stop (Cubic) @since_tizen 2.4 + EASE_OUT, ///< Sudden start and slows to a gradual stop (Cubic) @since_tizen 2.4 + EASE_IN_OUT, ///< Speeds up and slows to a gradual stop (Cubic) @since_tizen 2.4 - EASE_IN_SINE, ///< Speeds up and comes to a sudden stop (sinusoidal) - EASE_OUT_SINE, ///< Sudden start and slows to a gradual stop (sinusoidal) - EASE_IN_OUT_SINE, ///< Speeds up and slows to a gradual stop (sinusoidal) + EASE_IN_SINE, ///< Speeds up and comes to a sudden stop (sinusoidal) @since_tizen 2.4 + EASE_OUT_SINE, ///< Sudden start and slows to a gradual stop (sinusoidal) @since_tizen 2.4 + EASE_IN_OUT_SINE, ///< Speeds up and slows to a gradual stop (sinusoidal) @since_tizen 2.4 - BOUNCE, ///< Sudden start, loses momentum and returns to start position - SIN, ///< Single revolution - EASE_OUT_BACK, ///< Sudden start, exceed end position and return to a gradual stop + BOUNCE, ///< Sudden start, loses momentum and returns to start position @since_tizen 2.4 + SIN, ///< Single revolution @since_tizen 2.4 + EASE_OUT_BACK, ///< Sudden start, exceed end position and return to a gradual stop @since_tizen 2.4 COUNT }; @@ -80,9 +80,9 @@ public: */ enum Mode { - BUILTIN_FUNCTION, //< The user has specified a built-in function - CUSTOM_FUNCTION, //< The user has provided a custom function - BEZIER //< The user has provided the control points of a bezier curve + BUILTIN_FUNCTION, ///< The user has specified a built-in function @since_tizen 2.4 + CUSTOM_FUNCTION, ///< The user has provided a custom function @since_tizen 2.4 + BEZIER ///< The user has provided the control points of a bezier curve @since_tizen 2.4 }; /** @@ -115,6 +115,7 @@ public: /** * @brief Constructor. + * * Creates a bezier alpha function. The bezier will have the first point at (0,0) and * the end point at (1,1). * @since_tizen 2.4 @@ -145,7 +146,7 @@ public: * @brief Returns the built0in function used by the alpha function * @since_tizen 2.4 * @return One of the built-in alpha functions. In case no built-in function - * has been specified, it will return AlphaFunction::DEfAULT + * has been specified, it will return AlphaFunction::DEFAULT */ BuiltinFunction GetBuiltinFunction() const; diff --git a/dali/public-api/animation/animation.h b/dali/public-api/animation/animation.h index a480ef2..5c0806f 100644 --- a/dali/public-api/animation/animation.h +++ b/dali/public-api/animation/animation.h @@ -94,29 +94,16 @@ class Animation; * * @endcode * - * If the "Finish" signal is connected to a member function of an object, it must be disconnected before the object is destroyed. - * This is typically done in the object destructor, and requires either the Dali::Connection object or Dali::Animation handle to be stored. * - * Signals - * | %Signal Name | Method | - * |--------------|--------------------------| - * | finished | @ref FinishedSignal() | - * - * Actions - * | %Action Name | %Animation method called | - * |--------------|--------------------------| - * | play | Play() | - * | stop | Stop() | - * | pause | Pause() | * @since_tizen 2.4 */ class DALI_IMPORT_API Animation : public BaseHandle { public: - typedef Signal< void (Animation&) > AnimationSignalType; ///< Animation finished signal type + typedef Signal< void (Animation&) > AnimationSignalType; ///< Animation finished signal type @since_tizen 2.4 - typedef Any AnyFunction; ///< Interpolation function + typedef Any AnyFunction; ///< Interpolation function @since_tizen 2.4 /** * @brief What to do when the animation ends, is stopped or is destroyed @@ -124,9 +111,9 @@ public: */ enum EndAction { - Bake, ///< When the animation ends, the animated property values are saved. - Discard, ///< When the animation ends, the animated property values are forgotten. - BakeFinal ///< If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Bake. + Bake, ///< When the animation ends, the animated property values are saved. @since_tizen 2.4 + Discard, ///< When the animation ends, the animated property values are forgotten. @since_tizen 2.4 + BakeFinal ///< If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Bake. @since_tizen 2.4 }; /** @@ -135,14 +122,15 @@ public: */ enum Interpolation { - Linear, ///< Values in between key frames are interpolated using a linear polynomial. (Default) - Cubic ///< Values in between key frames are interpolated using a cubic polynomial. + Linear, ///< Values in between key frames are interpolated using a linear polynomial. (Default) @since_tizen 2.4 + Cubic ///< Values in between key frames are interpolated using a cubic polynomial. @since_tizen 2.4 }; /** * @brief Create an uninitialized Animation; this can be initialized with Animation::New(). * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an unintialized Animation handle is not allowed. + * * @since_tizen 2.4 */ Animation(); @@ -156,19 +144,19 @@ public: * @since_tizen 2.4 * @param [in] durationSeconds The duration in seconds. * @return A handle to a newly allocated Dali resource. - * @pre durationSeconds must be greater than zero. + * @pre DurationSeconds must be greater than zero. */ static Animation New(float durationSeconds); /** - * @brief Downcast an Object handle to Animation. + * @brief Downcast a handle to Animation handle. * * If handle points to an Animation object the downcast produces * valid handle. If not the returned handle is left uninitialized. * * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a Animation object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a Animation object or an uninitialized handle */ static Animation DownCast( BaseHandle handle ); @@ -202,7 +190,7 @@ public: * * @since_tizen 2.4 * @param[in] seconds The duration in seconds. - * @pre durationSeconds must be greater than zero. + * @pre DurationSeconds must be greater than zero. */ void SetDuration(float seconds); @@ -285,8 +273,9 @@ public: /** * @brief Sets the progress of the animation. + * * The animation will play (or continue playing) from this point. The progress - * must be in the 0-1 interval or in the play range interval if defined ( See SetPlayRange ), + * must be in the 0-1 interval or in the play range interval if defined ( See @ref Animation::SetPlayRange ), * otherwise, it will be ignored. * * @since_tizen 2.4 @@ -319,12 +308,13 @@ public: * @brief Retrieve the speed factor of the animation * * @since_tizen 2.4 - * @return speed factor + * @return Speed factor */ float GetSpeedFactor() const; /** * @brief Set the playing range. + * * Animation will play between the values specified. Both values ( range.x and range.y ) should be between 0-1, * otherwise they will be ignored. If the range provided is not in proper order ( minimum,maximum ), it will be reordered. * @@ -350,7 +340,8 @@ public: /** * @brief Play the animation from a given point. - * The progress must be in the 0-1 interval or in the play range interval if defined ( See SetPlayRange ), + * + * The progress must be in the 0-1 interval or in the play range interval if defined ( See @ref Animation::SetPlayRange ), * otherwise, it will be ignored. * * @since_tizen 2.4 @@ -382,7 +373,7 @@ public: * @brief Connect to this signal to be notified when an Animation's animations have finished. * * @since_tizen 2.4 - * @return A signal object to Connect() with. + * @return A signal object to @ref Signal::Connect() with. */ AnimationSignalType& FinishedSignal(); @@ -487,8 +478,8 @@ public: * @brief Animate a property between keyframes. * * @since_tizen 2.4 - * @param [in] target The target object + property to animate - * @param [in] keyFrames The set of time / value pairs between which to animate. + * @param [in] target The target object/property to animate + * @param [in] keyFrames The set of time/value pairs between which to animate. * @param [in] interpolation The method used to interpolate between values. */ void AnimateBetween(Property target, KeyFrames& keyFrames, Interpolation interpolation); @@ -507,8 +498,8 @@ public: * @brief Animate a property between keyframes. * * @since_tizen 2.4 - * @param [in] target The target object + property to animate - * @param [in] keyFrames The set of time / value pairs between which to animate. + * @param [in] target The target object/property to animate + * @param [in] keyFrames The set of time/value pairs between which to animate. * @param [in] alpha The alpha function to apply. * @param [in] interpolation The method used to interpolate between values. */ @@ -528,8 +519,8 @@ public: * @brief Animate a property between keyframes. * * @since_tizen 2.4 - * @param [in] target The target object + property to animate - * @param [in] keyFrames The set of time / value pairs between which to animate. + * @param [in] target The target object/property to animate + * @param [in] keyFrames The set of time/value pairs between which to animate. * @param [in] period The effect will occur duing this time period. * @param [in] interpolation The method used to interpolate between values. */ @@ -550,8 +541,8 @@ public: * @brief Animate a property between keyframes. * * @since_tizen 2.4 - * @param [in] target The target object + property to animate - * @param [in] keyFrames The set of time / value pairs between which to animate. + * @param [in] target The target object/property to animate + * @param [in] keyFrames The set of time/value pairs between which to animate. * @param [in] alpha The alpha function to apply to the overall progress. * @param [in] period The effect will occur duing this time period. * @param [in] interpolation The method used to interpolate between values. @@ -562,7 +553,9 @@ public: // Actor-specific convenience methods /** - * @brief Animate an actor's position and orientation through a predefined path. The actor will rotate to orient the supplied + * @brief Animate an actor's position and orientation through a predefined path. + * + * The actor will rotate to orient the supplied * forward vector with the path's tangent. If forward is the zero vector then no rotation will happen. * * @since_tizen 2.4 @@ -573,7 +566,9 @@ public: void Animate( Actor actor, Path path, const Vector3& forward ); /** - * @brief Animate an actor's position and orientation through a predefined path. The actor will rotate to orient the supplied + * @brief Animate an actor's position and orientation through a predefined path. + * + * The actor will rotate to orient the supplied * forward vector with the path's tangent. If forward is the zero vector then no rotation will happen. * * @since_tizen 2.4 @@ -585,7 +580,9 @@ public: void Animate( Actor actor, Path path, const Vector3& forward, AlphaFunction alpha ); /** - * @brief Animate an actor's position and orientation through a predefined path. The actor will rotate to orient the supplied + * @brief Animate an actor's position and orientation through a predefined path. + * + * The actor will rotate to orient the supplied * forward vector with the path's tangent. If forward is the zero vector then no rotation will happen. * * @since_tizen 2.4 @@ -597,7 +594,9 @@ public: void Animate( Actor actor, Path path, const Vector3& forward, TimePeriod period ); /** - * @brief Animate an actor's position and orientation through a predefined path. The actor will rotate to orient the supplied + * @brief Animate an actor's position and orientation through a predefined path. + * + * The actor will rotate to orient the supplied * forward vector with the path's tangent. If forward is the zero vector then no rotation will happen. * * @since_tizen 2.4 @@ -630,7 +629,7 @@ public: public: // Not intended for use by Application developers /** - * @brief This constructor is used by Dali New() methods + * @brief This constructor is used by Animation::New() methods * @since_tizen 2.4 * @param [in] animation A pointer to a newly allocated Dali resource */ diff --git a/dali/public-api/animation/constraint-source.h b/dali/public-api/animation/constraint-source.h index c9c70fb..44395f3 100644 --- a/dali/public-api/animation/constraint-source.h +++ b/dali/public-api/animation/constraint-source.h @@ -37,9 +37,9 @@ namespace Dali */ enum SourceType { - OBJECT_PROPERTY, ///< The property comes from an arbitrary object. - LOCAL_PROPERTY, ///< The property comes from the object which the constraint is applied to. - PARENT_PROPERTY ///< The property comes from the parent of the object, which the constraint is applied to. + OBJECT_PROPERTY, ///< The property comes from an arbitrary object. @since_tizen 2.4 + LOCAL_PROPERTY, ///< The property comes from the object which the constraint is applied to. @since_tizen 2.4 + PARENT_PROPERTY ///< The property comes from the parent of the object, which the constraint is applied to. @since_tizen 2.4 }; diff --git a/dali/public-api/animation/constraint.h b/dali/public-api/animation/constraint.h index 9310f07..bff70fb 100644 --- a/dali/public-api/animation/constraint.h +++ b/dali/public-api/animation/constraint.h @@ -40,7 +40,7 @@ namespace Internal DALI_INTERNAL class ConstraintBase; } -typedef Vector< PropertyInput* > PropertyInputContainer; +typedef Vector< PropertyInput* > PropertyInputContainer; ///< Container for PropertyInput @since_tizen 2.4 /** * @brief An abstract base class for Constraints. @@ -283,8 +283,8 @@ public: */ enum RemoveAction { - Bake, ///< When the constraint is fully-applied, the constrained value is saved. - Discard ///< When the constraint is removed, the constrained value is discarded. + Bake, ///< When the constraint is fully-applied, the constrained value is saved. @since_tizen 2.4 + Discard ///< When the constraint is removed, the constrained value is discarded. @since_tizen 2.4 }; static const RemoveAction DEFAULT_REMOVE_ACTION; ///< Bake @@ -292,7 +292,8 @@ public: /** * @brief Create an uninitialized Constraint; this can be initialized with Constraint::New(). * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an uninitialized Constraint handle is not allowed. + * * @since_tizen 2.4 */ Constraint(); @@ -306,6 +307,7 @@ public: * @endcode * * Create the constraint with this function as follows: + * * @code * Constraint constraint = Constraint::New< Vector3 >( handle, CONSTRAINING_PROPERTY_INDEX, &MyFunction ); * @endcode @@ -337,6 +339,7 @@ public: * @endcode * * Create the constraint with this object as follows: + * * @code * Constraint constraint = Constraint::New< Vector3 >( handle, CONSTRAINING_PROPERTY_INDEX, MyObject() ); * @endcode @@ -369,6 +372,7 @@ public: * @endcode * * Create the constraint with this object as follows: + * * @code * Constraint constraint = Constraint::New< Vector3 >( handle, CONSTRAINING_PROPERTY_INDEX, MyObject(), &MyObject::MyMethod ); * @endcode @@ -426,13 +430,13 @@ public: Constraint& operator=( const Constraint& rhs ); /** - * @brief Downcast an Object handle to Constraint handle. + * @brief Downcast a handle to Constraint handle. * * If handle points to a Constraint object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] baseHandle to An object - * @return handle to a Constraint object or an uninitialized handle + * @param[in] baseHandle BaseHandle to an object + * @return Handle to a Constraint object or an uninitialized handle */ static Constraint DownCast( BaseHandle baseHandle ); @@ -491,7 +495,7 @@ public: * * Otherwise the constrained value will be discarded, when the constraint is removed. * @since_tizen 2.4 - * @return The apply-action. + * @return The remove-action. */ RemoveAction GetRemoveAction() const; @@ -514,7 +518,7 @@ public: public: // Not intended for use by Application developers /** - * @brief This constructor is used by Dali New() methods + * @brief This constructor is used by Constraint::New() methods * @since_tizen 2.4 * @param [in] constraint A pointer to a newly allocated Dali resource */ diff --git a/dali/public-api/animation/constraints.h b/dali/public-api/animation/constraints.h index 9953a34..b3791c7 100644 --- a/dali/public-api/animation/constraints.h +++ b/dali/public-api/animation/constraints.h @@ -35,9 +35,10 @@ namespace Dali */ /** - * @brief EqualToConstraint + * @brief The constraint function that updates the target property with the value of the first source. * - * f(current, property) = property + * @e current = input[0]. @e current and input[0] indicate the target property + * and the first constraint source (the one added by the first Constraint::AddSource call), respectively. * @since_tizen 2.4 */ struct EqualToConstraint @@ -50,12 +51,11 @@ struct EqualToConstraint { } /** - * @brief override functor for float properties + * @brief Override functor for float properties * * @since_tizen 2.4 * @param[in, out] current The current property value, the constrained value is set * @param[in] inputs Contains the property to copy - * @return The copy of the input property */ void operator()( float& current, const PropertyInputContainer& inputs ) { @@ -63,12 +63,11 @@ struct EqualToConstraint } /** - * @brief override functor for float properties + * @brief Override functor for float properties * * @since_tizen 2.4 * @param[in] current The current property value, the constrained value is set * @param[in] inputs Contains the property to copy - * @return The copy of the input property */ void operator()( Vector2& current, const PropertyInputContainer& inputs ) { @@ -76,12 +75,11 @@ struct EqualToConstraint } /** - * @brief override functor for float properties + * @brief Override functor for float properties * * @since_tizen 2.4 * @param[in,out] current The current property value, the constrained value is set * @param[in] inputs Contains the property to copy - * @return The copy of the input property */ void operator()( Vector3& current, const PropertyInputContainer& inputs ) { @@ -89,12 +87,11 @@ struct EqualToConstraint } /** - * @brief override functor for float properties + * @brief Override functor for float properties * * @since_tizen 2.4 * @param[in,out] current The current property value, the constrained value is set * @param[in] inputs Contains the property to copy - * @return The copy of the input property */ void operator()( Vector4& current, const PropertyInputContainer& inputs ) { @@ -102,12 +99,11 @@ struct EqualToConstraint } /** - * @brief override functor for float properties + * @brief Override functor for float properties * * @since_tizen 2.4 * @param[in,out] current The current property value, the constrained value is set * @param[in] inputs Contains the property to copy - * @return The copy of the input property */ void operator()( Quaternion& current, const PropertyInputContainer& inputs ) { @@ -115,12 +111,11 @@ struct EqualToConstraint } /** - * @brief override functor for float properties + * @brief Override functor for float properties * * @since_tizen 2.4 * @param[in,out] current The current property value * @param[in] inputs Contains the property to copy - * @return The copy of the input property */ void operator()( Matrix3& current, const PropertyInputContainer& inputs ) { @@ -128,12 +123,11 @@ struct EqualToConstraint } /** - * @brief override functor for float properties + * @brief Override functor for float properties * * @since_tizen 2.4 * @param[in,out] current The current property value, the constrained value is set * @param[in] inputs Contains the property to copy - * @return The copy of the input property */ void operator()( Matrix& current, const PropertyInputContainer& inputs ) { @@ -143,9 +137,12 @@ struct EqualToConstraint }; /** - * @brief RelativeToConstraint for Vector3 properties + * @brief The constraint function that updates the target property with the value of the first source + * multiplied by scale parameter (for Vector3 properties). * - * current = property * scale + * @e current = input[0] * @e scale. @e current, input[0], and @e scale + * indicate the target property, the first constraint source, and the scale parameter, respectively. + * * implies element-wise multiplication. * @since_tizen 2.4 */ struct RelativeToConstraint @@ -153,6 +150,7 @@ struct RelativeToConstraint /** * @brief Constructor. * @since_tizen 2.4 + * @param[in] scale Scale factor */ RelativeToConstraint( float scale ) : mScale( scale, scale, scale ) { } @@ -160,6 +158,7 @@ struct RelativeToConstraint /** * @brief Constructor. * @since_tizen 2.4 + * @param[in] scale Scale factor */ RelativeToConstraint( const Vector3& scale ) : mScale( scale ) { } @@ -167,6 +166,8 @@ struct RelativeToConstraint /** * @brief Functor. * @since_tizen 2.4 + * @param[in,out] current The current property value (vector3 property * scale factor). + * @param[in] input Property container for current property calculation */ void operator()( Vector3& current, const PropertyInputContainer& inputs ) { @@ -177,7 +178,11 @@ struct RelativeToConstraint }; /** - * @brief RelativeToConstraint for float properties + * @brief The constraint function that updates the target property with the value of the first source + * multiplied by scale parameter (for float properties). + * + * @e current = input[0] * @e scale. @e current, input[0], and @e scale + * indicate the target property, the first constraint source, and the scale parameter, respectively. * @since_tizen 2.4 */ struct RelativeToConstraintFloat @@ -185,6 +190,7 @@ struct RelativeToConstraintFloat /** * @brief Constructor. * @since_tizen 2.4 + * @param[in] scale Scale factor */ RelativeToConstraintFloat( float scale ) : mScale( scale ) { } @@ -192,6 +198,8 @@ struct RelativeToConstraintFloat /** * @brief Functor. * @since_tizen 2.4 + * @param[in,out] current The current property value (float property * scale factor). + * @param[in] input Property container for current property calculation */ void operator()( float& current, const PropertyInputContainer& inputs ) { @@ -211,10 +219,9 @@ struct RelativeToConstraintFloat * * @since_tizen 2.4 * @param[in,out] current The current orientation property value, the constrained value is set. - * @param[in] inputs Contains the World position of the target, the World position of the camera, and the world orientation of the target - * @return The orientation of the camera + * @param[in] inputs Contains the world position of the target, the world position of the camera, and the world orientation of the target */ -inline void LookAt( Quaternion& current, const PropertyInputContainer& inputs ) +inline void LookAt( Dali::Quaternion& current, const Dali::PropertyInputContainer& inputs ) { const PropertyInput& targetPosition( *inputs[0] ); const PropertyInput& cameraPosition( *inputs[1] ); diff --git a/dali/public-api/animation/key-frames.h b/dali/public-api/animation/key-frames.h index b5592b2..91ded11 100644 --- a/dali/public-api/animation/key-frames.h +++ b/dali/public-api/animation/key-frames.h @@ -49,29 +49,29 @@ class DALI_IMPORT_API KeyFrames : public BaseHandle { public: /** - * @brief Create an initialized KeyFrame handle. + * @brief Create an initialized KeyFrames handle. * * @since_tizen 2.4 - * @return a handle to a newly allocated Dali resource. + * @return A handle to a newly allocated Dali resource. */ static KeyFrames New(); /** - * @brief Downcast an Object handle to KeyFrames handle. + * @brief Downcast a handle to KeyFrames handle. * * If handle points to a KeyFrames object the downcast produces * valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a KeyFrames object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a KeyFrames object or an uninitialized handle */ static KeyFrames DownCast( BaseHandle handle ); /** * @brief Create an uninitialized KeyFrame handle. * - * This can be initialized with KeyFrame::New(). Calling member - * functions with an uninitialized Dali::Object is not allowed. + * This can be initialized with KeyFrame::New(). + * Calling member functions with an uninitialized KeyFrames handle is not allowed. * @since_tizen 2.4 */ KeyFrames(); @@ -134,7 +134,7 @@ public: public: // Not intended for application developers /** - * @brief This constructor is used by Dali::New() methods. + * @brief This constructor is used by KeyFrames::New() methods. * * @since_tizen 2.4 * @param[in] keyFrames A pointer to an internal KeyFrame resource diff --git a/dali/public-api/animation/linear-constrainer.h b/dali/public-api/animation/linear-constrainer.h index a68becd..663e54c 100644 --- a/dali/public-api/animation/linear-constrainer.h +++ b/dali/public-api/animation/linear-constrainer.h @@ -38,9 +38,8 @@ namespace Internal DALI_INTERNAL } /** - * @brief + * @brief LinearConstrainer applies constraints to objects given a linear map. * - * LinearConstrainer applies constraints to objects given a linear map. * A linear map is defined by a set of value-progress pairs. * Progress must be normalized between [0,1]. If no progress is defined, the values * are considered to be equally spaced along the x axis. @@ -58,8 +57,8 @@ public: { enum { - VALUE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "value" type Array of float - PROGRESS, ///< name "progress" type Array of float + VALUE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< type Array of float @since_tizen 2.4 + PROGRESS, ///< type Array of float @since_tizen 2.4 }; }; @@ -67,26 +66,26 @@ public: * @brief Create an initialized LinearConstrainer handle. * * @since_tizen 2.4 - * @return a handle to a newly allocated Dali resource. + * @return A handle to a newly allocated Dali resource. */ static LinearConstrainer New(); /** - * @brief Downcast an Object handle to LinearConstrainer handle. + * @brief Downcast a handle to LinearConstrainer handle. * * If handle points to a LinearConstrainer object the downcast produces * valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a LinearConstrainer object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a LinearConstrainer object or an uninitialized handle */ static LinearConstrainer DownCast( BaseHandle handle ); /** * @brief Create an uninitialized LinearConstrainer handle. * - * This can be initialized with PathConstrainer::New(). Calling member - * functions with an uninitialized Dali::Object is not allowed. + * This can be initialized with @ref PathConstrainer::New + * Calling member functions with an uninitialized LinearConstrainer handle is not allowed. * @since_tizen 2.4 */ LinearConstrainer(); @@ -123,7 +122,7 @@ public: * @param[in] target Property to be constrained * @param[in] source Property used as parameter for the path * @param[in] range The range of values in the source property which will be mapped to [0,1] - * @param[in] wrap Wrapping domain. Source property will be wrapped in the domain [wrap.x,wrap.y] before mapping to [0,1] + * @param[in] wrap Wrapping domain. Source property will be wrapped in the domain [wrap.x,wrap.y] before mapping to [0,1]. See cfloat.h for FLT_MAX */ void Apply( Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap = Vector2(-FLT_MAX, FLT_MAX) ); @@ -137,7 +136,7 @@ public: public: // Not intended for application developers /** - * @brief This constructor is used by Dali::New() methods. + * @brief This constructor is used by LinearConstrainer::New() methods. * * @since_tizen 2.4 * @param[in] pathConstrainer A pointer to an internal PathConstrainer resource diff --git a/dali/public-api/animation/path.h b/dali/public-api/animation/path.h index 66e63d3..80b2c3f 100644 --- a/dali/public-api/animation/path.h +++ b/dali/public-api/animation/path.h @@ -37,7 +37,7 @@ class Path; /** * @brief A 3D parametric curve * - * Paths can be used to animate position and orientation of actors using Dali::Animate( Actor, Path, ... ) + * Paths can be used to animate position and orientation of actors using @ref Dali::Animate( Actor, Path, ... ) * * @since_tizen 2.4 */ @@ -53,8 +53,8 @@ public: { enum { - POINTS = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "points", type Vector3 - CONTROL_POINTS, ///< name "control-points", type Vector3 + POINTS = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< type Vector3 @since_tizen 2.4 + CONTROL_POINTS, ///< type Vector3 @since_tizen 2.4 }; }; @@ -62,26 +62,26 @@ public: * @brief Create an initialized Path handle. * * @since_tizen 2.4 - * @return a handle to a newly allocated Dali resource. + * @return A handle to a newly allocated Dali resource. */ static Path New(); /** - * @brief Downcast an Object handle to Path handle. + * @brief Downcast a handle to Path handle. * * If handle points to a KeyFrames object the downcast produces * valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a Path object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a Path object or an uninitialized handle */ static Path DownCast( BaseHandle handle ); /** * @brief Create an uninitialized Path handle. * - * This can be initialized with Path::New(). Calling member - * functions with an uninitialized Dali::Object is not allowed. + * This can be initialized with Path::New(). + * Calling member functions with an uninitialized Path handle is not allowed. * @since_tizen 2.4 */ Path(); @@ -185,7 +185,7 @@ public: public: // Not intended for application developers /** - * @brief This constructor is used by Dali::New() methods. + * @brief This constructor is used by Path::New() methods. * * @since_tizen 2.4 * @param[in] path A pointer to an internal path resource diff --git a/dali/public-api/common/compile-time-assert.h b/dali/public-api/common/compile-time-assert.h index e2f9c7b..d39e30a 100644 --- a/dali/public-api/common/compile-time-assert.h +++ b/dali/public-api/common/compile-time-assert.h @@ -31,10 +31,10 @@ namespace Dali * @{ */ -template struct CompileTimeAssertBool; ///< Bool Template to test condition -template <> struct CompileTimeAssertBool {}; ///< Specialize for true, but not for false +template struct CompileTimeAssertBool; ///< Bool Template to test condition @since_tizen 2.4 +template <> struct CompileTimeAssertBool {}; ///< Specialize for true, but not for false @since_tizen 2.4 -template struct CompileTimeAssertInt {}; ///< Template to wrap conditional template CompileTimeAsserBool +template struct CompileTimeAssertInt {}; ///< Template to wrap conditional template CompileTimeAsserBool @since_tizen 2.4 /** * @brief Use DALI_COMPILE_TIME_ASSERT to test expressions at compile time. diff --git a/dali/public-api/common/dali-common.h b/dali/public-api/common/dali-common.h index f54b4a9..fc27f6d 100644 --- a/dali/public-api/common/dali-common.h +++ b/dali/public-api/common/dali-common.h @@ -108,8 +108,8 @@ public: * Will always display a backtrace when raised in a debug build. * * @since_tizen 2.4 - * @param[in] location - the location of the assertion - * @param[in] condition - The assertion condition + * @param[in] location The location of the assertion + * @param[in] condition The assertion condition */ DaliException( const char* location, const char* condition ); diff --git a/dali/public-api/common/dali-vector.h b/dali/public-api/common/dali-vector.h index cbdb4a3..c253193 100644 --- a/dali/public-api/common/dali-vector.h +++ b/dali/public-api/common/dali-vector.h @@ -54,7 +54,7 @@ namespace Dali * @brief Base class to handle the memory of simple vector. * * Memory layout is such that it has two std::size_t to hold the count - * and capacity of the vector. mData is adjusted so that it points to the + * and capacity of the vector. VectorBase::mData is adjusted so that it points to the * beginning of the first real item so that iterating the items is quick. * @since_tizen 2.4 */ @@ -62,7 +62,7 @@ class DALI_IMPORT_API VectorBase { public: // Typedefs - typedef std::size_t SizeType; + typedef std::size_t SizeType; ///< Size type @since_tizen 2.4 protected: // Construction @@ -85,7 +85,7 @@ protected: // Construction public: // API /** - * @brief This method is inlined as its needed frequently for End() iterator. + * @brief This method is inlined as its needed frequently for Vector::End() iterator. * * @since_tizen 2.4 * @return The count of elements in this vector. @@ -132,7 +132,7 @@ protected: // for Derived classes * @brief Helper to set the count. * * @since_tizen 2.4 - * @param count Number of elements in the vector. + * @param[in] count Number of elements in the vector. */ void SetCount( SizeType count ); @@ -140,8 +140,8 @@ protected: // for Derived classes * @brief Reserve space in the vector. * * @since_tizen 2.4 - * @param count of elements to reserve. - * @param elementSize of a single element. + * @param[in] count Count of elements to reserve. + * @param[in] elementSize Size of a single element. */ void Reserve( SizeType count, SizeType elementSize ); @@ -149,8 +149,8 @@ protected: // for Derived classes * @brief Copy a vector. * * @since_tizen 2.4 - * @param vector Vector to copy from. - * @param elementSize of a single element. + * @param[in] vector Vector to copy from. + * @param[in] elementSize Size of a single element. */ void Copy( const VectorBase& vector, SizeType elementSize ); @@ -158,7 +158,7 @@ protected: // for Derived classes * @brief Swap the contents of two vectors. * * @since_tizen 2.4 - * @param vector Vector to swap with. + * @param[in] vector Vector to swap with. */ void Swap( VectorBase& vector ); @@ -167,9 +167,9 @@ protected: // for Derived classes * * Does not change capacity. * @since_tizen 2.4 - * @param address to erase from. - * @param elementSize to erase. - * @pre last element cannot be erased as there is nothing to move. + * @param[in] address Adress to erase from. + * @param[in] elementSize Size to erase. + * @pre Last element cannot be erased as there is nothing to move. */ void Erase( char* address, SizeType elementSize ); @@ -181,7 +181,7 @@ protected: // for Derived classes * @param[in] first Address to the first element to be erased. * @param[in] last Address to the last element to be erased. * @param[in] elementSize Size of one of the elements to be erased. - * @return address pointing to the next element of the last one. + * @return Address pointing to the next element of the last one. */ char* Erase( char* first, char* last, SizeType elementSize ); @@ -200,8 +200,8 @@ protected: // for Derived classes private: // not copiable as it does not know the size of elements - VectorBase( const VectorBase& ); ///< Undefined - VectorBase& operator=( const VectorBase& ); ///< Undefined + VectorBase( const VectorBase& ); ///< Undefined @since_tizen 2.4 + VectorBase& operator=( const VectorBase& ); ///< Undefined @since_tizen 2.4 protected: // Data @@ -220,7 +220,7 @@ class VectorAlgorithms : public VectorBase { protected: // API for deriving classes - typedef VectorBase::SizeType SizeType; + typedef VectorBase::SizeType SizeType; ///< Size type @since_tizen 2.4 /** * @brief Empty constructor. @@ -240,8 +240,8 @@ protected: // API for deriving classes * @brief Copy vector contents. * * @since_tizen 2.4 - * @param rhs to copy from. - * @param elementSize of the content. + * @param[in] rhs VectorBase object to copy from. + * @param[in] elementSize Size of the content. */ void Copy( const VectorBase& rhs, SizeType elementSize ) { @@ -259,8 +259,8 @@ protected: // API for deriving classes * @brief Reserve space in the vector. * * @since_tizen 2.4 - * @param count of elements to reserve. - * @param elementSize of a single element. + * @param[in] count Count of elements to reserve. + * @param[in] elementSize Size of a single element. */ void Reserve( SizeType count, SizeType elementSize ) { @@ -271,8 +271,8 @@ protected: // API for deriving classes * @brief Resize the vector. Does not change capacity. * * @since_tizen 2.4 - * @param count to resize to. - * @param elementSize of a single element. + * @param[in] count Count to resize to. + * @param[in] elementSize Size of a single element. */ void Resize( SizeType count, SizeType elementSize ) { @@ -307,8 +307,8 @@ protected: // API for deriving classes * @brief Erase an element. Does not change capacity. * * @since_tizen 2.4 - * @param address to erase from. - * @param elementSize to erase. + * @param[in] address Address to erase from. + * @param[in] elementSize Size to erase. */ void Erase( char* address, SizeType elementSize ) { @@ -322,7 +322,7 @@ protected: // API for deriving classes * @param[in] first Address to the first element to be erased. * @param[in] last Address to the last element to be erased. * @param[in] elementSize Size of one of the elements to be erased. - * @return address pointing to the next element of the last one. + * @return Address pointing to the next element of the last one. */ char* Erase( char* first, char* last, SizeType elementSize ) { @@ -390,7 +390,7 @@ private: * @brief Vector class with minimum space allocation when its empty. * * @since_tizen 2.4 - * @param type of the data that the vector holds. + * @param[in] type of the data that the vector holds. */ template< class T, bool IsTrivialType = TypeTraits::IS_TRIVIAL_TYPE == true > class Vector : public VectorAlgorithms< IsTrivialType > @@ -401,10 +401,10 @@ public: // API * @brief Type definitions. * @since_tizen 2.4 */ - typedef VectorBase::SizeType SizeType; - typedef T* Iterator; ///< Most simple Iterator is a pointer - typedef const T* ConstIterator; - typedef T ItemType; + typedef VectorBase::SizeType SizeType; ///< Size type @since_tizen 2.4 + typedef T* Iterator; ///< Most simple Iterator is a pointer @since_tizen 2.4 + typedef const T* ConstIterator; ///< Const iterator @since_tizen 2.4 + typedef T ItemType; ///< Item type @since_tizen 2.4 enum { @@ -431,7 +431,7 @@ public: // API * @brief Copy constructor. * * @since_tizen 2.4 - * @param vector Vector to copy from. + * @param[in] vector Vector to copy from. */ Vector( const Vector& vector ) { @@ -443,8 +443,8 @@ public: // API * @brief Assignment operator. * * @since_tizen 2.4 - * @param vector Vector to assign from. - * @return reference to self for chaining. + * @param[in] vector Vector to assign from. + * @return Reference to self for chaining. */ Vector& operator=( const Vector& vector ) { @@ -481,9 +481,9 @@ public: // API /** * @brief Subscript operator. * @since_tizen 2.4 - * @param index of the element. - * @return reference to the element for given index. - * @pre index must be in the vector's range. + * @param[in] index Index of the element. + * @return Reference to the element for given index. + * @pre Index must be in the vector's range. */ ItemType& operator[]( SizeType index ) { @@ -494,7 +494,7 @@ public: // API /** * @brief Subscript operator. * @since_tizen 2.4 - * @param index of the element. + * @param[in] index of the element. * @return reference to the element for given index. * @pre index must be in the vector's range. */ @@ -515,7 +515,7 @@ public: // API * become invalid. * * @since_tizen 2.4 - * @param[in] element to be added. + * @param[in] element Element to be added. */ void PushBack( const ItemType& element ) { @@ -544,7 +544,7 @@ public: // API * @pre Iterator at must be in the vector's range ( Vector::Begin(), Vector::End() ). * * @param[in] at Iterator where to insert the elements into the vector. - * @param[in] element to be added. + * @param[in] element An element to be added. *@since_tizen 2.4 */ void Insert( Iterator at, const ItemType& element ) @@ -598,7 +598,7 @@ public: // API * * Reserving less than current Capacity is a no-op. * @since_tizen 2.4 - * @param count of elements to reserve. + * @param[in] count Count of elements to reserve. */ void Reserve( SizeType count ) { @@ -609,8 +609,8 @@ public: // API * @brief Resize the vector. Does not change capacity. * * @since_tizen 2.4 - * @param count to resize to. - * @param item to insert to the new indices. + * @param[in] count Count to resize to. + * @param[in] item An item to insert to the new indices. */ void Resize( SizeType count, ItemType item = ItemType() ) { @@ -638,7 +638,7 @@ public: // API * Does not change capacity. Other elements get moved. * * @since_tizen 2.4 - * @param iterator Iterator pointing to item to remove. + * @param[in] iterator Iterator pointing to item to remove. * @return Iterator pointing to next element. * @pre Iterator \e iterator must be within the vector's range ( Vector::Begin(), Vector::End() - 1 ). * @@ -705,7 +705,7 @@ public: // API * this in case order does not matter. Does not change capacity. * * @since_tizen 2.4 - * @param iterator Iterator pointing to item to remove. + * @param[in] iterator Iterator pointing to item to remove. * @pre Iterator \e iterator must be in the vector's range ( Vector::Begin(), Vector::End() - 1 ). * */ @@ -725,7 +725,7 @@ public: // API * @brief Swap the contents of two vectors. * * @since_tizen 2.4 - * @param vector Vector to swap with. + * @param[in] vector Vector to swap with. */ void Swap( Vector& vector ) { diff --git a/dali/public-api/common/intrusive-ptr.h b/dali/public-api/common/intrusive-ptr.h index 7584197..06a8268 100644 --- a/dali/public-api/common/intrusive-ptr.h +++ b/dali/public-api/common/intrusive-ptr.h @@ -31,8 +31,8 @@ namespace Dali /** * @brief Templated intrusive pointer class * - * Uses the Dali:Refobject type supply actual reference counting - * The object is responsible for destroying itself + * Uses the Dali:RefObject type with actual reference counting. + * The object is responsible for destroying itself. * @since_tizen 2.4 */ template @@ -51,7 +51,7 @@ public: * @brief Constructor to attach existing object. * * @since_tizen 2.4 - * @param p pointer to object, + * @param[i] p Pointer to object, */ IntrusivePtr( T* p ) : mPtr( p ) { @@ -65,8 +65,8 @@ public: * @brief Copy constructor. * * @since_tizen 2.4 - * @param rhs const reference to an IntrusivePtr - * @tparam U reference counter object type + * @param[i] rhs Const reference to an IntrusivePtr + * @tparam U Reference counter object type */ template IntrusivePtr( IntrusivePtr const& rhs ) : mPtr( rhs.Get() ) @@ -107,7 +107,7 @@ public: * @brief Get pointer to reference counted object. * * @since_tizen 2.4 - * @return pointer to reference counted object + * @return Pointer to reference counted object */ T* Get() const { @@ -118,7 +118,7 @@ public: * @brief Pointer operator override. * * @since_tizen 2.4 - * @return pointer to reference counted object + * @return Pointer to reference counted object */ T* operator->() const { @@ -129,7 +129,7 @@ public: * @brief Dereference operator override. * * @since_tizen 2.4 - * @return reference to reference counted object + * @return Reference to reference counted object */ T& operator*() const { @@ -140,8 +140,8 @@ public: * @brief Assignment operator. * * @since_tizen 2.4 - * @param rhs const reference to intrusive pointer - * @return reference to reference counted object + * @param rhs Const reference to intrusive pointer + * @return Reference to reference counted object */ IntrusivePtr& operator=( IntrusivePtr const& rhs ) { @@ -153,8 +153,8 @@ public: * @brief Assignment operator. * * @since_tizen 2.4 - * @param rhs pointer to object to wrap - * @return A reference to this object + * @param rhs Pointer to object to wrap + * @return A Reference to this object */ IntrusivePtr& operator=( T* rhs ) { @@ -175,7 +175,7 @@ public: * @brief Reset intrusive pointer with reference counted object. * * @since_tizen 2.4 - * @param rhs pointer to object + * @param[i] rhs Pointer to object */ void Reset( T* rhs ) { @@ -241,9 +241,9 @@ private: * @brief Comparison overrides of objects wrapped by intrusive pointers. * * @since_tizen 2.4 - * @param lhs intrusive pointer to compare with - * @param rhs intrusive pointer to compare against - * @return true if the pointers point at the same object + * @param[i] lhs Intrusive pointer to compare with + * @param[i] rhs Intrusive pointer to compare against + * @return True if the pointers point at the same object */ template inline bool operator==( IntrusivePtrconst& lhs, IntrusivePtrconst& rhs ) @@ -255,9 +255,9 @@ inline bool operator==( IntrusivePtrconst& lhs, IntrusivePtrconst& rhs ) * @brief Comparison overrides of objects wrapped by intrusive pointers. * * @since_tizen 2.4 - * @param lhs intrusive pointer to compare with - * @param rhs intrusive pointer to compare against - * @return true if the pointers point at different objects + * @param[i] lhs Intrusive pointer to compare with + * @param[i] rhs Intrusive pointer to compare against + * @return True if the pointers point at different objects */ template inline bool operator!=( IntrusivePtrconst& lhs, IntrusivePtrconst &rhs) @@ -269,9 +269,9 @@ inline bool operator!=( IntrusivePtrconst& lhs, IntrusivePtrconst &rhs) * @brief Comparison overrides of objects wrapped by intrusive pointers * * @since_tizen 2.4 - * @param lhs intrusive pointer to compare with - * @param rhs object to compare against - * @return true if the intrusive pointer points at the specified object + * @param[i] lhs Intrusive pointer to compare with + * @param[i] rhs Object to compare against + * @return True if the intrusive pointer points at the specified object */ template inline bool operator==( IntrusivePtrconst& lhs, U* rhs ) @@ -283,9 +283,9 @@ inline bool operator==( IntrusivePtrconst& lhs, U* rhs ) * @brief Comparison overrides of objects wrapped by intrusive pointers. * * @since_tizen 2.4 - * @param lhs intrusive pointer to compare with - * @param rhs intrusive pointer to compare against - * @return true if the intrusive pointer doesn't point at the specified object + * @param[i] lhs Intrusive pointer to compare with + * @param[i] rhs Intrusive pointer to compare against + * @return True if the intrusive pointer doesn't point at the specified object */ template inline bool operator!=( IntrusivePtrconst& lhs, U* rhs ) @@ -297,9 +297,9 @@ inline bool operator!=( IntrusivePtrconst& lhs, U* rhs ) * @brief Comparison overrides of objects wrapped by intrusive pointers * * @since_tizen 2.4 - * @param lhs object to compare with - * @param rhs intrusive pointer to compare against - * @return true if the intrusive pointer points at the specified object + * @param[i] lhs Object to compare with + * @param[i] rhs Intrusive pointer to compare against + * @return True if the intrusive pointer points at the specified object */ template inline bool operator==( T* lhs, IntrusivePtrconst& rhs ) @@ -311,9 +311,9 @@ inline bool operator==( T* lhs, IntrusivePtrconst& rhs ) * @brief Comparison overrides of objects wrapped by intrusive pointers * * @since_tizen 2.4 - * @param lhs object to compare with - * @param rhs intrusive pointer to compare against - * @return true if the intrusive pointer doesn't point at the specified object + * @param[i] lhs Object to compare with + * @param[i] rhs Intrusive pointer to compare against + * @return True if the intrusive pointer doesn't point at the specified object */ template inline bool operator!=( T* lhs, IntrusivePtrconst& rhs ) diff --git a/dali/public-api/common/loading-state.h b/dali/public-api/common/loading-state.h index 4500653..445e847 100644 --- a/dali/public-api/common/loading-state.h +++ b/dali/public-api/common/loading-state.h @@ -34,9 +34,9 @@ namespace Dali */ enum LoadingState { - ResourceLoading, ///< The resource is loading - ResourceLoadingSucceeded, ///< The resource loaded successfully - ResourceLoadingFailed ///< The resource failed to load + ResourceLoading, ///< The resource is loading @since_tizen 2.4 + ResourceLoadingSucceeded, ///< The resource loaded successfully @since_tizen 2.4 + ResourceLoadingFailed ///< The resource failed to load @since_tizen 2.4 }; /** diff --git a/dali/public-api/common/stage.h b/dali/public-api/common/stage.h index 7e1c6ac..84e6940 100644 --- a/dali/public-api/common/stage.h +++ b/dali/public-api/common/stage.h @@ -50,28 +50,18 @@ struct WheelEvent; * * Multiple stage/window support is not currently provided. * - * Signals - * | %Signal Name | Method | - * |---------------------------|--------------------------------------| - * | key-event | @ref KeyEventSignal() | - * | event-processing-finished | @ref EventProcessingFinishedSignal() | - * | touched | @ref TouchedSignal() | - * | wheel-event | @ref WheelEventSignal() | - * | context-lost | @ref ContextLostSignal() | - * | context-regained | @ref ContextRegainedSignal() | - * | scene-created | @ref SceneCreatedSignal() | * @since_tizen 2.4 */ class DALI_IMPORT_API Stage : public BaseHandle { public: - typedef Signal< void (const KeyEvent&)> KeyEventSignalType; ///< Key event signal type - typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type - typedef Signal< void (const TouchEvent&)> TouchedSignalType; ///< Touched signal type - typedef Signal< void (const WheelEvent&)> WheelEventSignalType; ///< Touched signal type - typedef Signal< void () > ContextStatusSignal; ///< Context status signal type - typedef Signal< void () > SceneCreatedSignalType; ///< Scene created signal type + typedef Signal< void (const KeyEvent&)> KeyEventSignalType; ///< Key event signal type @since_tizen 2.4 + typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type @since_tizen 2.4 + typedef Signal< void (const TouchEvent&)> TouchedSignalType; ///< Touched signal type @since_tizen 2.4 + typedef Signal< void (const WheelEvent&)> WheelEventSignalType; ///< Touched signal type @since_tizen 2.4 + typedef Signal< void () > ContextStatusSignal; ///< Context status signal type @since_tizen 2.4 + typedef Signal< void () > SceneCreatedSignalType; ///< Scene created signal type @since_tizen 2.4 static const Vector4 DEFAULT_BACKGROUND_COLOR; ///< Default black background. static const Vector4 DEBUG_BACKGROUND_COLOR; ///< Green background, useful when debugging. @@ -88,7 +78,7 @@ public: * @brief Get the current Stage. * * @since_tizen 2.4 - * @return The current stage or an empty handle if Core has not been created or has been already destroyed. + * @return The current stage or an empty handle if the internal core has not been created or has been already destroyed. */ static Stage GetCurrent(); @@ -186,7 +176,7 @@ public: * @since_tizen 2.4 * @param[in] depth The depth. * @return The layer found at the given depth. - * @pre depth is less than layer count; see GetLayerCount(). + * @pre Depth is less than layer count; see GetLayerCount(). */ Layer GetLayer(unsigned int depth) const; @@ -220,7 +210,7 @@ public: * @brief Retrieve the DPI of the display device to which the stage is connected. * * @since_tizen 2.4 - * @return the horizontal and vertical DPI + * @return The horizontal and vertical DPI */ Vector2 GetDpi() const; @@ -240,7 +230,7 @@ public: * By default Dali will stop rendering when no Actor positions are being set, and when no animations are running etc. * This method is useful to force screen refreshes e.g. when updating a NativeImage. * @since_tizen 2.4 - * @param durationSeconds to keep rendering, 0 means render at least one more frame + * @param[i] durationSeconds Time to keep rendering, 0 means render at least one more frame */ void KeepRendering( float durationSeconds ); @@ -302,7 +292,7 @@ public: * If the application is responsible for handling context loss, it should listen to * this signal and tear down UI components when recieved. * @since_tizen 2.4 - * @return The ContextLost signal to connect to. + * @return The context lost signal to connect to. */ ContextStatusSignal& ContextLostSignal(); @@ -313,12 +303,14 @@ public: * If the application is responsible for handling context loss, it should listen to * this signal and rebuild UI components on receipt. * @since_tizen 2.4 - * @return The ContextRegained signal to connect to. + * @return The context regained signal to connect to. */ ContextStatusSignal& ContextRegainedSignal(); /** - * @brief This signal is emitted after the initial scene is created. It will be triggered after the + * @brief This signal is emitted after the initial scene is created. + * + * It will be triggered after the * application init signal. * * A callback of the following type may be connected: @@ -333,7 +325,7 @@ public: public: // Not intended for application developers /** - * @brief This constructor is used by Dali GetCurrent() methods. + * @brief This constructor is used by Stage::GetCurrent() methods. * * @since_tizen 2.4 * @param [in] stage A pointer to a Dali resource diff --git a/dali/public-api/common/type-traits.h b/dali/public-api/common/type-traits.h index 6342b3a..14f944b 100644 --- a/dali/public-api/common/type-traits.h +++ b/dali/public-api/common/type-traits.h @@ -26,30 +26,39 @@ namespace Dali */ /** - * @brief Basic type traits that every type has by default - * This allows specialisations to not have to repeat all flags + * @brief Basic type traits that every type has by default. + * + * This allows specializations to not have to repeat all flags * @since_tizen 2.4 */ template struct BasicTypes { /** - * This flag tells Dali if a class can be considered POD. If it declares copy constructor and/or destructor, its not considered trivial + * @brief This flag tells Dali if a class can be considered POD. + * + * If it declares copy constructor and/or destructor, its not considered trivial * and cannot be copied by using memcpy etc. + * @since_tizen 2.4 */ enum { IS_TRIVIAL_TYPE = __has_trivial_destructor(Type) && __has_trivial_copy(Type) }; }; /** - * @brief Type traits support + * @brief Type traits. + * * An example of overriding a traits flag for a custom type can be done by: - * + * + * @code + * * namespace Dali * { - * /// Tell DALi that Matrix is POD, even though it has a copy constructor - * template <> struct TypeTraits< Matrix > : public BasicTypes< Matrix > { enum { IS_TRIVIAL_TYPE = true }; }; + * /// Tell DALi that Dali::Matrix is POD, even though it has a copy constructor + * template <> struct TypeTraits< Dali::Matrix > : public BasicTypes< Dali::Matrix > { enum { IS_TRIVIAL_TYPE = true }; }; * } - * + * + * @endcode + * * @since_tizen 2.4 */ template diff --git a/dali/public-api/common/view-mode.h b/dali/public-api/common/view-mode.h index 17edbd9..427f1e8 100644 --- a/dali/public-api/common/view-mode.h +++ b/dali/public-api/common/view-mode.h @@ -31,10 +31,10 @@ namespace Dali */ enum ViewMode { - MONO, ///< Monoscopic (single camera). This is the default - STEREO_HORIZONTAL, ///< Stereoscopic. Frame buffer is split horizontally with the left and right camera views in their respective sides. - STEREO_VERTICAL, ///< Stereoscopic. Frame buffer is split vertically with the left camera view at the top and the right camera view at the bottom. - STEREO_INTERLACED ///< Stereoscopic. Left/Right camera views are rendered into the framebuffer on alternate frames. + MONO, ///< Monoscopic (single camera). This is the default @since_tizen 2.4 + STEREO_HORIZONTAL, ///< Stereoscopic. Frame buffer is split horizontally with the left and right camera views in their respective sides. @since_tizen 2.4 + STEREO_VERTICAL, ///< Stereoscopic. Frame buffer is split vertically with the left camera view at the top and the right camera view at the bottom. @since_tizen 2.4 + STEREO_INTERLACED ///< Stereoscopic. Left/Right camera views are rendered into the framebuffer on alternate frames. @since_tizen 2.4 }; /** diff --git a/dali/public-api/events/gesture-detector.h b/dali/public-api/events/gesture-detector.h index 1171917..37bb00e 100644 --- a/dali/public-api/events/gesture-detector.h +++ b/dali/public-api/events/gesture-detector.h @@ -53,21 +53,23 @@ class DALI_IMPORT_API GestureDetector : public Handle public: // Creation & Destruction /** - * @brief Create an uninitialized GestureDetector; this can be initialized with one of the derived gestures' New() methods. + * @brief Create an uninitialized GestureDetector. * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * This can be initialized with one of the derived gesture detectors' New() methods. For example, PanGestureDetector::New(). + * + * Calling member functions with an uninitialized Dali::GestureDetector handle is not allowed. * @since_tizen 2.4 */ GestureDetector(); /** - * @brief Downcast an Object handle to GestureDetector handle. + * @brief Downcast a handle to GestureDetector handle. * * If handle points to a GestureDetector object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a GestureDetector object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a GestureDetector object or an uninitialized handle */ static GestureDetector DownCast( BaseHandle handle ); @@ -150,7 +152,7 @@ public: // Actor related protected: /** - * @brief This constructor is used by Dali New() methods of derived classes. + * @brief This constructor is used by New() methods of derived classes (For example, PanGestureDetector::New()). * * @since_tizen 2.4 * @param [in] internal A pointer to a newly allocated Dali resource. diff --git a/dali/public-api/events/gesture.h b/dali/public-api/events/gesture.h index 68ec415..0e89d41 100644 --- a/dali/public-api/events/gesture.h +++ b/dali/public-api/events/gesture.h @@ -48,12 +48,15 @@ struct DALI_IMPORT_API Gesture /** * @brief Copy constructor. * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle */ Gesture( const Gesture& rhs ); /** * @brief Assignment operator. * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle + * @return A reference to this */ Gesture& operator=( const Gesture& rhs ); @@ -71,10 +74,10 @@ struct DALI_IMPORT_API Gesture */ enum Type { - Pinch = 1 << 0, ///< When two touch points move away or towards each other. - Pan = 1 << 1, ///< When the user drags their finger(s) in a particular direction. - Tap = 1 << 2, ///< When the user taps the screen. - LongPress = 1 << 3 ///< When the user continues to touch the same area on the screen for the device configured time. + Pinch = 1 << 0, ///< When two touch points move away or towards each other. @since_tizen 2.4 + Pan = 1 << 1, ///< When the user drags their finger(s) in a particular direction. @since_tizen 2.4 + Tap = 1 << 2, ///< When the user taps the screen. @since_tizen 2.4 + LongPress = 1 << 3 ///< When the user continues to touch the same area on the screen for the device configured time. @since_tizen 2.4 }; /** @@ -83,12 +86,12 @@ struct DALI_IMPORT_API Gesture */ enum State { - Clear, ///< There is no state associated with this gesture. - Started, ///< The touched points on the screen have moved enough to be considered a gesture. - Continuing, ///< The gesture is continuing. - Finished, ///< The user has lifted a finger or touched an additional point on the screen. - Cancelled, ///< The gesture has been cancelled. - Possible ///< A gesture is possible. + Clear, ///< There is no state associated with this gesture. @since_tizen 2.4 + Started, ///< The touched points on the screen have moved enough to be considered a gesture. @since_tizen 2.4 + Continuing, ///< The gesture is continuing. @since_tizen 2.4 + Finished, ///< The user has lifted a finger or touched an additional point on the screen. @since_tizen 2.4 + Cancelled, ///< The gesture has been cancelled. @since_tizen 2.4 + Possible ///< A gesture is possible. @since_tizen 2.4 }; // Data diff --git a/dali/public-api/events/key-event.h b/dali/public-api/events/key-event.h index c9b855d..c9a1372 100644 --- a/dali/public-api/events/key-event.h +++ b/dali/public-api/events/key-event.h @@ -42,7 +42,7 @@ namespace Dali * pressed. * * Currently KeyEvent is also being used to relay messages from the - * IMF keyboard to Core. In future IMF may communicate via its own + * IMF keyboard to the internal core. In future IMF may communicate via its own * module. * @since_tizen 2.4 */ @@ -56,8 +56,8 @@ struct DALI_IMPORT_API KeyEvent */ enum State { - Down, ///< Key down - Up, ///< Key up + Down, ///< Key down @since_tizen 2.4 + Up, ///< Key up @since_tizen 2.4 Last }; @@ -90,7 +90,7 @@ struct DALI_IMPORT_API KeyEvent * @brief Check to see if Shift key modifier has been supplied. * * @since_tizen 2.4 - * @return bool true if shift modifier + * @return Bool true if shift modifier */ bool IsShiftModifier() const; @@ -98,7 +98,7 @@ struct DALI_IMPORT_API KeyEvent * @brief Check to see if Ctrl (control) key modifier has been supplied. * * @since_tizen 2.4 - * @return bool true if ctrl modifier + * @return Bool true if ctrl modifier */ bool IsCtrlModifier() const; @@ -106,7 +106,7 @@ struct DALI_IMPORT_API KeyEvent * @brief Check to see if Alt key modifier has been supplied. * * @since_tizen 2.4 - * @return bool true if alt modifier + * @return Bool true if alt modifier */ bool IsAltModifier() const; diff --git a/dali/public-api/events/long-press-gesture-detector.h b/dali/public-api/events/long-press-gesture-detector.h index 6c38785..7e58f10 100644 --- a/dali/public-api/events/long-press-gesture-detector.h +++ b/dali/public-api/events/long-press-gesture-detector.h @@ -54,23 +54,19 @@ struct LongPressGesture; * * @see LongPressGesture * - * Signals - * | %Signal Name | Method | - * |---------------------|-----------------------| - * | long-press-detected | @ref DetectedSignal() | */ class DALI_IMPORT_API LongPressGestureDetector : public GestureDetector { public: // Typedefs - typedef Signal< void ( Actor, const LongPressGesture& ) > DetectedSignalType; ///< Gesture detected signal type + typedef Signal< void ( Actor, const LongPressGesture& ) > DetectedSignalType; ///< Gesture detected signal type @since_tizen 2.4 public: // Creation & Destruction /** * @brief Create an uninitialized LongPressGestureDetector; this can be initialized with LongPressGestureDetector::New(). * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an uninitialized LongPressGestureDetector handle is not allowed. * @since_tizen 2.4 */ LongPressGestureDetector(); @@ -108,13 +104,13 @@ public: // Creation & Destruction static LongPressGestureDetector New(unsigned int minTouches, unsigned int maxTouches); /** - * @brief Downcast an Object handle to LongPressGestureDetector handle. + * @brief Downcast a handle to LongPressGestureDetector handle. * * If handle points to a LongPressGestureDetector object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a LongPressGestureDetector object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a LongPressGestureDetector object or an uninitialized handle */ static LongPressGestureDetector DownCast( BaseHandle handle ); @@ -211,7 +207,7 @@ public: // Signals public: // Not intended for Application developers /** - * @brief This constructor is used by Dali New() methods. + * @brief This constructor is used by LongPressGestureDetector::New() methods. * * @since_tizen 2.4 * @param [in] internal A pointer to a newly allocated Dali resource. diff --git a/dali/public-api/events/long-press-gesture.h b/dali/public-api/events/long-press-gesture.h index 72ba0da..9a5b126 100644 --- a/dali/public-api/events/long-press-gesture.h +++ b/dali/public-api/events/long-press-gesture.h @@ -32,8 +32,8 @@ namespace Dali /** * @brief A LongPressGesture is emitted when the user touches and holds the screen with the stated number of fingers. * - * This gesture can be in one of two states, when the long-press gesture is first detected: "Started"; - * and when the long-press gesture ends: "Finished". + * This gesture can be in one of two states, when the long-press gesture is first detected: Gesture::Started + * and when the long-press gesture ends: Gesture::Finished. * * Long press gesture finishes when all touches have been released. * @@ -48,19 +48,22 @@ struct DALI_IMPORT_API LongPressGesture : public Gesture * @brief Constructor * * @since_tizen 2.4 - * @param[in] state The state of the gesture + * @param[in] state The state of the gesture */ LongPressGesture(Gesture::State state); /** * @brief Copy constructor * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle */ LongPressGesture( const LongPressGesture& rhs ); /** * @brief Assignment operator * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle + * @return A reference to this */ LongPressGesture& operator=( const LongPressGesture& rhs ); diff --git a/dali/public-api/events/pan-gesture-detector.h b/dali/public-api/events/pan-gesture-detector.h index 0b3febf..bb85515 100644 --- a/dali/public-api/events/pan-gesture-detector.h +++ b/dali/public-api/events/pan-gesture-detector.h @@ -58,10 +58,6 @@ struct PanGesture; * @since_tizen 2.4 * @see PanGesture * - * Signals - * | %Signal Name | Method | - * |--------------|-----------------------| - * | pan-detected | @ref DetectedSignal() | */ class DALI_IMPORT_API PanGestureDetector : public GestureDetector { @@ -75,21 +71,21 @@ public: { enum { - SCREEN_POSITION = DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX, ///< name "screen-position", type Vector2 - SCREEN_DISPLACEMENT, ///< name "screen-displacement", type Vector2 - SCREEN_VELOCITY, ///< name "screen-velocity", type Vector2 - LOCAL_POSITION, ///< name "local-position", type Vector2 - LOCAL_DISPLACEMENT, ///< name "local-displacement", type Vector2 - LOCAL_VELOCITY, ///< name "local-velocity", type Vector2 - PANNING, ///< name "panning", type bool + SCREEN_POSITION = DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX, ///< type Vector2 @since_tizen 2.4 + SCREEN_DISPLACEMENT, ///< type Vector2 @since_tizen 2.4 + SCREEN_VELOCITY, ///< type Vector2 @since_tizen 2.4 + LOCAL_POSITION, ///< type Vector2 @since_tizen 2.4 + LOCAL_DISPLACEMENT, ///< type Vector2 @since_tizen 2.4 + LOCAL_VELOCITY, ///< type Vector2 @since_tizen 2.4 + PANNING, ///< type bool @since_tizen 2.4 }; }; // Typedefs - typedef Signal< void ( Actor, const PanGesture& ) > DetectedSignalType; ///< Pan gesture detected signal type + typedef Signal< void ( Actor, const PanGesture& ) > DetectedSignalType; ///< Pan gesture detected signal type @since_tizen 2.4 // Directional Pan - typedef std::pair< Radian, Radian > AngleThresholdPair; ///< Range of angles for a direction + typedef std::pair< Radian, Radian > AngleThresholdPair; ///< Range of angles for a direction @since_tizen 2.4 static const Radian DIRECTION_LEFT; ///< For a left pan (-PI Radians). static const Radian DIRECTION_RIGHT; ///< For a right pan (0 Radians). @@ -105,7 +101,7 @@ public: // Creation & Destruction /** * @brief Create an uninitialized PanGestureDetector; this can be initialized with PanGestureDetector::New(). * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an uninitialized PanGestureDetector handle is not allowed. * @since_tizen 2.4 */ PanGestureDetector(); @@ -119,13 +115,13 @@ public: // Creation & Destruction static PanGestureDetector New(); /** - * @brief Downcast an Object handle to PanGestureDetector handle. + * @brief Downcast a handle to PanGestureDetector handle. * * If handle points to a PanGestureDetector object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a PanGestureDetector object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a PanGestureDetector object or an uninitialized handle */ static PanGestureDetector DownCast( BaseHandle handle ); @@ -268,7 +264,7 @@ public: // Directional Panning * @brief Returns the angle by index that this pan gesture detector emits a signal. * * @since_tizen 2.4 - * @return an angle threshold pair, or a zero valued angle pair when index is invalid. + * @return An angle threshold pair, or a zero valued angle pair when index is invalid. * @pre The gesture detector has been initialized. * @pre The index is less than GetAngleCount() */ @@ -336,10 +332,10 @@ public: // Pan Properties Setters public: // Not intended for Application developers /** - * @brief This constructor is used by Dali New() methods. + * @brief This constructor is used by PanGestureDetector::New() methods. * * @since_tizen 2.4 - * @param [in] internal A pointer to a newly allocated Dali resource. + * @param [in] internal A pointer to a newly allocated Dali resource. */ explicit DALI_INTERNAL PanGestureDetector(Internal::PanGestureDetector* internal); diff --git a/dali/public-api/events/pan-gesture.h b/dali/public-api/events/pan-gesture.h index 2b646fb..71f9946 100644 --- a/dali/public-api/events/pan-gesture.h +++ b/dali/public-api/events/pan-gesture.h @@ -32,9 +32,9 @@ namespace Dali /** * @brief A PanGesture is emitted when the user moves one or more fingers in a particular direction. * - * This gesture can be in one of three states, when the pan gesture is first detected: "Started"; - * when the pan gesture is continuing: "Continuing"; and finally, when the pan gesture ends: - * "Finished". + * This gesture can be in one of three states, when the pan gesture is first detected: Gesture::Started + * when the pan gesture is continuing: Gesture::Continuing and finally, when the pan gesture ends: + * Gesture::Finished. * * A pan gesture will end in the following ways: * - User releases the primary finger (the first touch). @@ -59,19 +59,22 @@ struct DALI_IMPORT_API PanGesture: public Gesture * @brief Constructor. * * @since_tizen 2.4 - * @param[in] state The state of the gesture + * @param[in] state The state of the gesture */ PanGesture(Gesture::State state); /** * @brief Copy constructor. * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle */ PanGesture( const PanGesture& rhs ); /** * @brief Assignment operator. * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle + * @return A reference to this */ PanGesture& operator=( const PanGesture& rhs ); diff --git a/dali/public-api/events/pinch-gesture-detector.h b/dali/public-api/events/pinch-gesture-detector.h index 4a70c21..b1470f1 100644 --- a/dali/public-api/events/pinch-gesture-detector.h +++ b/dali/public-api/events/pinch-gesture-detector.h @@ -53,10 +53,6 @@ struct PinchGesture; * @since_tizen 2.4 * @see PinchGesture * - * Signals - * | %Signal Name | Method | - * |----------------|-----------------------| - * | pinch-detected | @ref DetectedSignal() | */ class DALI_IMPORT_API PinchGestureDetector : public GestureDetector { @@ -73,7 +69,7 @@ public: // Creation & Destruction /** * @brief Create an uninitialized PinchGestureDetector; this can be initialized with PinchGestureDetector::New(). * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an uninitialized PinchGestureDetector handle is not allowed. * @since_tizen 2.4 */ PinchGestureDetector(); @@ -87,13 +83,13 @@ public: // Creation & Destruction static PinchGestureDetector New(); /** - * @brief Downcast an Object handle to PinchGestureDetector handle. + * @brief Downcast a handle to PinchGestureDetector handle. * * If handle points to a PinchGestureDetector object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a PinchGestureDetector object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a PinchGestureDetector object or an uninitialized handle */ static PinchGestureDetector DownCast( BaseHandle handle ); @@ -140,7 +136,7 @@ public: // Signals public: // Not intended for Application developers /** - * @brief This constructor is used by Dali New() methods. + * @brief This constructor is used by PinchGestureDetector::New() methods. * * @since_tizen 2.4 * @param [in] internal A pointer to a newly allocated Dali resource. diff --git a/dali/public-api/events/pinch-gesture.h b/dali/public-api/events/pinch-gesture.h index 848dda8..b0b00a5 100644 --- a/dali/public-api/events/pinch-gesture.h +++ b/dali/public-api/events/pinch-gesture.h @@ -33,9 +33,9 @@ namespace Dali * @brief A PinchGesture is emitted when the user moves two fingers towards or away from each other. * * This gesture can be in one of three states; when the pinch gesture is first detected, its - * state is set to "Started". After this, if there is change in the gesture, the state will - * be "Continuing". Finally, when the gesture ends, the state of the gesture changes to - * "Finished". + * state is set to Gesture::Started. After this, if there is change in the gesture, the state will + * be Gesture::Continuing. Finally, when the gesture ends, the state of the gesture changes to + * Gesture::Finished. * * A pinch gesture will continue to be sent to the actor under the center point of the pinch * until the pinch ends. @@ -49,19 +49,22 @@ struct DALI_IMPORT_API PinchGesture: public Gesture * @brief Default Constructor. * * @since_tizen 2.4 - * @param[in] state The state of the gesture + * @param[in] state The state of the gesture */ PinchGesture(Gesture::State state); /** * @brief Copy constructor. * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle */ PinchGesture( const PinchGesture& rhs ); /** * @brief Assignment operator. * @since_tizen 2.4 + * @param[in] rhs A reference to the copied handle + * @return A reference to this */ PinchGesture& operator=( const PinchGesture& rhs ); diff --git a/dali/public-api/events/tap-gesture-detector.h b/dali/public-api/events/tap-gesture-detector.h index 7363678..3a95c8e 100644 --- a/dali/public-api/events/tap-gesture-detector.h +++ b/dali/public-api/events/tap-gesture-detector.h @@ -40,9 +40,9 @@ struct TapGesture; * @brief This class emits a signal when a tap gesture occurs that meets the requirements set by the * application. * - * See TapGestureDetector::SetTapsRequired + * See @ref TapGestureDetector::SetTapsRequired * - * A Tap Gesture is a discrete gesture, which means it does not have any state information attached + * A TapGesture is a discrete gesture, which means it does not have any state information attached * to it. Please see TapGesture for more information. * * The application programmer can use this gesture detector as follows: @@ -55,10 +55,6 @@ struct TapGesture; * @since_tizen 2.4 * @note Multi-touch taps are not currently supported. However, multiple taps (double & triple tap etc.) ARE supported. * - * Signals - * | %Signal Name | Method | - * |--------------|-----------------------| - * | tap-detected | @ref DetectedSignal() | * @see TapGesture * */ @@ -77,7 +73,7 @@ public: // Creation & Destruction /** * @brief Create an uninitialized TapGestureDetector; this can be initialized with TapGestureDetector::New(). * - * Calling member functions with an uninitialized Dali::Object is not allowed. + * Calling member functions with an uninitialized TapGestureDetector handle is not allowed. * @since_tizen 2.4 */ TapGestureDetector(); @@ -95,19 +91,19 @@ public: // Creation & Destruction * @brief Create an initialized TapGestureDetector with the specified parameters. * * @since_tizen 2.4 - * @param[in] tapsRequired The minimum & maximum number of taps required. + * @param[in] tapsRequired The minimum & maximum number of taps required. * @return A handle to a newly allocated Dali resource. */ static TapGestureDetector New( unsigned int tapsRequired ); /** - * @brief Downcast an Object handle to TapGestureDetector handle. + * @brief Downcast a handle to TapGestureDetector handle. * * If handle points to a TapGestureDetector object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a TapGestureDetector object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a TapGestureDetector object or an uninitialized handle */ static TapGestureDetector DownCast( BaseHandle handle ); @@ -198,10 +194,10 @@ public: // Signals public: // Not intended for Application developers /** - * @brief This constructor is used by Dali New() methods. + * @brief This constructor is used by TapGestureDetector::New() methods. * * @since_tizen 2.4 - * @param [in] internal A pointer to a newly allocated Dali resource. + * @param [in] internal A pointer to a newly allocated Dali resource. */ explicit DALI_INTERNAL TapGestureDetector(Internal::TapGestureDetector* internal); }; diff --git a/dali/public-api/events/tap-gesture.h b/dali/public-api/events/tap-gesture.h index f85e387..349ca85 100644 --- a/dali/public-api/events/tap-gesture.h +++ b/dali/public-api/events/tap-gesture.h @@ -49,12 +49,15 @@ struct DALI_IMPORT_API TapGesture : public Gesture /** * @brief Copy constructor * @since_tizen 2.4 + * @param rhs A reference to the copied handle */ TapGesture( const TapGesture& rhs ); /** * @brief Assignment operator * @since_tizen 2.4 + * @param rhs A reference to the copied handle + * @return A reference to this */ TapGesture& operator=( const TapGesture& rhs ); diff --git a/dali/public-api/events/touch-event.h b/dali/public-api/events/touch-event.h index 050825f..55c67b9 100644 --- a/dali/public-api/events/touch-event.h +++ b/dali/public-api/events/touch-event.h @@ -49,7 +49,7 @@ struct DALI_IMPORT_API TouchEvent /** * @brief Constructor * @since_tizen 2.4 - * @param[in] time The time the event occurred + * @param[in] time The time the event occurred */ TouchEvent(unsigned long time); diff --git a/dali/public-api/events/touch-point.h b/dali/public-api/events/touch-point.h index 695d814..792c98a 100644 --- a/dali/public-api/events/touch-point.h +++ b/dali/public-api/events/touch-point.h @@ -123,9 +123,9 @@ struct DALI_IMPORT_API TouchPoint Vector2 screen; }; -typedef std::vector TouchPointContainer; ///< Container of touch points. -typedef TouchPointContainer::iterator TouchPointContainerIterator; ///< Iterator for Dali::TouchPointContainer -typedef TouchPointContainer::const_iterator TouchPointContainerConstIterator; ///< Const iterator for Dali::TouchPointContainer +typedef std::vector TouchPointContainer; ///< Container of touch points. @since_tizen 2.4 +typedef TouchPointContainer::iterator TouchPointContainerIterator; ///< Iterator for Dali::TouchPointContainer @since_tizen 2.4 +typedef TouchPointContainer::const_iterator TouchPointContainerConstIterator; ///< Const iterator for Dali::TouchPointContainer @since_tizen 2.4 /** * @} diff --git a/dali/public-api/events/wheel-event.h b/dali/public-api/events/wheel-event.h index 3c8f875..08a3580 100644 --- a/dali/public-api/events/wheel-event.h +++ b/dali/public-api/events/wheel-event.h @@ -51,8 +51,8 @@ struct DALI_IMPORT_API WheelEvent */ enum Type { - MOUSE_WHEEL, ///< Mouse wheel event - CUSTOM_WHEEL ///< Custom wheel event + MOUSE_WHEEL, ///< Mouse wheel event @since_tizen 2.4 + CUSTOM_WHEEL ///< Custom wheel event @since_tizen 2.4 }; /** @@ -67,7 +67,7 @@ struct DALI_IMPORT_API WheelEvent * @since_tizen 2.4 * @param[in] type The type of the wheel event * @param[in] direction The direction of wheel rolling (0 = default vertical wheel, 1 = horizontal wheel) - * @param[in] modifiers modifier keys pressed during the event (such as shift, alt and control) + * @param[in] modifiers Modifier keys pressed during the event (such as shift, alt and control) * @param[in] point The co-ordinates of the cursor relative to the top-left of the screen. * @param[in] z The offset of rolling (positive value means roll down or clockwise, and negative value means roll up or counter-clockwise) * @param[in] timeStamp The time the wheel is being rolled. @@ -84,7 +84,7 @@ struct DALI_IMPORT_API WheelEvent * @brief Check to see if Shift key modifier has been supplied. * * @since_tizen 2.4 - * @return bool true if shift modifier + * @return True if shift modifier */ bool IsShiftModifier() const; @@ -92,7 +92,7 @@ struct DALI_IMPORT_API WheelEvent * @brief Check to see if Ctrl (control) key modifier has been supplied. * * @since_tizen 2.4 - * @return bool true if ctrl modifier + * @return True if ctrl modifier */ bool IsCtrlModifier() const; @@ -100,7 +100,7 @@ struct DALI_IMPORT_API WheelEvent * @brief Check to see if Alt key modifier has been supplied. * * @since_tizen 2.4 - * @return bool true if alt modifier + * @return True if alt modifier */ bool IsAltModifier() const; diff --git a/dali/public-api/images/buffer-image.h b/dali/public-api/images/buffer-image.h index 46442b8..e5ba9ae 100644 --- a/dali/public-api/images/buffer-image.h +++ b/dali/public-api/images/buffer-image.h @@ -35,26 +35,26 @@ namespace Internal DALI_INTERNAL class BufferImage; } -typedef unsigned char PixelBuffer; ///< pixel data buffer -typedef Rect RectArea; ///< rectangular area (x,y,w,h) - +typedef unsigned char PixelBuffer; ///< pixel data buffer @since_tizen 2.4 +typedef Rect RectArea; ///< rectangular area (x,y,w,h) @since_tizen 2.4 /** * @brief BufferImage represents an image resource that can be added to ImageViews. + * * Its pixel buffer data is provided by the application developer. * * Care should be taken with pixel data allocated by the application, * as the data is copied to GL both when the image is added to the * stage and after a call to Update(). In both of these cases, a - * SignalUploaded will be sent to the application confirming that the + * Image::UploadedSignal will be sent to the application confirming that the * operation has completed. * * The application can free the pixel data after receiving a - * SignalUploaded. + * Image::UploadedSignal. * * Similarly, once the image is on stage (i.e. it's being used by an * ImageView that is on stage), the application should only write to - * the buffer after receiving a SignalUploaded, then call Update() + * the buffer after receiving a Image::UploadedSignal, then call Update() * once the write is finished. This avoids the pixel data being changed * whilst it's being copied to GL. Writing to the buffer without waiting * for the signal will likely result in visible tearing. @@ -82,14 +82,14 @@ public: * Dali has ownership of the buffer. * For better performance and portability use power of two dimensions. * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE. - * @note: default resource management policies are Immediate and Never - * * @since_tizen 2.4 - * @param [in] width image width in pixels - * @param [in] height image height in pixels - * @param [in] pixelformat the pixel format (rgba 32 bit by default) - * @return a handle to a new instance of BufferImage + * @param [in] width Image width in pixels + * @param [in] height Image height in pixels + * @param [in] pixelformat The pixel format (rgba 32 bit by default) + * @return A handle to a new instance of BufferImage * @pre width & height are greater than zero + * @note default resource management policies are Immediate and Never + * */ static BufferImage New(unsigned int width, unsigned int height, @@ -104,11 +104,14 @@ public: * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE. * * @since_tizen 2.4 + * @remarks ReleasePolicy is an experimental feature and might not be supported in the next release. + * We do recommend not to use this method. + * Please refer the Remarks of ReleasePolicy for more information. * @param [in] width Image width in pixels * @param [in] height Image height in pixels * @param [in] pixelFormat The pixel format * @param [in] releasePolicy Optionally release memory when image is not visible on screen. - * @return a handle to a new instance of BufferImage + * @return A handle to a new instance of BufferImage * @pre width & height are greater than zero */ static BufferImage New(unsigned int width, @@ -123,19 +126,19 @@ public: * * The application holds ownership of the buffer. It must not * destroy the PixelBuffer on a staged image if it has called - * Update() and hasn't received a SignalUploaded, or if it has just - * added it to the stage and has not received a SignalUploaded. + * Update() and hasn't received a Image::UploadedSignal, or if it has just + * added it to the stage and has not received a Image::UploadedSignal. * * For better performance and portability use power of two dimensions. * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE. * * @since_tizen 2.4 - * @param [in] pixelBuffer pixel buffer. has to be allocated by application. - * @param [in] width image width in pixels - * @param [in] height image height in pixels - * @param [in] pixelFormat the pixel format (rgba 32 bit by default) - * @param [in] stride the internal stride of the pixelbuffer in pixels - * @return a handle to a new instance of BufferImage + * @param [in] pixelBuffer Pixel buffer. has to be allocated by application. + * @param [in] width Image width in pixels + * @param [in] height Image height in pixels + * @param [in] pixelFormat The pixel format (rgba 32 bit by default) + * @param [in] stride The internal stride of the pixelbuffer in pixels + * @return A handle to a new instance of BufferImage * @pre width & height are greater than zero */ static BufferImage New(PixelBuffer* pixelBuffer, @@ -151,22 +154,25 @@ public: * * The application holds ownership of the buffer. It must not * destroy the PixelBuffer on a staged image if it has called - * Update() and hasn't received a SignalUploaded, or if it has just - * added it to the stage and has not received a SignalUploaded. + * Update() and hasn't received a Image::UploadedSignal, or if it has just + * added it to the stage and has not received a Image::UploadedSignal. * * For better performance and portability use power of two dimensions. * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE. * * @since_tizen 2.4 - * @param [in] pixelBuffer pixel buffer. has to be allocated by application. - * @param [in] width image width in pixels - * @param [in] height image height in pixels - * @param [in] pixelFormat the pixel format - * @param [in] stride the internal stride of the pixelbuffer in pixels - * @param [in] releasePolicy optionally relase memory when image is not visible on screen. - * @return a handle to a new instance of BufferImage + * @remarks ReleasePolicy is an experimental feature and might not be supported in the next release. + * We do recommend not to use this method. + * Please refer the Remarks of ReleasePolicy for more information. + * @param [in] pixelBuffer Pixel buffer. has to be allocated by application. + * @param [in] width Image width in pixels + * @param [in] height Image height in pixels + * @param [in] pixelFormat The pixel format + * @param [in] stride The internal stride of the pixelbuffer in pixels + * @param [in] releasePolicy Optionally relase memory when image is not visible on screen. + * @return A handle to a new instance of BufferImage * @pre width & height are greater than zero - * @note in case releasePolicy is "Unused", application has to call + * @note in case releasePolicy is Image::UNUSED, application has to call * BufferImage::Update() whenever image is re-added to the stage * */ @@ -178,14 +184,14 @@ public: ReleasePolicy releasePolicy); /** - * @brief Downcast an Object handle to BufferImage. + * @brief Downcast a handle to BufferImage handle. * * If handle points to a BufferImage the downcast produces valid * handle. If not the returned handle is left uninitialized. * * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a BufferImage or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a BufferImage or an uninitialized handle */ static BufferImage DownCast( BaseHandle handle ); @@ -209,7 +215,7 @@ public: * @brief This assignment operator is required for (smart) pointer semantics. * * @since_tizen 2.4 - * @param [in] rhs A reference to the copied handle + * @param [in] rhs A reference to the copied handle * @return A reference to this */ BufferImage& operator=(const BufferImage& rhs); @@ -231,10 +237,10 @@ public: * * Whilst the image is on stage, after writing to the buffer the * application should call Update() and wait for the - * SignalUploaded() method before writing again. + * Image::UploadedSignal() method before writing again. * * @since_tizen 2.4 - * @return the pixel buffer + * @return The pixel buffer */ PixelBuffer* GetBuffer(); @@ -242,7 +248,7 @@ public: * @brief Returns buffer size in bytes. * * @since_tizen 2.4 - * @return the buffer size in bytes + * @return The buffer size in bytes */ unsigned int GetBufferSize() const; @@ -250,7 +256,7 @@ public: * @brief Returns buffer stride (in bytes). * * @since_tizen 2.4 - * @return the buffer stride + * @return The buffer stride */ unsigned int GetBufferStride() const; @@ -258,32 +264,32 @@ public: * @brief Returns the pixel format of the contained buffer * * @since_tizen 2.4 - * @return the pixel format + * @return The pixel format */ Pixel::Format GetPixelFormat() const; /** * @brief Inform Dali that the contents of the buffer have changed. * - * SignalUploaded will be sent in response if the image is on stage + * Image::UploadedSignal will be sent in response if the image is on stage * and the image data has been successfully copied to graphics * memory. To avoid visual tearing, the application should wait for - * the SignalUploaded before modifying the data. + * the Image::UploadedSignal before modifying the data. * * The application must not destroy an external PixelBuffer on a staged - * image after calling this method until the SignalUploaded has been + * image after calling this method until the Image::UploadedSignal has been * successfully received. * - * @note: BufferImage::Update might not work with BGR/BGRA formats! - * @note: Some GPUs may not support Non power of two buffer updates (for - * example C110/SGX540) * @since_tizen 2.4 + * @note BufferImage::Update might not work with BGR/BGRA formats! + * @note Some GPUs may not support Non power of two buffer updates (for + * example C110/SGX540) */ void Update(); /** * @copydoc Update() - * @param [in] updateArea area that has changed in buffer + * @param [in] updateArea Area that has changed in buffer */ void Update( RectArea updateArea ); @@ -294,10 +300,10 @@ public: * is responsible for freeing it. * * The application must not destroy an external PixelBuffer on a staged image - * if it has called Update() and hasn't received a SignalUploaded. + * if it has called Update() and hasn't received a Image::UploadedSignal. * * @since_tizen 2.4 - * @return true if application owns data, false otherwise + * @return True if application owns data, false otherwise */ bool IsDataExternal() const; diff --git a/dali/public-api/images/encoded-buffer-image.h b/dali/public-api/images/encoded-buffer-image.h index 85354cd..1a060ec 100644 --- a/dali/public-api/images/encoded-buffer-image.h +++ b/dali/public-api/images/encoded-buffer-image.h @@ -38,7 +38,7 @@ namespace Internal DALI_INTERNAL class EncodedBufferImage; } -typedef Uint16Pair ImageDimensions; +typedef Uint16Pair ImageDimensions; ///< Image dimension type @since_tizen 2.4 /** @@ -60,9 +60,6 @@ typedef Uint16Pair ImageDimensions; * *

Signals

* - * Image::LoadingFinishedSignal is emitted when the decoding of the - * image data is completed, either successfully or not. - * * Image::UploadedSignal is emitted when the decoded image data gets * uploaded to the OpenGL ES implementation. * @since_tizen 2.4 @@ -73,7 +70,7 @@ public: /** * @brief Constructor which creates an uninitialized EncodedBufferImage object. * - * Use Image::New(...) to create an initialised object. + * Use @ref Image::New to create an initialised object. * @since_tizen 2.4 */ EncodedBufferImage(); @@ -81,10 +78,10 @@ public: /** * @brief Create an initialised image object from an encoded image buffer in memory. * - * The image will be created eagerly using LoadPolicy::Immediate. - * The function is non-blocking and returns immediately while the image - * decoding happens on a background thread. * @since_tizen 2.4 + * @remarks Image::ReleasePolicy is an experimental feature and might not be supported in the next release. + * We do recommend not to use this method. + * Please refer the remarks of ReleasePolicy for more information. * @param [in] encodedImage The encoded bytes of an image, in a supported * image format such as PNG, JPEG, GIF, BMP, KTX, ICO, and WBMP, organised * exactly as it would be as a file in the filesystem. @@ -95,7 +92,7 @@ public: * @param [in] size The width and height to fit the loaded image to. * @param [in] fittingMode The method used to fit the shape of the image before loading to the shape defined by the size parameter. * @param [in] samplingMode The filtering method used when sampling pixels from the input image while fitting it to desired size. - * @param [in] releasePol The ReleasePolicy to apply to Image. If the Unused + * @param [in] releasePol The releasePolicy to apply to Image. If the Image::UNUSED. * @param [in] orientationCorrection Reorient the image to respect any orientation metadata in its header. * policy is set, a reload will not be possible, so the Image should never be * used once all actors using it have gone off-stage. @@ -106,9 +103,6 @@ public: /** * @brief Create an initialised image object from an encoded image buffer in memory. * - * The image will be created eagerly using LoadPolicy::Immediate. - * The function is non-blocking and returns immediately while the image - * decoding happens on a background thread. * @since_tizen 2.4 * @param [in] encodedImage The encoded bytes of an image, in a supported * image format such as PNG, JPEG, GIF, BMP, KTX, ICO, and WBMP, organised @@ -122,13 +116,13 @@ public: static EncodedBufferImage New( const uint8_t * const encodedImage, std::size_t encodedImageByteCount ); /** - * @brief Downcast an Object handle to EncodedBufferImage. + * @brief Downcast a handle to EncodedBufferImage handle. * * If handle points to a EncodedBufferImage the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a EncodedBufferImage or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a EncodedBufferImage or an uninitialized handle */ static EncodedBufferImage DownCast( BaseHandle handle ); diff --git a/dali/public-api/images/frame-buffer-image.h b/dali/public-api/images/frame-buffer-image.h index 6dd499f..99f77ed 100644 --- a/dali/public-api/images/frame-buffer-image.h +++ b/dali/public-api/images/frame-buffer-image.h @@ -35,27 +35,33 @@ namespace Internal DALI_INTERNAL class FrameBufferImage; } +/** + * @brief Render Buffer formats + * @since_tizen 2.4 + */ namespace RenderBuffer { /** * @brief Render Buffer formats + * * The default format for framebuffer creation is COLOR, so If a depth buffer for 3D rendering is required use * COLOR_DEPTH instead * @since_tizen 2.4 */ -enum Format ///< Framebuffer format, default color depth is RGBA 32 bit with alpha +enum Format ///< Framebuffer format, default color depth is RGBA 32 bit with alpha @since_tizen 2.4 { - COLOR, ///< Framebuffer will be created with color buffer. - COLOR_DEPTH, ///< Framebuffer will be created with color and depth buffer - COLOR_STENCIL, ///< Framebuffer will be created with color and stencil buffer - COLOR_DEPTH_STENCIL ///< Framebuffer will be created with color, depth and stencil buffer. NOTE: May be not supported in all devices + COLOR, ///< Framebuffer will be created with color buffer. @since_tizen 2.4 + COLOR_DEPTH, ///< Framebuffer will be created with color and depth buffer @since_tizen 2.4 + COLOR_STENCIL, ///< Framebuffer will be created with color and stencil buffer @since_tizen 2.4 + COLOR_DEPTH_STENCIL ///< Framebuffer will be created with color, depth and stencil buffer. @note May be not supported in all devices @since_tizen 2.4 }; } /** * @brief FrameBufferImage represents a GLES Frame Buffer Object and contains the result * of an 'off screen' render pass of a RenderTask. - * The FrameBufferImage can then be used with an ImageView (with optional shader + * + * The FrameBufferImage can then be used with an @ref Dali::Toolkit::ImageView (with optional shader * effects) and rendered to the screen. * @since_tizen 2.4 */ @@ -65,7 +71,7 @@ public: /** * @brief Constructor which creates an uninitialized FrameBufferImage object. * - * Use Image::New(...) to create an initialised object. + * Use @ref Image::New to create an initialised object. * @since_tizen 2.4 */ FrameBufferImage(); @@ -74,7 +80,6 @@ public: * @brief Create a new FrameBufferImage. * * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE. - * The ReleasePolicy defaults to Dali::Image::Never. * @since_tizen 2.4 * @param [in] width The width in pixels. Setting to zero will use the width of the stage. * @param [in] height The height in pixels. Setting to zero will use the height of the stage. @@ -91,15 +96,15 @@ public: * * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE. * @since_tizen 2.4 + * @remarks Image::ReleasePolicy is an experimental feature and might not be supported in the next release. + * We do recommend not to use this method. + * Please refer the Remarks of ReleasePolicy for more information. * @param [in] width The width in pixels. Setting to zero will use the width of the stage. * @param [in] height The height in pixels. Setting to zero will use the height of the stage. * @param [in] pixelFormat The pixel format. - * @param [in] releasePolicy The ReleasePolicy to apply to the FrameBufferImage. + * @param [in] releasePolicy The releasePolicy to apply to the FrameBufferImage. * @param [in] bufferFormat The format of the buffers that are going to be created for the FBO, (COLOR and DEPTH buffer as default) * - * Note that there is no need for a LoadPolicy - by definition it is always OnDemand, since there is no point in the FrameBufferImage existing unless someone is rendering to - * it, or it is being used as an input (e.g. ShaderEffect / ImageView). - * * @return A handle to a new instance of a FrameBufferImage. * @post When the FrameBufferImage is first used as a render target, an exception may be thrown if pixelFormat is not supported on the hardware platform. */ @@ -113,9 +118,6 @@ public: * @since_tizen 2.4 * @param [in] image The native image. * - * Note that there is no need for a LoadPolicy - by definition it is always OnDemand, since there is no point in the FrameBufferImage existing unless someone is rendering to - * it, or it is being used as an input (e.g. ShaderEffect / ImageView). - * * @return A handle to a new instance of a FrameBufferImage. * @post When the FrameBufferImage is first used as a render target, an exception may be thrown if the NativeImage cannot be mapped to a texture. */ @@ -126,11 +128,11 @@ public: * * The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE. * @since_tizen 2.4 + * @remarks Image::ReleasePolicy is an experimental feature and might not be supported in the next release. + * We do recommend not to use this method. + * Please refer the remarks of ReleasePolicy for more information. * @param [in] image The native image. - * @param [in] releasePolicy The ReleasePolicy to apply to the FrameBufferImage. - * - * Note that there is no need for a LoadPolicy - by definition it is always OnDemand, since there is no point in the FrameBufferImage existing unless someone is rendering to - * it, or it is being used as an input (e.g. ShaderEffect / ImageView). + * @param [in] releasePolicy The releasePolicy to apply to the FrameBufferImage. * * @return A handle to a new instance of a FrameBufferImage. * @post When the FrameBufferImage is first used as a render target, an exception may be thrown if the NativeImage cannot be mapped to a texture. @@ -138,13 +140,13 @@ public: static FrameBufferImage New(NativeImageInterface& image, ReleasePolicy releasePolicy); /** - * @brief Downcast an Object handle to FrameBufferImage handle. + * @brief Downcast a handle to FrameBufferImage handle. * * If handle points to a FrameBufferImage object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a FrameBufferImage object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a FrameBufferImage object or an uninitialized handle */ static FrameBufferImage DownCast( BaseHandle handle ); diff --git a/dali/public-api/images/image-operations.h b/dali/public-api/images/image-operations.h index c84d4db..e30c9ed 100644 --- a/dali/public-api/images/image-operations.h +++ b/dali/public-api/images/image-operations.h @@ -51,17 +51,28 @@ namespace FittingMode { enum Type { - SHRINK_TO_FIT, ///< Fit full image inside desired width & height, potentially not - /// filling one of either the desired image width or height with - /// pixels. - SCALE_TO_FILL, ///< Image fills whole desired width & height with image data. The - /// image is centred in the desired dimensions, exactly touching - /// in one dimension, with image regions outside the other desired - /// dimension cropped away. - FIT_WIDTH, ///< Image fills whole width. Height is scaled proportionately to - /// maintain aspect ratio. - FIT_HEIGHT ///< Image fills whole height. Width is scaled proportionately to - /// maintain aspect ratio. + /// @brief Fit full image inside desired width & height, potentially not + /// filling one of either the desired image width or height with + /// pixels. + /// @since_tizen 2.4 + SHRINK_TO_FIT, + + /// @brief Image fills whole desired width & height with image data. The + /// image is centred in the desired dimensions, exactly touching + /// in one dimension, with image regions outside the other desired + /// dimension cropped away. + /// @since_tizen 2.4 + SCALE_TO_FILL, + + /// @brief Image fills whole width. Height is scaled proportionately to + /// maintain aspect ratio. + /// @since_tizen 2.4 + FIT_WIDTH, + + /// @brief Image fills whole height. Width is scaled proportionately to + /// maintain aspect ratio. + /// @since_tizen 2.4 + FIT_HEIGHT }; const Type DEFAULT = SHRINK_TO_FIT; } @@ -82,24 +93,44 @@ namespace SamplingMode { enum Type { - BOX, ///< Iteratively box filter to generate an image of 1/2, 1/4, - /// 1/8, etc width and height and approximately the desired - /// size. This is the default. - NEAREST, ///< For each output pixel, read one input pixel. - LINEAR, ///< For each output pixel, read a quad of four input pixels - /// and write a weighted average of them. - BOX_THEN_NEAREST, ///< Iteratively box filter to generate an image of 1/2, 1/4, - /// 1/8 etc width and height and approximately the desired - /// size, then for each output pixel, read one pixel from the - /// last level of box filtering. - BOX_THEN_LINEAR, ///< Iteratively box filter to almost the right size, then for - /// each output pixel, read four pixels from the last level of - /// box filtering and write their weighted average. - NO_FILTER, ///< No filtering is performed. If the SCALE_TO_FILL scaling mode - /// is enabled, the borders of the image may be trimmed to - /// match the aspect ratio of the desired dimensions. - DONT_CARE ///< For caching algorithms where a client strongly prefers a - /// cache-hit to reuse a cached image. + /// @brief Iteratively box filter to generate an image of 1/2, 1/4, + /// 1/8, etc width and height and approximately the desired + /// size. This is the default. + /// @since_tizen 2.4 + BOX, + + /// @brief For each output pixel, read one input pixel. + /// @since_tizen 2.4 + NEAREST, + + /// @brief For each output pixel, read a quad of four input pixels + /// and write a weighted average of them. + /// @since_tizen 2.4 + LINEAR, + + /// @brief Iteratively box filter to generate an image of 1/2, 1/4, + /// 1/8 etc width and height and approximately the desired + /// size, then for each output pixel, read one pixel from the + /// last level of box filtering. + /// @since_tizen 2.4 + BOX_THEN_NEAREST, + + /// @brief Iteratively box filter to almost the right size, then for + /// each output pixel, read four pixels from the last level of + /// box filtering and write their weighted average. + /// @since_tizen 2.4 + BOX_THEN_LINEAR, + + /// @brief No filtering is performed. If the SCALE_TO_FILL scaling mode + /// is enabled, the borders of the image may be trimmed to + /// match the aspect ratio of the desired dimensions. + /// @since_tizen 2.4 + NO_FILTER, + + /// @brief For caching algorithms where a client strongly prefers a + /// cache-hit to reuse a cached image. + /// @since_tizen 2.4 + DONT_CARE }; const Type DEFAULT = BOX; } diff --git a/dali/public-api/images/image.h b/dali/public-api/images/image.h index dc87c69..bdd869c 100644 --- a/dali/public-api/images/image.h +++ b/dali/public-api/images/image.h @@ -42,24 +42,12 @@ class Image; * * Image objects can be shared between ImageViews. This is practical if you have a visual element on screen * which is repeatedly used. An example would be a button background image. - * The image resource is discarded when all ImageViews using the Image object are discarded or in case they - * were created with ReleasePolicy::Unused, taken off stage. - * Note: if a resource was shared between Image objects it exists until its last reference is gone. + * The image resource is discarded when all ImageViews using the Image object are discarded. + * @since_tizen 2.4 + * @note if a resource was shared between Image objects it exists until its last reference is gone. * * Image objects are responsible for the underlying resource's lifetime. * - * ReleasePolicies - * - Unused: release resource once ImageView using it is taken off stage. - * - Never: keep resource alive until Image object is thrown away. - * - * Resolution of conflicting policies - * If the same image is created more than once with conflicting policies, ReleasePolicy "Never" overrides "Unused". - * - * Signals - * | %Signal Name | Method | - * |------------------------|------------------------------| - * | uploaded | @ref UploadedSignal() | - * @since_tizen 2.4 */ class DALI_IMPORT_API Image : public BaseHandle { @@ -71,11 +59,13 @@ public: /** * @brief ReleasePolicy controls the way images are deleted from memory. * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. */ enum ReleasePolicy { - UNUSED, ///< release resource once image is not in use anymore (eg. all actors using it become offstage). Reload when resource is required again. - NEVER ///< keep image data for the lifetime of the object. (default) + UNUSED, ///< release resource once image is not in use anymore (eg. all actors using it become offstage). Reload when resource is required again. @since_tizen 2.4 + NEVER ///< keep image data for the lifetime of the object. (default) @since_tizen 2.4 }; /** @@ -89,7 +79,7 @@ public: /** * @brief Constructor which creates an empty Image handle. * - * Use Image::New(...) to create an initialised handle. + * Use @ref Image::New to create an initialised handle. * @since_tizen 2.4 */ Image(); @@ -120,13 +110,13 @@ public: Image& operator=(const Image& rhs); /** - * @brief Downcast an Object handle to Image handle. + * @brief Downcast a handle to Image handle. * * If handle points to a Image object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a Image object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a Image object or an uninitialized handle */ static Image DownCast( BaseHandle handle ); @@ -134,7 +124,9 @@ public: * @brief Return resource release policy. * * @since_tizen 2.4 - * @return resource release policy + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. + * @return Resource release policy */ ReleasePolicy GetReleasePolicy() const; @@ -144,7 +136,7 @@ public: * Returns either the requested width or the actual loaded width if no specific size was requested. * * @since_tizen 2.4 - * @return width of the image in pixels. + * @return Width of the image in pixels. */ unsigned int GetWidth() const; @@ -154,7 +146,7 @@ public: * Returns either the requested height or the actual loaded height if no specific size was requested. * * @since_tizen 2.4 - * @return height of the image in pixels. + * @return Height of the image in pixels. */ unsigned int GetHeight() const; diff --git a/dali/public-api/images/native-image-interface.h b/dali/public-api/images/native-image-interface.h index 7b3b00b..5a3d130 100644 --- a/dali/public-api/images/native-image-interface.h +++ b/dali/public-api/images/native-image-interface.h @@ -48,7 +48,7 @@ public: * * e.g. For the EglImageKHR extension, this corresponds to calling eglCreateImageKHR() * @since_tizen 2.4 - * @return false If the initialization fails. + * @return False If the initialization fails. * @pre There is a GL context for the current thread. */ virtual bool GlExtensionCreate() = 0; @@ -72,7 +72,7 @@ public: virtual unsigned int TargetTexture() = 0; /** - * @brief Called in each NativeTexture::Bind() call to allow implementation specific operations. + * @brief Called in internal each NativeTexture::Bind() call to allow implementation specific operations. * * The correct texture sampler has already been bound before the function gets called. * @since_tizen 2.4 @@ -84,7 +84,7 @@ public: * @brief Returns the width of the NativeImage. * * @since_tizen 2.4 - * @return width + * @return Width */ virtual unsigned int GetWidth() const = 0; @@ -92,7 +92,7 @@ public: * @brief Returns the height of the NativeImage. * * @since_tizen 2.4 - * @return height + * @return Height */ virtual unsigned int GetHeight() const = 0; diff --git a/dali/public-api/images/native-image.h b/dali/public-api/images/native-image.h index 15e4802..b8e1bd9 100644 --- a/dali/public-api/images/native-image.h +++ b/dali/public-api/images/native-image.h @@ -36,6 +36,7 @@ class NativeImage; /** * @brief NativeImage represents an image resource that can be added to ImageViews. + * * Its data is provided by native resources, such as shared bitmap memory or pixmap from X11 or ECORE-X11, etc. * @since_tizen 2.4 */ @@ -101,7 +102,7 @@ public: static NativeImage New( NativeImageInterface& nativeImageInterface ); /** - * @brief Downcast an Object handle to NativeImage handle. + * @brief Downcast a handle to NativeImage handle. * * If handle points to a NativeImage object, the downcast produces valid handle. * If not, the returned handle is left unintialized. diff --git a/dali/public-api/images/nine-patch-image.h b/dali/public-api/images/nine-patch-image.h index 925d2c2..8c4f291 100644 --- a/dali/public-api/images/nine-patch-image.h +++ b/dali/public-api/images/nine-patch-image.h @@ -36,7 +36,8 @@ class NinePatchImage; } /** - * @brief NinePatchImage represents an image resource that can be added to ImageViews. + * @brief NinePatchImage represents an nine-patch image resource. + * * It contains a bitmap that is synchronously loaded from the file system that contains * a 9 patch border - a 1 pixel border that describes the stretch borders and the child * area. @@ -44,11 +45,9 @@ class NinePatchImage; * The class offers an API to read the stretch area and child area, but it does not * remove the border from it's bitmap. An API can be used to obtain a BufferImage with * the border removed. - * - * Adding this image to an ImageView using an Image handle will automatically convert - * to use the cropped BufferImage - if you don't retain a handle to this object, it will - * be automatically destroyed. * @since_tizen 2.4 + * @remarks This is an experimental feature for ImageActor and might not be supported in the next release. + * We do recommend not to use it. */ class DALI_IMPORT_API NinePatchImage : public ResourceImage { @@ -56,7 +55,7 @@ public: /** * @brief Constructor which creates an uninitialized NinePatchImage object. * - * Use Image::New(...) to create an initialised object. + * Use @ref Image::New to create an initialised object. * @since_tizen 2.4 */ NinePatchImage(); @@ -66,23 +65,23 @@ public: * * A pixel buffer for image data is allocated and loaded from the filesystem. * Dali has ownership of the buffer. - * @note: default resource management policies are Immediate and Never - * * @since_tizen 2.4 - * @param [in] filename File to load synchronously into buffer - * @return a handle to a new instance of NinePatchImage + * @param [in] filename File to load synchronously into buffer + * @return A handle to a new instance of NinePatchImage + * @note Default resource management policies are Immediate and Never + * */ static NinePatchImage New( const std::string& filename ); /** - * @brief Downcast an Object handle to NinePatchImage. + * @brief Downcast a handle to NinePatchImage handle. * * If handle points to a NinePatchImage the downcast produces valid * handle. If not the returned handle is left uninitialized. * * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a NinePatchImage or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a NinePatchImage or an uninitialized handle */ static NinePatchImage DownCast( BaseHandle handle ); @@ -121,12 +120,13 @@ public: /** * @brief Get the child rectangle * @since_tizen 2.4 - * @return the position and size of the child rectangle + * @return The position and size of the child rectangle */ Rect GetChildRectangle(); /** * @brief Creates a buffer image from the bitmap with the 1 pixel border cropped off. + * * This does not change the internal bitmap. * * @since_tizen 2.4 diff --git a/dali/public-api/images/pixel.h b/dali/public-api/images/pixel.h index cf2fe7b..b2f4211 100644 --- a/dali/public-api/images/pixel.h +++ b/dali/public-api/images/pixel.h @@ -27,7 +27,7 @@ namespace Dali * @addtogroup dali_core_images * @{ */ - + /** * @brief Pixel format types and their properties. * @since_tizen 2.4 @@ -37,40 +37,41 @@ namespace Pixel /** * @brief Pixel formats * - * @note: BufferImage::Update might not work with BGR/BGRA formats! + * Pixel format, default color depth is RGBA 32 bit with alpha * @since_tizen 2.4 + * @note BufferImage::Update might not work with BGR/BGRA formats! */ -enum Format ///< pixel format, default color depth is RGBA 32 bit with alpha +enum Format { // Start at > 0 to distinguish null data: - A8 = 1, ///< color depth 8-bit, alpha - L8, ///< color depth 8-bit, luminance - LA88, ///< color depth 16-bit, luminance with 8 bit alpha - RGB565, ///< color depth 16 bit, 5-6-5 - BGR565, ///< color depth 16 bit, 5-6-5 - RGBA4444, ///< color depth 16 bit with alpha, 4-4-4-4 - BGRA4444, ///< color depth 16 bit with alpha, 4-4-4-4 - RGBA5551, ///< color depth 16 bit with alpha, 5-5-5-1 - BGRA5551, ///< color depth 16 bit with alpha, 5-5-5-1 - RGB888, ///< color depth 24 bit, 8-8-8 - RGB8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# - BGR8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# - RGBA8888, ///< color depth 32 bit with alpha, 8-8-8-8 - BGRA8888, ///< color depth 32 bit with alpha, 8-8-8-8 + A8 = 1, ///< color depth 8-bit, alpha @since_tizen 2.4 + L8, ///< color depth 8-bit, luminance @since_tizen 2.4 + LA88, ///< color depth 16-bit, luminance with 8 bit alpha @since_tizen 2.4 + RGB565, ///< color depth 16 bit, 5-6-5 @since_tizen 2.4 + BGR565, ///< color depth 16 bit, 5-6-5 @since_tizen 2.4 + RGBA4444, ///< color depth 16 bit with alpha, 4-4-4-4 @since_tizen 2.4 + BGRA4444, ///< color depth 16 bit with alpha, 4-4-4-4 @since_tizen 2.4 + RGBA5551, ///< color depth 16 bit with alpha, 5-5-5-1 @since_tizen 2.4 + BGRA5551, ///< color depth 16 bit with alpha, 5-5-5-1 @since_tizen 2.4 + RGB888, ///< color depth 24 bit, 8-8-8 @since_tizen 2.4 + RGB8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# @since_tizen 2.4 + BGR8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# @since_tizen 2.4 + RGBA8888, ///< color depth 32 bit with alpha, 8-8-8-8 @since_tizen 2.4 + BGRA8888, ///< color depth 32 bit with alpha, 8-8-8-8 @since_tizen 2.4 // GLES 3 Standard compressed formats: - COMPRESSED_R11_EAC, ///< ETC2 / EAC single-channel, unsigned - COMPRESSED_SIGNED_R11_EAC, ///< ETC2 / EAC single-channel, signed - COMPRESSED_RG11_EAC, ///< ETC2 / EAC dual-channel, unsigned - COMPRESSED_SIGNED_RG11_EAC, ///< ETC2 / EAC dual-channel, signed - COMPRESSED_RGB8_ETC2, ///< ETC2 / EAC RGB - COMPRESSED_SRGB8_ETC2, ///< ETC2 / EAC RGB using sRGB colourspace. - COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, ///< ETC2 / EAC RGB with single bit per pixel alpha mask. - COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,///< ETC2 / EAC RGB using sRGB colourspace, with single bit per pixel alpha mask. - COMPRESSED_RGBA8_ETC2_EAC, ///< ETC2 / EAC RGB plus separate alpha channel. - COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, ///< ETC2 / EAC RGB using sRGB colourspace, plus separate alpha channel. + COMPRESSED_R11_EAC, ///< ETC2 / EAC single-channel, unsigned @since_tizen 2.4 + COMPRESSED_SIGNED_R11_EAC, ///< ETC2 / EAC single-channel, signed @since_tizen 2.4 + COMPRESSED_RG11_EAC, ///< ETC2 / EAC dual-channel, unsigned @since_tizen 2.4 + COMPRESSED_SIGNED_RG11_EAC, ///< ETC2 / EAC dual-channel, signed @since_tizen 2.4 + COMPRESSED_RGB8_ETC2, ///< ETC2 / EAC RGB @since_tizen 2.4 + COMPRESSED_SRGB8_ETC2, ///< ETC2 / EAC RGB using sRGB colourspace. @since_tizen 2.4 + COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, ///< ETC2 / EAC RGB with single bit per pixel alpha mask. @since_tizen 2.4 + COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,///< ETC2 / EAC RGB using sRGB colourspace, with single bit per pixel alpha mask. @since_tizen 2.4 + COMPRESSED_RGBA8_ETC2_EAC, ///< ETC2 / EAC RGB plus separate alpha channel. @since_tizen 2.4 + COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, ///< ETC2 / EAC RGB using sRGB colourspace, plus separate alpha channel. @since_tizen 2.4 // GLES 2 extension compressed formats: - COMPRESSED_RGB8_ETC1, ///< ETC1 RGB as defined by GLES 2 extension OES_compressed_ETC1_RGB8_texture: http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt - COMPRESSED_RGB_PVRTC_4BPPV1 ///< PowerVR 4bpp RGB format (v1) as defined by extension IMG_texture_compression_pvrtc: http://www.khronos.org/registry/gles/extensions/IMG/IMG_texture_compression_pvrtc.txt + COMPRESSED_RGB8_ETC1, ///< ETC1 RGB as defined by GLES 2 extension OES_compressed_ETC1_RGB8_texture: http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt @since_tizen 2.4 + COMPRESSED_RGB_PVRTC_4BPPV1 ///< PowerVR 4bpp RGB format (v1) as defined by extension IMG_texture_compression_pvrtc: http://www.khronos.org/registry/gles/extensions/IMG/IMG_texture_compression_pvrtc.txt @since_tizen 2.4 ///! Update LAST_VALID_PIXEL_FORMAT below if you add an enum value here. }; @@ -92,8 +93,9 @@ const Format LAST_VALID_PIXEL_FORMAT = COMPRESSED_RGB_PVRTC_4BPPV1; * @brief Whether specified pixel format contains an alpha value. * * @since_tizen 2.4 - * @param [in] pixelformat pixel format - * @return true if format has alpha, false otherwise + * @param [in] pixelformat Pixel format + * @return True if format has alpha, false otherwise + * */ DALI_IMPORT_API bool HasAlpha(Format pixelformat); @@ -103,20 +105,23 @@ DALI_IMPORT_API bool HasAlpha(Format pixelformat); * @since_tizen 2.4 * @param [in] pixelFormat The pixel format * @return The number of bytes per pixel + * */ DALI_IMPORT_API unsigned int GetBytesPerPixel(Format pixelFormat); /** * @brief Returns the offset of the byte containing the alpha value from the start of the pixel data * and the bitmask of that byte to get the alpha value. - * For example, in case of RGBA4444, byteOffset value is 1 and bitMask value is 0x0f. + * + * For example, in case of Pixel::RGBA4444, byteOffset value is 1 and bitMask value is 0x0f. * It means the second byte contains the alpha value and the last 4 bits of the byte is the alpha value. * * Bitmask is zero if the pixelFormat does not support alpha * @since_tizen 2.4 - * @param[in] pixelFormat the pixel format - * @param[out] byteOffset the byte offset of the byte containing the alpha value - * @param[out] bitMask the bitmask of the byte to get the alpha value + * @param[in] pixelFormat The pixel format + * @param[out] byteOffset The byte offset of the byte containing the alpha value + * @param[out] bitMask The bitmask of the byte to get the alpha value + * */ DALI_IMPORT_API void GetAlphaOffsetAndMask(Format pixelFormat, int& byteOffset, int& bitMask); diff --git a/dali/public-api/images/resource-image.h b/dali/public-api/images/resource-image.h index 8260241..da04bf0 100644 --- a/dali/public-api/images/resource-image.h +++ b/dali/public-api/images/resource-image.h @@ -45,20 +45,14 @@ class ResourceImage; *

ResourceImage Loading

* * When the ResourceImage is created, resource loading will be attempted unless - * the ResourceImage is created with IMMEDIATE loading policy or a compatible resource is found in cache. - * In case of loading images ON_DEMAND, resource loading will only be attempted if the associated ImageView + * the ResourceImage is created with ResourceImage::IMMEDIATE loading policy or a compatible resource is found in cache. + * In case of loading images ResourceImage::ON_DEMAND, resource loading will only be attempted if the associated Dali::Toolkit::ImageView * is put on Stage. * Scaling of images to a desired smaller size can be requested by providing desired dimensions, * scaling mode and filter mode to to ResourceImage::New(). * - * LoadPolicies - * - IMMEDIATE: acquire image resource when creating ResourceImage. - * - ON_DEMAND: only load in case the associated ImageView is put on Stage - * - * Resolution of conflicting policies - * If the same image is created more than once with conflicting policies, LoadPolicy "IMMEDIATE" overrides "ON_DEMAND". - * * Custom load requests + * * Size, scaling mode, filter mode, and orientation compensation can be set when requesting an image. * * Compatible resources @@ -75,12 +69,8 @@ class ResourceImage; * If the file changed since the last load operation, this might result in a different resource. * Reload only takes effect if both of these conditions apply: * - The ResourceImage has already finished loading - * - The ResourceImage is either on Stage or using IMMEDIATE load policy + * - The ResourceImage is either on Stage or using ResourceImage::IMMEDIATE load policy * - * Signals - * | %Signal Name | Method | - * |------------------------|------------------------------| - * | image-loading-finished | @ref LoadingFinishedSignal() | * @since_tizen 2.4 */ class DALI_IMPORT_API ResourceImage : public Image @@ -93,11 +83,13 @@ public: /** * @brief LoadPolicy controls the way images are loaded into memory. * @since_tizen 2.4 + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. */ enum LoadPolicy { - IMMEDIATE, ///< load image once it is created (default) - ON_DEMAND ///< delay loading until the image is being used (a related actor is added to Stage) + IMMEDIATE, ///< Load image once it is created (default) @since_tizen 2.4 + ON_DEMAND ///< Delay loading until the image is being used (a related actor is added to Stage) @since_tizen 2.4 }; /** @@ -182,6 +174,9 @@ public: * @since_tizen 2.4 * @privlevel public * @privilege %http://tizen.org/privilege/internet + * @remarks ResourceImage::LoadPolicy and Image::ReleasePolicy are experimental features and might not be supported in the next release. + * We do recommend not to use this method. + * Please refer the Remarks of ResourceImage::LoadPolicy and Image::ReleasePolicy for more information. * @remarks %http://tizen.org/privilege/internet is needed if @a url is a http or https address. * @param [in] url The URL of the image file to use (can be a local file path, http or https address). * @param [in] loadPol The LoadPolicy to apply when loading the image resource. @@ -217,6 +212,9 @@ public: * @since_tizen 2.4 * @privlevel public * @privilege %http://tizen.org/privilege/internet + * @remarks LoadPolicy and ReleasePolicy are experimental features and might not be supported in the next release. + * We do recommend not to use this method. + * Please refer the Remarks of LoadPolicy and ReleasePolicy for more information. * @remarks %http://tizen.org/privilege/internet is needed if @a url is a http or https address. * @param [in] url The URL of the image file to use (can be a local file path, http or https address). * @param [in] loadPol The LoadPolicy to apply when loading the image resource. @@ -238,13 +236,13 @@ public: ///@} /** - * @brief Downcast an Object handle to ResourceImage handle. + * @brief Downcast a handle to ResourceImage handle. * * If handle points to a ResourceImage object the * downcast produces valid handle. If not the returned handle is left uninitialized. * @since_tizen 2.4 - * @param[in] handle to An object - * @return handle to a Image object or an uninitialized handle + * @param[in] handle Handle to an object + * @return Handle to a Image object or an uninitialized handle */ static ResourceImage DownCast( BaseHandle handle ); @@ -252,7 +250,9 @@ public: * @brief Return load policy. * * @since_tizen 2.4 - * @return resource load policy + * @remarks This is an experimental feature and might not be supported in the next release. + * We do recommend not to use it. + * @return Resource load policy */ LoadPolicy GetLoadPolicy() const; diff --git a/dali/public-api/math/compile-time-math.h b/dali/public-api/math/compile-time-math.h index 570be1b..7aa7dde 100644 --- a/dali/public-api/math/compile-time-math.h +++ b/dali/public-api/math/compile-time-math.h @@ -34,11 +34,11 @@ namespace Dali /** * @brief Compile time template to calculate base to the power of N. * - * Note! values need to be compile time constants - * Usage: Power< 10, 2 >::value; // value=100 * @since_tizen 2.4 - * @param mantissa to raise to exponent - * @param N exponent to use for mantissa + * @tparam mantissa to raise to exponent + * @tparam N exponent to use for mantissa + * @note values need to be compile time constants + * Usage: Power< 10, 2 >::value; // value=100 */ template< size_t mantissa, size_t exponent > struct Power @@ -51,7 +51,7 @@ struct Power * * Specialisation for power of 1 * @since_tizen 2.4 - * @param mantissa to raise to exponent + * @tparam mantissa to raise to exponent */ template< size_t mantissa > struct Power< mantissa, 1 > @@ -64,7 +64,7 @@ struct Power< mantissa, 1 > * * Specialisation for power of 0 * @since_tizen 2.4 - * @param mantissa to raise to exponent + * @tparam mantissa to raise to exponent */ template< size_t mantissa > struct Power< mantissa, 0 > @@ -75,11 +75,11 @@ struct Power< mantissa, 0 > /** * @brief Compile time template to calculate base logarithm of N. * - * Note! values need to be compile time constants - * Usage: Log< 100, 10 >::value; value equals 2 * @since_tizen 2.4 - * @param number for which to calculate the logarithm - * @param base logarithm to calculate + * @tparam number for which to calculate the logarithm + * @tparam base logarithm to calculate + * @note values need to be compile time constants + * Usage: Log< 100, 10 >::value; value equals 2 */ template< size_t number, size_t base = 2 > struct Log @@ -92,7 +92,7 @@ struct Log * * Specialisation for logarithm of 1 * @since_tizen 2.4 - * @param base logarithm to calculate + * @tparam base logarithm to calculate */ template< size_t base > struct Log< 1, base > @@ -105,7 +105,7 @@ struct Log< 1, base > * * Specialisation for logarithm of 0 * @since_tizen 2.4 - * @param base logarithm to calculate + * @tparam base logarithm to calculate */ template< size_t base > struct Log< 0, base > @@ -117,10 +117,10 @@ struct Log< 0, base > /** * @brief Compile time template to calculate the machine epsilon for a given floating point number. * - * Note! value needs to be compile time constant - * Usage: Epsilon<1000>::value; value equals 0.000119209 * @since_tizen 2.4 - * @param N the number for which to calculate the machine epsilon + * @tparam N the number for which to calculate the machine epsilon + * @note value needs to be compile time constant + * Usage: Epsilon<1000>::value; value equals 0.000119209 */ template< size_t N > struct Epsilon diff --git a/dali/public-api/math/degree.h b/dali/public-api/math/degree.h index 4341f5d..dbabc7a 100644 --- a/dali/public-api/math/degree.h +++ b/dali/public-api/math/degree.h @@ -41,7 +41,7 @@ struct Radian; struct Degree { /** - * @brief default constructor, initialises to 0. + * @brief Default constructor, initialises to 0. * @since_tizen 2.4 */ Degree() diff --git a/dali/public-api/math/matrix.h b/dali/public-api/math/matrix.h index ad60d9a..32d0054 100644 --- a/dali/public-api/math/matrix.h +++ b/dali/public-api/math/matrix.h @@ -37,6 +37,7 @@ class Quaternion; /** * @brief The Matrix class represents transformations and projections. + * * It is agnostic w.r.t. row/column major notation - it operates on a flat array. * Each axis is contiguous in memory, so the x axis corresponds to elements 0, 1, 2 and 3, the y axis dorresponds to elements 4, 5, 6, 7, etc. * @since_tizen 2.4 @@ -59,7 +60,7 @@ public: * @brief Constructor. * * @since_tizen 2.4 - * @param initialize to zero or leave uninitialized + * @param[i] initialize True for initialization by zero or otherwise */ explicit Matrix( bool initialize ); @@ -69,13 +70,17 @@ public: * The matrix is initialised with the contents of 'array' which must contain 16 floats. * The order of the values for a transform matrix is: * + * @code + * * xAxis.x xAxis.y xAxis.z 0.0f * yAxis.x yAxis.y yAxis.z 0.0f * zAxis.x zAxis.y zAxis.z 0.0f * trans.x trans.y trans.z 1.0f * + * @endcode + * * @since_tizen 2.4 - * @param [in] array 16 floats + * @param [in] array Pointer of 16 floats data */ explicit Matrix(const float* array); @@ -83,7 +88,7 @@ public: * @brief Constructs a matrix from quaternion. * * @since_tizen 2.4 - * @param rotation as quaternion + * @param rotation Rotation as quaternion */ explicit Matrix( const Quaternion& rotation ); @@ -91,7 +96,7 @@ public: * @brief Copy constructor. * * @since_tizen 2.4 - * @param [in] matrix to copy values from + * @param [in] matrix A reference to the copied matrix */ Matrix( const Matrix& matrix ); @@ -99,8 +104,8 @@ public: * @brief Assignment operator. * * @since_tizen 2.4 - * @param [in] matrix to copy values from - * @return a reference to this + * @param [in] matrix A reference to the copied matrix + * @return A reference to this */ Matrix& operator=( const Matrix& matrix ); @@ -119,7 +124,7 @@ public: * @brief Sets this matrix to be an identity matrix with scale. * * @since_tizen 2.4 - * @param scale to set on top of identity matrix + * @param[i] scale Scale to set on top of identity matrix */ void SetIdentityAndScale( const Vector3& scale ); @@ -129,7 +134,7 @@ public: * Any Matrix representing only a rotation and/or translation * can be inverted using this function. It is faster and more accurate then using Invert(). * @since_tizen 2.4 - * @param [out] result returns the inverse of this matrix + * @param [out] result The inverse of this matrix */ void InvertTransform(Matrix& result) const; @@ -139,7 +144,7 @@ public: * Using the Matrix invert function for the specific type * of matrix you are dealing with is faster, more accurate. * @since_tizen 2.4 - * @return true if successful + * @return True if successful */ bool Invert(); @@ -153,7 +158,7 @@ public: * @brief Returns the xAxis from a Transform matrix. * * @since_tizen 2.4 - * @return the x axis + * @return The x axis */ Vector3 GetXAxis() const; @@ -161,7 +166,7 @@ public: * @brief Returns the yAxis from a Transform matrix. * * @since_tizen 2.4 - * @return the y axis + * @return The y axis */ Vector3 GetYAxis() const; @@ -169,7 +174,7 @@ public: * @brief Returns the zAxis from a Transform matrix. * * @since_tizen 2.4 - * @return the z axis + * @return The z axis */ Vector3 GetZAxis() const; @@ -178,7 +183,7 @@ public: * * This assumes the matrix is a transform matrix. * @since_tizen 2.4 - * @param [in] axis the values to set the axis to + * @param[in] axis The values to set the axis to */ void SetXAxis(const Vector3& axis); @@ -187,7 +192,7 @@ public: * * This assumes the matrix is a transform matrix. * @since_tizen 2.4 - * @param [in] axis the values to set the axis to + * @param[in] axis The values to set the axis to */ void SetYAxis(const Vector3& axis); @@ -196,7 +201,7 @@ public: * * This assumes the matrix is a transform matrix. * @since_tizen 2.4 - * @param [in] axis the values to set the axis to + * @param[in] axis The values to set the axis to */ void SetZAxis(const Vector3& axis); @@ -205,8 +210,8 @@ public: * * This assumes the matrix is a transform matrix. * @since_tizen 2.4 - * @return the translation - * @note inlined for performance reasons (generates less code than a function call) + * @return The translation + * @note Inlined for performance reasons (generates less code than a function call) */ const Vector4& GetTranslation() const { return reinterpret_cast(mMatrix[12]); } @@ -215,8 +220,8 @@ public: * * This assumes the matrix is a transform matrix. * @since_tizen 2.4 - * @return the translation - * @note inlined for performance reasons (generates less code than a function call) + * @return The translation + * @note Inlined for performance reasons (generates less code than a function call) */ const Vector3& GetTranslation3() const { return reinterpret_cast(mMatrix[12]); } @@ -225,7 +230,7 @@ public: * * This assumes the matrix is a transform matrix. * @since_tizen 2.4 - * @param [in] translation the translation + * @param[in] translation The translation */ void SetTranslation(const Vector4& translation); @@ -234,7 +239,7 @@ public: * * This assumes the matrix is a transform matrix. * @since_tizen 2.4 - * @param [in] translation the translation + * @param[in] translation The translation */ void SetTranslation(const Vector3& translation); @@ -252,13 +257,19 @@ public: * @brief Returns the contents of the matrix as an array of 16 floats. * * The order of the values for a transform matrix is: + * + * @code + * * xAxis.x xAxis.y xAxis.z 0.0f * yAxis.x yAxis.y yAxis.z 0.0f * zAxis.x zAxis.y zAxis.z 0.0f * trans.x trans.y trans.z 1.0f + * + * @endcode + * * @since_tizen 2.4 - * @return the matrix contents as an array of 16 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The matrix contents as an array of 16 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ const float* AsFloat() const {return mMatrix;} @@ -267,13 +278,18 @@ public: * * The order of the values for a transform matrix is: * + * @code + * * xAxis.x xAxis.y xAxis.z 0.0f * yAxis.x yAxis.y yAxis.z 0.0f * zAxis.x zAxis.y zAxis.z 0.0f * trans.x trans.y trans.z 1.0f + * + * @endcode + * * @since_tizen 2.4 - * @return the matrix contents as an array of 16 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The matrix contents as an array of 16 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ float* AsFloat() {return mMatrix;} @@ -282,9 +298,9 @@ public: * * Use this method in time critical path as it does not require temporaries * @since_tizen 2.4 - * @param result of the multiplication - * @param lhs matrix, this can be same matrix as result - * @param rhs matrix, this cannot be same matrix as result + * @param[out] result Result of the multiplication + * @param[in] lhs Matrix, this can be same matrix as result + * @param[in] rhs Matrix, this cannot be same matrix as result */ static void Multiply( Matrix& result, const Matrix& lhs, const Matrix& rhs ); @@ -293,9 +309,9 @@ public: * * Use this method in time critical path as it does not require temporaries * @since_tizen 2.4 - * @param result of the multiplication - * @param lhs matrix, this can be same matrix as result - * @param rhs quaternion + * @param[out] result Result of the multiplication + * @param[in] lhs Matrix, this can be same matrix as result + * @param[in] rhs Quaternion */ static void Multiply( Matrix& result, const Matrix& lhs, const Quaternion& rhs ); @@ -303,7 +319,7 @@ public: * @brief The multiplication operator. * * @since_tizen 2.4 - * @param [in] rhs the Matrix to multiply this by + * @param[in] rhs The Matrix to multiply this by * @return A matrix containing the result */ Vector4 operator*(const Vector4& rhs) const; @@ -314,8 +330,8 @@ public: * Utilises appropriate machine epsilon values. * * @since_tizen 2.4 - * @param [in] rhs the Matrix to compare this to - * @return true if the matrices are equal + * @param[in] rhs The Matrix to compare this to + * @return True if the matrices are equal */ bool operator==(const Matrix & rhs) const; @@ -324,8 +340,8 @@ public: * * Utilises appropriate machine epsilon values. * @since_tizen 2.4 - * @param [in] rhs the Matrix to compare this to - * @return true if the matrices are not equal. + * @param[in] rhs The Matrix to compare this to + * @return True if the matrices are not equal. */ bool operator!=(const Matrix & rhs) const; @@ -334,9 +350,9 @@ public: * * Performs scale, rotation, then translation * @since_tizen 2.4 - * @param[in] scale to apply - * @param[in] rotation to apply - * @param[in] translation to apply + * @param[in] scale Scale to apply + * @param[in] rotation Rotation to apply + * @param[in] translation Translation to apply */ void SetTransformComponents(const Vector3& scale, const Quaternion& rotation, @@ -347,9 +363,9 @@ public: * * Performs translation, then rotation, then scale. * @since_tizen 2.4 - * @param[in] scale to apply - * @param[in] rotation to apply - * @param[in] translation to apply + * @param[in] scale Scale to apply + * @param[in] rotation Rotation to apply + * @param[in] translation Translation to apply */ void SetInverseTransformComponents(const Vector3& scale, const Quaternion& rotation, @@ -364,7 +380,7 @@ public: * @param[in] xAxis The X axis of the basis * @param[in] yAxis The Y axis of the basis * @param[in] zAxis The Z axis of the basis - * @param[in] translation to apply + * @param[in] translation Translation to apply */ void SetInverseTransformComponents(const Vector3& xAxis, const Vector3& yAxis, @@ -375,9 +391,9 @@ public: * @brief Gets the position, scale and rotation components from the given transform matrix. * * @since_tizen 2.4 - * @param[out] position to set - * @param[out] rotation to set - only valid if the transform matrix has not been skewed or sheared - * @param[out] scale to set - only valid if the transform matrix has not been skewed or sheared + * @param[out] position Position to set + * @param[out] rotation Rotation to set - only valid if the transform matrix has not been skewed or sheared + * @param[out] scale Scale to set - only valid if the transform matrix has not been skewed or sheared * @pre This matrix must not contain skews or shears. */ void GetTransformComponents(Vector3& position, @@ -394,8 +410,8 @@ private: * * It is printed in memory order, i.e. each printed row is contiguous in memory. * @since_tizen 2.4 - * @param [in] o The output stream operator. - * @param [in] matrix The matrix to print. + * @param[in] o The output stream operator. + * @param[in] matrix The matrix to print. * @return The output stream operator. */ DALI_IMPORT_API std::ostream& operator<< (std::ostream& o, const Matrix& matrix); diff --git a/dali/public-api/math/matrix3.h b/dali/public-api/math/matrix3.h index 683eb0f..faf82e6 100644 --- a/dali/public-api/math/matrix3.h +++ b/dali/public-api/math/matrix3.h @@ -59,7 +59,7 @@ public: * @brief Copy Constructor. * * @since_tizen 2.4 - * @param[in] m Another 3x3 matrix + * @param[in] m A reference to the copied 3x3 matrix */ Matrix3(const Matrix3& m); @@ -90,7 +90,7 @@ public: /** * @brief Assignment Operator * @since_tizen 2.4 - * @param matrix from which to copy values + * @param[i] matrix from which to copy values * @return reference to this object */ Matrix3& operator=( const Matrix3& matrix ); @@ -98,8 +98,8 @@ public: /** * @brief Assignment Operator * @since_tizen 2.4 - * @param matrix from which to copy values - * @return reference to this object + * @param[in] matrix A reference to the copied matrix + * @return A reference to this */ Matrix3& operator=( const Matrix& matrix ); @@ -109,8 +109,8 @@ public: * Utilises appropriate machine epsilon values. * * @since_tizen 2.4 - * @param [in] rhs the Matrix to compare this to - * @return true if the matrices are equal + * @param [in] rhs The Matrix to compare this to + * @return True if the matrices are equal */ bool operator==(const Matrix3 & rhs) const; @@ -120,8 +120,8 @@ public: * Utilises appropriate machine epsilon values. * * @since_tizen 2.4 - * @param [in] rhs the Matrix to compare this to - * @return true if the matrices are equal + * @param[in] rhs The Matrix to compare this to + * @return True if the matrices are equal */ bool operator!=(const Matrix3 & rhs) const; @@ -143,23 +143,34 @@ public: * @brief Returns the contents of the matrix as an array of 9 floats. * * The order of the values for a matrix is: + * + * @code + * * xAxis.x yAxis.x zAxis.x * xAxis.y yAxis.y zAxis.y * xAxis.z yAxis.z zAxis.z + * + * @endcode + * * @since_tizen 2.4 - * @return the matrix contents as an array of 9 floats. + * @return The matrix contents as an array of 9 floats. */ const float* AsFloat() const {return &mElements[0];} /** * @brief Returns the contents of the matrix as an array of 9 floats. * + * @code + * * The order of the values for a matrix is: * xAxis.x yAxis.x zAxis.x * xAxis.y yAxis.y zAxis.y * xAxis.z yAxis.z zAxis.z + * + * @endcode + * * @since_tizen 2.4 - * @return the matrix contents as an array of 9 floats. + * @return The matrix contents as an array of 9 floats. */ float* AsFloat() {return &mElements[0];} @@ -167,14 +178,14 @@ public: * @brief Inverts the matrix. * * @since_tizen 2.4 - * @return true if successful + * @return True if successful */ bool Invert(); /** * @brief Swaps the rows to columns * @since_tizen 2.4 - * @return true + * @return True if successful */ bool Transpose(); @@ -182,18 +193,18 @@ public: * @brief Multiplies all elements of the matrix by the scale value. * * @since_tizen 2.4 - * @param scale - the value by which to scale the whole matrix. + * @param[i] scale The value by which to scale the whole matrix. * */ void Scale(float scale); /** - * @brief Magnitude returns the average of the absolute values of the + * @brief Returns the average of the absolute values of the * elements * 3. * * (The Magnitude of the unit matrix is therefore 1) * @since_tizen 2.4 - * @return the magnitude - always positive. + * @return The magnitude - always positive. */ float Magnitude() const; @@ -205,7 +216,7 @@ public: * If the matrix is not invertible, then the matrix is left unchanged. * * @since_tizen 2.4 - * @return true if the matrix is invertible, otherwise false + * @return True if the matrix is invertible, otherwise false */ bool ScaledInverseTranspose(); @@ -214,9 +225,9 @@ public: * * Use this method in time critical path as it does not require temporaries * @since_tizen 2.4 - * @param result of the multiplication - * @param lhs matrix, this can be same matrix as result - * @param rhs matrix, this cannot be same matrix as result + * @param[out] result Result of the multiplication + * @param[in] lhs Matrix, this can be same matrix as result + * @param[in] rhs Matrix, this cannot be same matrix as result */ static void Multiply( Matrix3& result, const Matrix3& lhs, const Matrix3& rhs ); @@ -229,8 +240,8 @@ private: * @brief Print a 3x3 matrix. * * @since_tizen 2.4 - * @param [in] o The output stream operator. - * @param [in] matrix The matrix to print. + * @param[in] o The output stream operator. + * @param[in] matrix The matrix to print. * @return The output stream operator. */ DALI_IMPORT_API std::ostream& operator<< (std::ostream& o, const Matrix3& matrix); diff --git a/dali/public-api/math/quaternion.h b/dali/public-api/math/quaternion.h index 4bfff41..b24730d 100644 --- a/dali/public-api/math/quaternion.h +++ b/dali/public-api/math/quaternion.h @@ -67,7 +67,7 @@ public: * @brief Construct from a quaternion represented by a vector. * * @since_tizen 2.4 - * @param[in] vector - x,y,z fields represent i,j,k coefficients, w represents cos(theta/2) + * @param[in] vector x,y,z fields represent i,j,k coefficients, w represents cos(theta/2) */ explicit Quaternion( const Vector4& vector ); @@ -75,8 +75,8 @@ public: * @brief Constructor from an axis and angle. * * @since_tizen 2.4 - * @param[in] angle - the angle around the axis - * @param[in] axis - the vector of the axis + * @param[in] angle The angle around the axis + * @param[in] axis The vector of the axis */ Quaternion( Radian angle, const Vector3& axis ); @@ -133,7 +133,7 @@ public: * @brief Helper to check if this is an identity quaternion * * @since_tizen 2.4 - * @return true if this is identity quaternion + * @return True if this is identity quaternion */ bool IsIdentity() const; @@ -142,8 +142,8 @@ public: * * @since_tizen 2.4 * @param[out] axis - * @param[out] angle in radians - * @return true if converted correctly + * @param[out] angle Angle in radians + * @return True if converted correctly */ bool ToAxisAngle( Vector3& axis, Radian& angle ) const; @@ -151,7 +151,7 @@ public: * @brief Return the quaternion as a vector. * * @since_tizen 2.4 - * @return the vector representation of the quaternion + * @return The vector representation of the quaternion */ const Vector4& AsVector() const; @@ -169,7 +169,7 @@ public: * @brief returns the Euler angles from a rotation Quaternion. * * @since_tizen 2.4 - * @return a vector of Euler angles (x == pitch, y == yaw, z == roll) + * @return A vector of Euler angles (x == pitch, y == yaw, z == roll) */ Vector4 EulerAngles() const; @@ -213,7 +213,7 @@ public: * @brief Division operator. * * @since_tizen 2.4 - * @param[in] other a quaternion to divide by + * @param[in] other A quaternion to divide by * @return A quaternion containing the result */ const Quaternion operator/( const Quaternion& other ) const; @@ -249,7 +249,7 @@ public: * * @since_tizen 2.4 * @param[in] other The quaternion to add - * @return itself + * @return A reference to this */ const Quaternion& operator+=( const Quaternion& other ); @@ -258,7 +258,7 @@ public: * * @since_tizen 2.4 * @param[in] other The quaternion to subtract - * @return itself + * @return A reference to this */ const Quaternion& operator-=( const Quaternion& other ); @@ -267,7 +267,7 @@ public: * * @since_tizen 2.4 * @param[in] other The quaternion to multiply - * @return itself + * @return A reference to this */ const Quaternion& operator*=( const Quaternion& other ); @@ -276,7 +276,7 @@ public: * * @since_tizen 2.4 * @param[in] scale the value to scale by - * @return itself + * @return A reference to this */ const Quaternion& operator*=( float scale ); @@ -284,8 +284,8 @@ public: * @brief Scale with Assignment operator. * * @since_tizen 2.4 - * @param[in] scale the value to scale by - * @return itself + * @param[in] scale The value to scale by + * @return A reference to this */ const Quaternion& operator/=( float scale ); @@ -311,7 +311,7 @@ public: * @brief Return the length of the quaternion. * * @since_tizen 2.4 - * @return the length of the quaternion + * @return The length of the quaternion */ float Length() const; @@ -319,7 +319,7 @@ public: * @brief Return the squared length of the quaternion. * * @since_tizen 2.4 - * @return the squared length of the quaternion + * @return The squared length of the quaternion */ float LengthSquared() const; @@ -334,7 +334,7 @@ public: * @brief Normalized. * * @since_tizen 2.4 - * @return a normalized version of this quaternion + * @return A normalized version of this quaternion */ Quaternion Normalized() const; @@ -356,7 +356,7 @@ public: * @brief Performs the logarithm of a Quaternion = v*a where q = (cos(a),v*sin(a)). * * @since_tizen 2.4 - * @return a quaternion representing the logarithm + * @return A quaternion representing the logarithm */ Quaternion Log() const; @@ -364,7 +364,7 @@ public: * @brief Performs an exponent e^Quaternion = Exp(v*a) = (cos(a),vsin(a)). * * @since_tizen 2.4 - * @return a quaternion representing the exponent + * @return A quaternion representing the exponent */ Quaternion Exp() const; @@ -372,9 +372,9 @@ public: * @brief Return the dot product of two quaternions. * * @since_tizen 2.4 - * @param[in] q1 - the first quaternion - * @param[in] q2 - the second quaternion - * @return the dot product of the two quaternions + * @param[in] q1 The first quaternion + * @param[in] q2 The second quaternion + * @return The dot product of the two quaternions */ static float Dot( const Quaternion &q1, const Quaternion &q2 ); @@ -382,10 +382,10 @@ public: * @brief Linear Interpolation (using a straight line between the two quaternions). * * @since_tizen 2.4 - * @param[in] q1 - the start quaternion - * @param[in] q2 - the end quaternion - * @param[in] t - a progress value between 0 and 1 - * @return the interpolated quaternion + * @param[in] q1 The start quaternion + * @param[in] q2 The end quaternion + * @param[in] t A progress value between 0 and 1 + * @return The interpolated quaternion */ static Quaternion Lerp( const Quaternion &q1, const Quaternion &q2, float t ); @@ -394,10 +394,10 @@ public: * the two quaternions). * * @since_tizen 2.4 - * @param[in] q1 - the start quaternion - * @param[in] q2 - the end quaternion - * @param[in] progress - a progress value between 0 and 1 - * @return the interpolated quaternion + * @param[in] q1 The start quaternion + * @param[in] q2 The end quaternion + * @param[in] progress A progress value between 0 and 1 + * @return The interpolated quaternion */ static Quaternion Slerp( const Quaternion &q1, const Quaternion &q2, float progress ); @@ -405,10 +405,10 @@ public: * @brief This version of Slerp, used by Squad, does not check for theta > 90. * * @since_tizen 2.4 - * @param[in] q1 - the start quaternion - * @param[in] q2 - the end quaternion - * @param[in] t - a progress value between 0 and 1 - * @return the interpolated quaternion + * @param[in] q1 The start quaternion + * @param[in] q2 The end quaternion + * @param[in] t A progress value between 0 and 1 + * @return The interpolated quaternion */ static Quaternion SlerpNoInvert( const Quaternion &q1, const Quaternion &q2, float t ); @@ -416,12 +416,12 @@ public: * @brief Spherical Cubic Interpolation. * * @since_tizen 2.4 - * @param[in] start - the start quaternion - * @param[in] end - the end quaternion - * @param[in] ctrl1 - the control quaternion for q1 - * @param[in] ctrl2 - the control quaternion for q2 - * @param[in] t - a progress value between 0 and 1 - * @return the interpolated quaternion + * @param[in] start The start quaternion + * @param[in] end The end quaternion + * @param[in] ctrl1 The control quaternion for q1 + * @param[in] ctrl2 The control quaternion for q2 + * @param[in] t A progress value between 0 and 1 + * @return The interpolated quaternion */ static Quaternion Squad( const Quaternion& start, const Quaternion& end, const Quaternion& ctrl1, const Quaternion& ctrl2, float t ); @@ -429,9 +429,9 @@ public: * @brief Returns the shortest angle between two quaternions in Radians. * * @since_tizen 2.4 - * @param[in] q1 - the first quaternion - * @param[in] q2 - the second quaternion - * @return the angle between the two quaternions. + * @param[in] q1 The first quaternion + * @param[in] q2 The second quaternion + * @return The angle between the two quaternions. */ static float AngleBetween( const Quaternion& q1, const Quaternion& q2 ); @@ -439,8 +439,8 @@ public: * @brief Rotate v by this Quaternion (Quaternion must be unit). * * @since_tizen 2.4 - * @param[in] vector a vector to rotate - * @return the rotated vector + * @param[in] vector A vector to rotate + * @return The rotated vector */ Vector4 Rotate( const Vector4& vector ) const; @@ -448,8 +448,8 @@ public: * @brief Rotate v by this Quaternion (Quaternion must be unit). * * @since_tizen 2.4 - * @param[in] vector a vector to rotate - * @return the rotated vector + * @param[in] vector A vector to rotate + * @return The rotated vector */ Vector3 Rotate( const Vector3& vector ) const; diff --git a/dali/public-api/math/radian.h b/dali/public-api/math/radian.h index aad9160..0dc0eb6 100644 --- a/dali/public-api/math/radian.h +++ b/dali/public-api/math/radian.h @@ -40,7 +40,7 @@ namespace Dali struct Radian { /** - * @brief default constructor, initialises to 0. + * @brief Default constructor, initialises to 0. * @since_tizen 2.4 */ Radian() @@ -72,7 +72,7 @@ struct Radian * * @since_tizen 2.4 * @param[in] value Float value in radians - * @return a reference to this object + * @return A reference to this */ Radian& operator=( float value ) { @@ -85,7 +85,7 @@ struct Radian * * @since_tizen 2.4 * @param[in] degree The value in degrees. - * @return a reference to this object + * @return A reference to this */ Radian& operator=( Degree degree ) { @@ -96,7 +96,7 @@ struct Radian /** * @brief Conversion to float * @since_tizen 2.4 - * @return the float value of this Radian + * @return The float value of this Radian */ operator float() const { diff --git a/dali/public-api/math/random.h b/dali/public-api/math/random.h index 730687a..d69e544 100644 --- a/dali/public-api/math/random.h +++ b/dali/public-api/math/random.h @@ -40,9 +40,9 @@ namespace Random * * Note, uses a limited number of values. * @since_tizen 2.4 - * @param[in] f0 the lower bound - * @param[in] f1 the upper bound - * @return a random value between the lower and upper bound + * @param[in] f0 The lower bound + * @param[in] f1 The upper bound + * @return A random value between the lower and upper bound */ inline float Range(float f0, float f1) { @@ -55,7 +55,7 @@ inline float Range(float f0, float f1) * @brief Function to return a normalized axis in a random direction. * * @since_tizen 2.4 - * @return the axis + * @return The axis */ inline Vector4 Axis() { diff --git a/dali/public-api/math/uint-16-pair.h b/dali/public-api/math/uint-16-pair.h index c9db70f..9f89a0f 100644 --- a/dali/public-api/math/uint-16-pair.h +++ b/dali/public-api/math/uint-16-pair.h @@ -73,6 +73,7 @@ public: /** * @brief Copy constructor. * @since_tizen 2.4 + * @param[in] rhs A reference to the copied Uint16Pair */ Uint16Pair( const Uint16Pair& rhs ) { @@ -89,8 +90,9 @@ public: } /** - * @brief @returns the y dimension stored in this 2-tuple. + * @brief Returns the y dimension stored in this 2-tuple. * @since_tizen 2.4 + * @return Height */ uint16_t GetHeight() const { @@ -98,8 +100,9 @@ public: } /** - * @brief @returns the x dimension stored in this 2-tuple. + * @brief Returns the x dimension stored in this 2-tuple. * @since_tizen 2.4 + * @return X */ uint16_t GetX() const { @@ -107,8 +110,9 @@ public: } /** - * @brief @returns the y dimension stored in this 2-tuple. + * @brief Returns the y dimension stored in this 2-tuple. * @since_tizen 2.4 + * @return Y */ uint16_t GetY() const { @@ -118,6 +122,8 @@ public: /** * @brief Equality operator. * @since_tizen 2.4 + * @param[i] rhs A reference for comparison + * @return True if same */ bool operator==( const Uint16Pair& rhs ) const { @@ -127,6 +133,8 @@ public: /** * @brief Inequality operator. * @since_tizen 2.4 + * @param[i] rhs A reference for comparison + * @return True if different */ bool operator!=( const Uint16Pair& rhs ) const { @@ -137,6 +145,8 @@ public: * @brief Less than comparison operator for storing in collections (not geometrically * meaningful). * @since_tizen 2.4 + * @param[i] rhs A reference for comparison + * @return True if less */ bool operator<( const Uint16Pair& rhs ) const { @@ -147,6 +157,8 @@ public: * @brief Greater than comparison operator for storing in collections (not * geometrically meaningful). * @since_tizen 2.4 + * @param[i] rhs A reference for comparison + * @return True if greater */ bool operator>( const Uint16Pair& rhs ) const { @@ -160,6 +172,8 @@ public: * Uses a template for loose coupling, to save a header include, and allow any * vector type with .x and .y members to be converted. * @since_tizen 2.4 + * @param[in] from Floating point vector2 + * @return Closest integer value. */ template static Uint16Pair FromFloatVec2( const FLOAT_VECTOR_N_TYPE& from ) @@ -176,6 +190,8 @@ public: * Uses a template to allow any vector type with operator [] to be converted * in addition to plain arrays. * @since_tizen 2.4 + * @param[in] from Floating point array + * @return Closest integer value. */ template static Uint16Pair FromFloatArray( const FLOAT_ARRAY& from ) diff --git a/dali/public-api/math/vector2.h b/dali/public-api/math/vector2.h index 0bb1c53..5e59ad5 100644 --- a/dali/public-api/math/vector2.h +++ b/dali/public-api/math/vector2.h @@ -73,7 +73,7 @@ public: * @brief Conversion constructor from an array of two floats. * * @since_tizen 2.4 - * @param [in] array of xy + * @param [in] array Array of xy */ explicit Vector2(const float* array) : x(array[0]), @@ -112,8 +112,8 @@ public: * @brief Assignment operator. * * @since_tizen 2.4 - * @param[in] array of floats - * @return itself + * @param[in] array Array of floats + * @return Itself */ Vector2& operator=(const float* array) { @@ -127,8 +127,8 @@ public: * @brief Assignment operator. * * @since_tizen 2.4 - * @param[in] rhs vector to assign. - * @return itself + * @param[in] rhs Vector to assign. + * @return Itself */ Vector2& operator=(const Vector3& rhs); @@ -136,8 +136,8 @@ public: * @brief Assignment operator. * * @since_tizen 2.4 - * @param[in] rhs vector to assign. - * @return itself + * @param[in] rhs Vector to assign. + * @return Itself */ Vector2& operator=(const Vector4& rhs); @@ -145,7 +145,7 @@ public: * @brief Addition operator. * * @since_tizen 2.4 - * @param[in] rhs vector to add. + * @param[in] rhs Vector to add. * @return A vector containing the result of the addition */ Vector2 operator+(const Vector2& rhs) const @@ -159,8 +159,8 @@ public: * @brief Addition assignment operator. * * @since_tizen 2.4 - * @param[in] rhs vector to add. - * @return itself + * @param[in] rhs Vector to add. + * @return Itself */ Vector2& operator+=(const Vector2& rhs) { @@ -174,7 +174,7 @@ public: * @brief Subtraction operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to subtract + * @param[in] rhs The vector to subtract * @return A vector containing the result of the subtraction */ Vector2 operator-(const Vector2& rhs) const @@ -188,8 +188,8 @@ public: * @brief Subtraction assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to subtract - * @return itself + * @param[in] rhs The vector to subtract + * @return Itself */ Vector2& operator-=(const Vector2& rhs) { @@ -203,7 +203,7 @@ public: * @brief Multiplication operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to multiply + * @param[in] rhs The vector to multiply * @return A vector containing the result of the multiplication */ Vector2 operator*(const Vector2& rhs) const @@ -215,7 +215,7 @@ public: * @brief Multiplication operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector + * @param[in] rhs The float value to scale the vector * @return A vector containing the result of the scaling */ Vector2 operator*(float rhs) const @@ -227,8 +227,8 @@ public: * @brief Multiplication assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to multiply - * @return itself + * @param[in] rhs The vector to multiply + * @return Itself */ Vector2& operator*=(const Vector2& rhs) { @@ -242,8 +242,8 @@ public: * @brief Multiplication assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector - * @return itself + * @param[in] rhs The float value to scale the vector + * @return Itself */ Vector2& operator*=(float rhs) { @@ -257,7 +257,7 @@ public: * @brief Division operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to divide + * @param[in] rhs The vector to divide * @return A vector containing the result of the division */ Vector2 operator/(const Vector2& rhs) const @@ -282,8 +282,8 @@ public: * @brief Division assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to divide - * @return itself + * @param[in] rhs The vector to divide + * @return Itself */ Vector2& operator/=(const Vector2& rhs) { @@ -297,8 +297,8 @@ public: * @brief Division assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector by - * @return itself + * @param[in] rhs The float value to scale the vector by + * @return Itself */ Vector2& operator/=(float rhs) { @@ -328,7 +328,7 @@ public: * * @since_tizen 2.4 * @param[in] rhs The vector to test against - * @return true if the vectors are equal + * @return True if the vectors are equal */ bool operator==(const Vector2& rhs) const; @@ -339,7 +339,7 @@ public: * * @since_tizen 2.4 * @param[in] rhs The vector to test against - * @return true if the vectors are not equal + * @return True if the vectors are not equal */ bool operator!=(const Vector2& rhs) const { @@ -351,7 +351,7 @@ public: * * Asserts if index is out of range. Should be 0 or 1 * @since_tizen 2.4 - * @param[in] index Subscript + * @param[in] index Subscript index * @return The float at the given index */ const float& operator[](const unsigned int index) const @@ -380,7 +380,7 @@ public: * @brief Returns the length of the vector. * * @since_tizen 2.4 - * @return the length of the vector + * @return The length of the vector */ float Length() const; @@ -390,7 +390,7 @@ public: * This is more efficient than Length() for threshold * testing as it avoids the use of a square root. * @since_tizen 2.4 - * @return the length of the vector squared. + * @return The length of the vector squared. */ float LengthSquared() const; @@ -405,8 +405,8 @@ public: * @brief Clamps the vector between minimum and maximum vectors. * * @since_tizen 2.4 - * @param [in] min the minimum vector - * @param [in] max the maximum vector + * @param [in] min The minimum vector + * @param [in] max The maximum vector */ void Clamp( const Vector2& min, const Vector2& max ); @@ -417,8 +417,8 @@ public: * 0: x (or width) * 1: y (or height) * @since_tizen 2.4 - * @return the vector contents as an array of 2 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The vector contents as an array of 2 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ const float* AsFloat() const {return &x;} @@ -429,8 +429,8 @@ public: * 0: x (or width) * 1: y (or height) * @since_tizen 2.4 - * @return the vector contents as an array of 2 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The vector contents as an array of 2 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ float* AsFloat() {return &x;} @@ -502,9 +502,9 @@ inline Vector2 Max( const Vector2& a, const Vector2& b ) * @brief Clamps each of vector v's components between minimum and maximum values. * * @since_tizen 2.4 - * @param [in] v a vector - * @param [in] min the minimum value - * @param [in] max the maximum value + * @param [in] v A vector + * @param [in] min The minimum value + * @param [in] max The maximum value * @return a vector containing the clamped components of v */ DALI_IMPORT_API Vector2 Clamp( const Vector2& v, const float& min, const float& max ); diff --git a/dali/public-api/math/vector3.h b/dali/public-api/math/vector3.h index f7d5bad..19b42ee 100644 --- a/dali/public-api/math/vector3.h +++ b/dali/public-api/math/vector3.h @@ -63,9 +63,9 @@ struct DALI_IMPORT_API Vector3 * @brief Constructor. * * @since_tizen 2.4 - * @param [in] x (or width) component - * @param [in] y (or height) component - * @param [in] z (or depth) component + * @param [in] x x or width component + * @param [in] y y or height component + * @param [in] z z or depth component */ explicit Vector3(float x, float y, float z) : x(x), @@ -78,7 +78,7 @@ struct DALI_IMPORT_API Vector3 * @brief Conversion constructor from an array of three floats. * * @since_tizen 2.4 - * @param [in] array of xyz + * @param [in] array Array of xyz */ explicit Vector3(const float* array) : x(array[0]), @@ -120,8 +120,8 @@ struct DALI_IMPORT_API Vector3 * @brief Assignment operator. * * @since_tizen 2.4 - * @param[in] array of floats - * @return itself + * @param[in] array Array of floats + * @return Itself */ Vector3& operator=(const float* array) { @@ -136,8 +136,8 @@ struct DALI_IMPORT_API Vector3 * @brief Assignment operator. * * @since_tizen 2.4 - * @param[in] rhs vector to assign. - * @return itself + * @param[in] rhs Vector to assign. + * @return Itself */ Vector3& operator=(const Vector2& rhs); @@ -145,8 +145,8 @@ struct DALI_IMPORT_API Vector3 * @brief Assignment operator. * * @since_tizen 2.4 - * @param[in] rhs vector to assign. - * @return itself + * @param[in] rhs Vector to assign. + * @return Itself */ Vector3& operator=(const Vector4& rhs); @@ -154,7 +154,7 @@ struct DALI_IMPORT_API Vector3 * @brief Addition operator. * * @since_tizen 2.4 - * @param[in] rhs vector to add. + * @param[in] rhs Vector to add. * @return A vector containing the result of the addition */ Vector3 operator+(const Vector3& rhs) const @@ -168,8 +168,8 @@ struct DALI_IMPORT_API Vector3 * @brief Addition assignment operator. * * @since_tizen 2.4 - * @param[in] rhs vector to add. - * @return itself + * @param[in] rhs Vector to add. + * @return Itself */ Vector3& operator+=(const Vector3& rhs) { @@ -184,7 +184,7 @@ struct DALI_IMPORT_API Vector3 * @brief Subtraction operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to subtract + * @param[in] rhs The vector to subtract * @return A vector containing the result of the subtraction */ Vector3 operator-(const Vector3& rhs) const @@ -198,8 +198,8 @@ struct DALI_IMPORT_API Vector3 * @brief Subtraction assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to subtract - * @return itself + * @param[in] rhs The vector to subtract + * @return Itself */ Vector3& operator-=(const Vector3& rhs) { @@ -214,7 +214,7 @@ struct DALI_IMPORT_API Vector3 * @brief Multiplication operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to multiply + * @param[in] rhs The vector to multiply * @return A vector containing the result of the multiplication */ Vector3 operator*(const Vector3& rhs) const @@ -228,7 +228,7 @@ struct DALI_IMPORT_API Vector3 * @brief Multiplication operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector + * @param[in] rhs The float value to scale the vector * @return A vector containing the result of the scaling */ Vector3 operator*(float rhs) const @@ -240,8 +240,8 @@ struct DALI_IMPORT_API Vector3 * @brief Multiplication assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to multiply - * @return itself + * @param[in] rhs The vector to multiply + * @return Itself */ Vector3& operator*=(const Vector3& rhs) { @@ -256,8 +256,8 @@ struct DALI_IMPORT_API Vector3 * @brief Multiplication assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector - * @return itself + * @param[in] rhs The float value to scale the vector + * @return Itself */ Vector3& operator*=(float rhs) { @@ -272,8 +272,8 @@ struct DALI_IMPORT_API Vector3 * @brief Multiplication assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the Quaternion value to multiply the vector by - * @return itself + * @param[in] rhs The Quaternion value to multiply the vector by + * @return Itself */ Vector3& operator*=(const Quaternion& rhs); @@ -281,7 +281,7 @@ struct DALI_IMPORT_API Vector3 * @brief Division operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to divide + * @param[in] rhs The vector to divide * @return A vector containing the result of the division */ Vector3 operator/(const Vector3& rhs) const @@ -307,8 +307,8 @@ struct DALI_IMPORT_API Vector3 * @brief Division assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to divide - * @return itself + * @param[in] rhs The vector to divide + * @return Itself */ Vector3& operator/=(const Vector3& rhs) { @@ -323,8 +323,8 @@ struct DALI_IMPORT_API Vector3 * @brief Division assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector by - * @return itself + * @param[in] rhs The float value to scale the vector by + * @return Itself */ Vector3& operator/=(float rhs) { @@ -356,7 +356,7 @@ struct DALI_IMPORT_API Vector3 * * @since_tizen 2.4 * @param[in] rhs The vector to test against - * @return true if the vectors are equal + * @return True if the vectors are equal */ bool operator==(const Vector3& rhs) const; @@ -367,7 +367,7 @@ struct DALI_IMPORT_API Vector3 * * @since_tizen 2.4 * @param[in] rhs The vector to test against - * @return true if the vectors are not equal + * @return True if the vectors are not equal */ bool operator!=(const Vector3& rhs) const { @@ -379,7 +379,7 @@ struct DALI_IMPORT_API Vector3 * * Asserts if index is out of range. Should be 0, 1 or 2 * @since_tizen 2.4 - * @param[in] index Subscript + * @param[in] index Subscript index * @return The float at the given index. */ const float& operator[](const unsigned int index) const @@ -411,8 +411,8 @@ struct DALI_IMPORT_API Vector3 * This is great for lighting, threshold testing the angle between two unit vectors, * calculating the distance between two points in a particular direction. * @since_tizen 2.4 - * @param [in] other the other vector - * @return the dot product + * @param [in] other The other vector + * @return The dot product */ float Dot(const Vector3& other) const; @@ -423,8 +423,8 @@ struct DALI_IMPORT_API Vector3 * two vectors. This is great for calculating normals and making matrices orthogonal. * * @since_tizen 2.4 - * @param [in] other the other vector - * @return the cross product + * @param [in] other The other vector + * @return The cross product */ Vector3 Cross(const Vector3& other) const; @@ -432,7 +432,7 @@ struct DALI_IMPORT_API Vector3 * @brief Returns the length of the vector. * * @since_tizen 2.4 - * @return the length of the vector + * @return The length of the vector */ float Length() const; @@ -442,7 +442,7 @@ struct DALI_IMPORT_API Vector3 * This is more efficient than Length() for threshold * testing as it avoids the use of a square root. * @since_tizen 2.4 - * @return the length of the vector squared. + * @return The length of the vector squared. */ float LengthSquared() const; @@ -457,8 +457,8 @@ struct DALI_IMPORT_API Vector3 * @brief Clamps the vector between minimum and maximum vectors. * * @since_tizen 2.4 - * @param [in] min the minimum vector - * @param [in] max the maximum vector + * @param [in] min The minimum vector + * @param [in] max The maximum vector */ void Clamp( const Vector3& min, const Vector3& max ); @@ -470,8 +470,8 @@ struct DALI_IMPORT_API Vector3 * 1: y (or height, or g) * 2: z (or depth, or b) * @since_tizen 2.4 - * @return the vector contents as an array of 3 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The vector contents as an array of 3 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ const float* AsFloat() const {return &x;} @@ -483,8 +483,8 @@ struct DALI_IMPORT_API Vector3 * 1: y (or height, or g) * 2: z (or depth, or b) * @since_tizen 2.4 - * @return the vector contents as an array of 3 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The vector contents as an array of 3 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ float* AsFloat() {return &x;} @@ -492,8 +492,8 @@ struct DALI_IMPORT_API Vector3 * @brief Returns the x & y components (or width & height, or r & g) as a Vector2. * * @since_tizen 2.4 - * @return the partial vector contents as Vector2 (x,y) - * @note inlined for performance reasons (generates less code than a function call) + * @return The partial vector contents as Vector2 (x,y) + * @note Inlined for performance reasons (generates less code than a function call) */ const Vector2& GetVectorXY() const {return reinterpret_cast(x);} @@ -501,8 +501,8 @@ struct DALI_IMPORT_API Vector3 * @brief Returns the x & y components (or width & height, or r & g) as a Vector2. * * @since_tizen 2.4 - * @return the partial vector contents as Vector2 (x,y) - * @note inlined for performance reasons (generates less code than a function call) + * @return The partial vector contents as Vector2 (x,y) + * @note Inlined for performance reasons (generates less code than a function call) */ Vector2& GetVectorXY() {return reinterpret_cast(x);} @@ -510,8 +510,8 @@ struct DALI_IMPORT_API Vector3 * @brief Returns the y & z components (or height & depth, or g & b) as a Vector2. * * @since_tizen 2.4 - * @return the partial vector contents as Vector2 (y,z) - * @note inlined for performance reasons (generates less code than a function call) + * @return The partial vector contents as Vector2 (y,z) + * @note Inlined for performance reasons (generates less code than a function call) */ const Vector2& GetVectorYZ() const {return reinterpret_cast(y);} @@ -519,8 +519,8 @@ struct DALI_IMPORT_API Vector3 * @brief Returns the y & z components (or height & depth, or g & b) as a Vector2. * * @since_tizen 2.4 - * @return the partial vector contents as Vector2 (y,z) - * @note inlined for performance reasons (generates less code than a function call) + * @return The partial vector contents as Vector2 (y,z) + * @note Inlined for performance reasons (generates less code than a function call) */ Vector2& GetVectorYZ() {return reinterpret_cast(y);} @@ -565,9 +565,9 @@ DALI_IMPORT_API std::ostream& operator<< (std::ostream& o, const Vector3& vector * * If a=0,1,2 and b=2,1,0 returns a vector of 2,1,2. * @since_tizen 2.4 - * @param [in] a a vector - * @param [in] b a vector - * @return a vector containing the minimum of each component from a and b + * @param [in] a A vector + * @param [in] b A vector + * @return A vector containing the minimum of each component from a and b */ inline Vector3 Min( const Vector3& a, const Vector3& b ) { @@ -581,9 +581,9 @@ inline Vector3 Min( const Vector3& a, const Vector3& b ) * * If a=0,1 and b=1,0 returns a vector of 1,1 * @since_tizen 2.4 - * @param [in] a a vector - * @param [in] b a vector - * @return a vector containing the maximum of each component from a and b + * @param [in] a A vector + * @param [in] b A vector + * @return A vector containing the maximum of each component from a and b */ inline Vector3 Max( const Vector3& a, const Vector3& b ) { @@ -596,10 +596,10 @@ inline Vector3 Max( const Vector3& a, const Vector3& b ) * @brief Clamps each of vector v's components between minimum and maximum values. * * @since_tizen 2.4 - * @param [in] v a vector - * @param [in] min the minimum value - * @param [in] max the maximum value - * @return a vector containing the clamped components of v + * @param [in] v A vector + * @param [in] min The minimum value + * @param [in] max The maximum value + * @return A vector containing the clamped components of v */ DALI_IMPORT_API Vector3 Clamp( const Vector3& v, const float& min, const float& max ); diff --git a/dali/public-api/math/vector4.h b/dali/public-api/math/vector4.h index 9383ad4..131037a 100644 --- a/dali/public-api/math/vector4.h +++ b/dali/public-api/math/vector4.h @@ -66,10 +66,10 @@ struct DALI_IMPORT_API Vector4 * @brief Conversion constructor from four floats. * * @since_tizen 2.4 - * @param [in] x (or r/s) component - * @param [in] y (or g/t) component - * @param [in] z (or b/p) component - * @param [in] w (or a/q) component + * @param [in] x x or r/s component + * @param [in] y y or g/t component + * @param [in] z z or b/p component + * @param [in] w w or a/q component */ explicit Vector4(float x, float y, float z, float w) : x(x), @@ -84,7 +84,7 @@ struct DALI_IMPORT_API Vector4 * @brief Conversion constructor from an array of four floats. * * @since_tizen 2.4 - * @param [in] array of either xyzw/rgba/stpq + * @param [in] array Array of either xyzw/rgba/stpq */ explicit Vector4(const float* array) : x(array[0]), @@ -98,7 +98,7 @@ struct DALI_IMPORT_API Vector4 * @brief Conversion constructor from Vector2. * * @since_tizen 2.4 - * @param [in] vec2 to copy from, z and w are initialized to 0 + * @param [in] vec2 Vector2 to copy from, z and w are initialized to 0 */ explicit Vector4( const Vector2& vec2 ); @@ -106,7 +106,7 @@ struct DALI_IMPORT_API Vector4 * @brief Conversion constructor from Vector3. * * @since_tizen 2.4 - * @param [in] vec3 to copy from, w is initialized to 0 + * @param [in] vec3 to Vector3 copy from, w is initialized to 0 */ explicit Vector4( const Vector3& vec3 ); @@ -123,8 +123,8 @@ struct DALI_IMPORT_API Vector4 * @brief Assignment operator. * * @since_tizen 2.4 - * @param [in] array of floats - * @return itself + * @param [in] array Array of floats + * @return Itself */ Vector4& operator=(const float* array) { @@ -141,8 +141,8 @@ struct DALI_IMPORT_API Vector4 * * Only sets x and y. z and w are left as they were * @since_tizen 2.4 - * @param [in] vec2 to assign from. - * @return itself + * @param [in] vec2 A reference to assign from. + * @return Itself */ Vector4& operator=(const Vector2& vec2 ); @@ -151,8 +151,8 @@ struct DALI_IMPORT_API Vector4 * * Only sets x and y and z. w is left as it was * @since_tizen 2.4 - * @param [in] vec3 to assign from - * @return itself + * @param [in] vec3 A reference to assign from + * @return Itself */ Vector4& operator=(const Vector3& vec3 ); @@ -160,7 +160,7 @@ struct DALI_IMPORT_API Vector4 * @brief Addition operator. * * @since_tizen 2.4 - * @param[in] rhs vector to add. + * @param[in] rhs Vector to add. * @return A vector containing the result of the addition */ Vector4 operator+(const Vector4 & rhs) const @@ -174,8 +174,8 @@ struct DALI_IMPORT_API Vector4 * @brief Addition assignment operator. * * @since_tizen 2.4 - * @param[in] rhs vector to add. - * @return itself + * @param[in] rhs Vector to add. + * @return Itself */ Vector4& operator+=(const Vector4& rhs) { @@ -191,7 +191,7 @@ struct DALI_IMPORT_API Vector4 * @brief Subtraction operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to subtract + * @param[in] rhs The vector to subtract * @return A vector containing the result of the subtraction */ Vector4 operator-(const Vector4& rhs) const @@ -207,8 +207,8 @@ struct DALI_IMPORT_API Vector4 * @brief Subtraction assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to subtract - * @return itself + * @param[in] rhs The vector to subtract + * @return Itself */ Vector4& operator-=(const Vector4& rhs) { @@ -224,7 +224,7 @@ struct DALI_IMPORT_API Vector4 * @brief Multiplication operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to multiply + * @param[in] rhs The vector to multiply * @return A vector containing the result of the multiplication */ Vector4 operator*(const Vector4& rhs) const @@ -238,7 +238,7 @@ struct DALI_IMPORT_API Vector4 * @brief Multiplication operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector + * @param[in] rhs The float value to scale the vector * @return A vector containing the result of the scaling */ Vector4 operator*(float rhs) const @@ -250,8 +250,8 @@ struct DALI_IMPORT_API Vector4 * @brief Multiplication assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to multiply - * @return itself + * @param[in] rhs The vector to multiply + * @return Itself */ Vector4& operator*=(const Vector4& rhs) { @@ -267,8 +267,8 @@ struct DALI_IMPORT_API Vector4 * @brief Multiplication assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector - * @return itself + * @param[in] rhs The float value to scale the vector + * @return Itself */ Vector4& operator*=(float rhs) { @@ -284,7 +284,7 @@ struct DALI_IMPORT_API Vector4 * @brief Division operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to divide + * @param[in] rhs The vector to divide * @return A vector containing the result of the division */ Vector4 operator/(const Vector4 & rhs) const @@ -311,8 +311,8 @@ struct DALI_IMPORT_API Vector4 * @brief Division assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the vector to divide - * @return itself + * @param[in] rhs The vector to divide + * @return Itself */ Vector4& operator/=(const Vector4& rhs) { @@ -328,8 +328,8 @@ struct DALI_IMPORT_API Vector4 * @brief Division assignment operator. * * @since_tizen 2.4 - * @param[in] rhs the float value to scale the vector by - * @return itself + * @param[in] rhs The float value to scale the vector by + * @return Itself */ Vector4& operator/=(float rhs) { @@ -346,7 +346,7 @@ struct DALI_IMPORT_API Vector4 * @brief Unary negation operator. * * @since_tizen 2.4 - * @return the negative value + * @return The negative value */ Vector4 operator-() const { @@ -362,7 +362,7 @@ struct DALI_IMPORT_API Vector4 * * @since_tizen 2.4 * @param[in] rhs The vector to test against - * @return true if the vectors are equal + * @return True if the vectors are equal */ bool operator==(const Vector4 &rhs) const; @@ -385,7 +385,7 @@ struct DALI_IMPORT_API Vector4 * * Asserts if index is out of range. Should be 0, 1, 2 or 3 * @since_tizen 2.4 - * @param[in] index Subscript + * @param[in] index Subscript index * @return The float at the given index */ const float& operator[](const unsigned int index) const @@ -417,8 +417,8 @@ struct DALI_IMPORT_API Vector4 * This is great for lighting, threshold testing the angle between two unit vectors, * calculating the distance between two points in a particular direction. * @since_tizen 2.4 - * @param [in] other the other vector - * @return the dot product + * @param [in] other The other vector + * @return The dot product */ float Dot(const Vector3& other) const; @@ -429,8 +429,8 @@ struct DALI_IMPORT_API Vector4 * This is great for lighting, threshold testing the angle between two unit vectors, * calculating the distance between two points in a particular direction. * @since_tizen 2.4 - * @param [in] other the other vector - * @return the dot product + * @param [in] other The other vector + * @return The dot product */ float Dot(const Vector4& other) const; @@ -438,8 +438,8 @@ struct DALI_IMPORT_API Vector4 * @brief Returns the 4d dot product of this vector and another vector. * * @since_tizen 2.4 - * @param [in] other the other vector - * @return the dot product + * @param [in] other The other vector + * @return The dot product */ float Dot4(const Vector4& other) const; @@ -450,7 +450,7 @@ struct DALI_IMPORT_API Vector4 * two vectors. This is great for calculating normals and making matrices orthogonal. * * @since_tizen 2.4 - * @param [in] other the other vector + * @param [in] other The other vector * @return A vector containing the cross product */ Vector4 Cross(const Vector4& other) const; @@ -459,7 +459,7 @@ struct DALI_IMPORT_API Vector4 * @brief Returns the length of the vector. * * @since_tizen 2.4 - * @return the length. + * @return The length. */ float Length() const; @@ -469,7 +469,7 @@ struct DALI_IMPORT_API Vector4 * This is faster than using Length() when performing * threshold checks as it avoids use of the square root. * @since_tizen 2.4 - * @return the length of the vector squared. + * @return The length of the vector squared. */ float LengthSquared() const; @@ -485,36 +485,46 @@ struct DALI_IMPORT_API Vector4 * @brief Clamps the vector between minimum and maximum vectors. * * @since_tizen 2.4 - * @param [in] min the minimum vector - * @param [in] max the maximum vector + * @param [in] min The minimum vector + * @param [in] max The maximum vector */ void Clamp( const Vector4& min, const Vector4& max ); /** * @brief Returns the contents of the vector as an array of 4 floats. * + * @code + * * The order of the values in this array are as follows: * 0: x (or r, or s) * 1: y (or g, or t) * 2: z (or b, or p) * 3: w (or a, or q) + * + * @endcode + * * @since_tizen 2.4 - * @return the vector contents as an array of 4 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The vector contents as an array of 4 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ const float* AsFloat() const {return &x;} /** * @brief Returns the contents of the vector as an array of 4 floats. * + * @code + * * The order of the values in this array are as follows: * 0: x (or r, or s) * 1: y (or g, or t) * 2: z (or b, or p) * 3: w (or a, or q) + * + * @endcode + * * @since_tizen 2.4 - * @return the vector contents as an array of 4 floats. - * @note inlined for performance reasons (generates less code than a function call) + * @return The vector contents as an array of 4 floats. + * @note Inlined for performance reasons (generates less code than a function call) */ float* AsFloat() {return &x;} @@ -566,9 +576,9 @@ DALI_IMPORT_API std::ostream& operator<<(std::ostream& o, const Vector4& vector) * * If a=0,1,2,3 and b=4,0,1,2 returns a vector of 0,0,1,2 * @since_tizen 2.4 - * @param [in] a a vector - * @param [in] b a vector - * @return a vector containing the minimum of each component from a and b + * @param [in] a A vector + * @param [in] b A vector + * @return A vector containing the minimum of each component from a and b */ inline Vector4 Min( const Vector4& a, const Vector4& b ) { @@ -583,9 +593,9 @@ inline Vector4 Min( const Vector4& a, const Vector4& b ) * * If a=0,1,2,3 and b=4,0,1,2 returns a vector of 4,1,2,3 * @since_tizen 2.4 - * @param [in] a a vector - * @param [in] b a vector - * @return a vector containing the maximum of each component from a and b + * @param [in] a A vector + * @param [in] b A vector + * @return A vector containing the maximum of each component from a and b */ inline Vector4 Max( const Vector4& a, const Vector4& b ) { @@ -599,10 +609,10 @@ inline Vector4 Max( const Vector4& a, const Vector4& b ) * @brief Clamps each of vector v's components between minimum and maximum values. * * @since_tizen 2.4 - * @param [in] v a vector - * @param [in] min the minimum value - * @param [in] max the maximum value - * @return a vector containing the clamped components of v + * @param [in] v A vector + * @param [in] min The minimum value + * @param [in] max The maximum value + * @return A vector containing the clamped components of v */ DALI_IMPORT_API Vector4 Clamp( const Vector4& v, const float& min, const float& max ); diff --git a/dali/public-api/object/base-handle.h b/dali/public-api/object/base-handle.h index 3f5ffd8..04a7ac3 100644 --- a/dali/public-api/object/base-handle.h +++ b/dali/public-api/object/base-handle.h @@ -259,7 +259,7 @@ private: }; /** - * @brief Template wrapper to downcast an base object handle to derived class handle. + * @brief Template wrapper to downcast a base object handle to derived class handle. * * @since_tizen 2.4 * @param handle to a base object diff --git a/dali/public-api/object/handle.h b/dali/public-api/object/handle.h index 8e793ad..e0db7c5 100644 --- a/dali/public-api/object/handle.h +++ b/dali/public-api/object/handle.h @@ -63,6 +63,7 @@ public: * @brief Some objects support dynamic property creation at run-time. * * New properties are registered by calling RegisterProperty() with an unused property name. + * @since_tizen 2.4 */ DYNAMIC_PROPERTIES = 0x01, }; @@ -167,6 +168,7 @@ public: /** * @brief Query the index of a property. + * * Returns the first property index that matches the given name exactly. * * @since_tizen 2.4 @@ -367,6 +369,10 @@ public: }; +/** + * @brief WeightObject namespace + * @since_tizen 2.4 + */ namespace WeightObject { diff --git a/dali/public-api/object/object-registry.h b/dali/public-api/object/object-registry.h index 8f1a0d7..28be4da 100644 --- a/dali/public-api/object/object-registry.h +++ b/dali/public-api/object/object-registry.h @@ -49,11 +49,6 @@ class ObjectRegistry; * ObjectRegistry registry = Stage::GetObjectRegistry(); * registry.ObjectCreatedSignal().Connect( ObjectCreatedCallbackFunc ); * - * Signals - * | %Signal Name | Method | - * |------------------|------------------------------| - * | object-created | @ref ObjectCreatedSignal() | - * | object-destroyed | @ref ObjectDestroyedSignal() | * @since_tizen 2.4 */ class DALI_IMPORT_API ObjectRegistry : public BaseHandle @@ -139,7 +134,7 @@ public: // Signals * * A callback of the following type may be connected: * @code - * void YourCallbackName(const Dali::RefObject* objectPointer); + * void YourCallbackName(const RefObject* objectPointer); * @endcode * @since_tizen 2.4 * @return The signal to connect to. diff --git a/dali/public-api/object/property-array.h b/dali/public-api/object/property-array.h index eacc77e..dd73fb8 100644 --- a/dali/public-api/object/property-array.h +++ b/dali/public-api/object/property-array.h @@ -41,7 +41,7 @@ class DALI_IMPORT_API Property::Array { public: - typedef std::size_t SizeType; + typedef std::size_t SizeType; ///< Size type @since_tizen 2.4 /** * @brief Default constructor. diff --git a/dali/public-api/object/property-index-ranges.h b/dali/public-api/object/property-index-ranges.h index 5203e51..8d6d71b 100644 --- a/dali/public-api/object/property-index-ranges.h +++ b/dali/public-api/object/property-index-ranges.h @@ -37,26 +37,26 @@ namespace Dali */ enum PropertyRanges { - DEFAULT_OBJECT_PROPERTY_START_INDEX = 0, ///< For all objects deriving from Handle (including Actors). + DEFAULT_OBJECT_PROPERTY_START_INDEX = 0, ///< For all objects deriving from Handle (including Actors). @since_tizen 2.4 - DEFAULT_ACTOR_PROPERTY_START_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< Start index for Actor. - DEFAULT_ACTOR_PROPERTY_MAX_COUNT = 10000, ///< Actor range: 0 to 9999 + DEFAULT_ACTOR_PROPERTY_START_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< Start index for Actor. @since_tizen 2.4 + DEFAULT_ACTOR_PROPERTY_MAX_COUNT = 10000, ///< Actor range: 0 to 9999 @since_tizen 2.4 - DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX = DEFAULT_ACTOR_PROPERTY_START_INDEX + DEFAULT_ACTOR_PROPERTY_MAX_COUNT, ///< Property start index for classes deriving directly from Actor. + DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX = DEFAULT_ACTOR_PROPERTY_START_INDEX + DEFAULT_ACTOR_PROPERTY_MAX_COUNT, ///< Property start index for classes deriving directly from Actor. @since_tizen 2.4 - DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION = 10000, ///< Second-level and onwards derived objects should increment their start index by this. + DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION = 10000, ///< Second-level and onwards derived objects should increment their start index by this. @since_tizen 2.4 - DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< Used by PanGestureDetector. + DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< Used by PanGestureDetector. @since_tizen 2.4 - PROPERTY_REGISTRATION_START_INDEX = 10000000, ///< The index when registering a property should start from this number. - DEFAULT_PROPERTY_MAX_COUNT = PROPERTY_REGISTRATION_START_INDEX, ///< Default Property Range: 0 to 9999999 + PROPERTY_REGISTRATION_START_INDEX = 10000000, ///< The index when registering a property should start from this number. @since_tizen 2.4 + DEFAULT_PROPERTY_MAX_COUNT = PROPERTY_REGISTRATION_START_INDEX, ///< Default Property Range: 0 to 9999999 @since_tizen 2.4 - PROPERTY_REGISTRATION_MAX_INDEX = 19999999, ///< The maximum index supported when registering a property + PROPERTY_REGISTRATION_MAX_INDEX = 19999999, ///< The maximum index supported when registering a property @since_tizen 2.4 - ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX = 20000000, ///< The index when registering an animatable property should start from this number. (SceneGraph properties per type) - ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX = 29999999, ///< The maximum index supported when registering an animatable property + ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX = 20000000, ///< The index when registering an animatable property should start from this number. (SceneGraph properties per type) @since_tizen 2.4 + ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX = 29999999, ///< The maximum index supported when registering an animatable property @since_tizen 2.4 - PROPERTY_CUSTOM_START_INDEX = 50000000, ///< The index at which custom properties start (SceneGraph and Event side properties per instance) + PROPERTY_CUSTOM_START_INDEX = 50000000, ///< The index at which custom properties start (SceneGraph and Event side properties per instance) @since_tizen 2.4 }; /** diff --git a/dali/public-api/object/property-map.h b/dali/public-api/object/property-map.h index daea471..92a6210 100644 --- a/dali/public-api/object/property-map.h +++ b/dali/public-api/object/property-map.h @@ -33,7 +33,7 @@ namespace Dali * @{ */ -typedef std::pair StringValuePair; +typedef std::pair StringValuePair; ///< String and property value pair @since_tizen 2.4 /** * @brief A Map of property values. @@ -43,7 +43,7 @@ class DALI_IMPORT_API Property::Map { public: - typedef std::size_t SizeType; + typedef std::size_t SizeType; ///< Size type @since_tizen 2.4 /** * @brief Default constructor. diff --git a/dali/public-api/object/property-notification.h b/dali/public-api/object/property-notification.h index d4e273f..3d404b6 100644 --- a/dali/public-api/object/property-notification.h +++ b/dali/public-api/object/property-notification.h @@ -52,10 +52,10 @@ public: */ enum NotifyMode { - Disabled, ///< Don't notify, regardless of result of Condition - NotifyOnTrue, ///< Notify whenever condition changes from false to true. - NotifyOnFalse, ///< Notify whenever condition changes from true to false. - NotifyOnChanged ///< Notify whenever condition changes (false to true, and true to false) + Disabled, ///< Don't notify, regardless of result of Condition @since_tizen 2.4 + NotifyOnTrue, ///< Notify whenever condition changes from false to true. @since_tizen 2.4 + NotifyOnFalse, ///< Notify whenever condition changes from true to false. @since_tizen 2.4 + NotifyOnChanged ///< Notify whenever condition changes (false to true, and true to false) @since_tizen 2.4 }; public: @@ -69,7 +69,7 @@ public: PropertyNotification(); /** - * @brief Downcast an Object handle to PropertyNotification. + * @brief Downcast a handle to PropertyNotification handle. * * If handle points to an PropertyNotification object the downcast * produces valid handle. If not the returned handle is left @@ -138,7 +138,9 @@ public: Property::Index GetTargetProperty() const; /** - * @brief Sets the Notification mode. This determines how the property + * @brief Sets the Notification mode. + * + * This determines how the property * notification should respond to the result of a condition. * * @since_tizen 2.4 diff --git a/dali/public-api/object/property.h b/dali/public-api/object/property.h index 9e77534..484a56d 100644 --- a/dali/public-api/object/property.h +++ b/dali/public-api/object/property.h @@ -51,7 +51,7 @@ struct DALI_IMPORT_API Property static const int INVALID_INDEX; ///< -1 is not a valid property index static const int INVALID_COMPONENT_INDEX; ///< -1 is not a valid property index - typedef Dali::Vector< Index > IndexContainer; ///< A vector of property indices + typedef Dali::Vector< Index > IndexContainer; ///< A vector of property indices @since_tizen 2.4 /** * @brief A value-type representing a property value. @@ -74,21 +74,21 @@ struct DALI_IMPORT_API Property */ enum Type { - NONE, ///< No type - - BOOLEAN, ///< A boolean type - FLOAT, ///< A float type - INTEGER, ///< An integer type - VECTOR2, ///< a vector array of size=2 with float precision - VECTOR3, ///< a vector array of size=3 with float precision - VECTOR4, ///< a vector array of size=4 with float precision - MATRIX3, ///< a 3x3 matrix - MATRIX, ///< a 4x4 matrix - RECTANGLE, ///< an integer array of size=4 - ROTATION, ///< either a quaternion or an axis angle rotation - STRING, ///< A string type - ARRAY, ///< an array of Property::Value - MAP ///< a string key to Property:value mapping + NONE, ///< No type @since_tizen 2.4 + + BOOLEAN, ///< A boolean type @since_tizen 2.4 + FLOAT, ///< A float type @since_tizen 2.4 + INTEGER, ///< An integer type @since_tizen 2.4 + VECTOR2, ///< a vector array of size=2 with float precision @since_tizen 2.4 + VECTOR3, ///< a vector array of size=3 with float precision @since_tizen 2.4 + VECTOR4, ///< a vector array of size=4 with float precision @since_tizen 2.4 + MATRIX3, ///< a 3x3 matrix @since_tizen 2.4 + MATRIX, ///< a 4x4 matrix @since_tizen 2.4 + RECTANGLE, ///< an integer array of size=4 @since_tizen 2.4 + ROTATION, ///< either a quaternion or an axis angle rotation @since_tizen 2.4 + STRING, ///< A string type @since_tizen 2.4 + ARRAY, ///< an array of Property::Value @since_tizen 2.4 + MAP ///< a string key to Property:value mapping @since_tizen 2.4 }; /** @@ -97,10 +97,10 @@ struct DALI_IMPORT_API Property */ enum AccessMode { - READ_ONLY, ///< if the property is read-only - READ_WRITE, ///< If the property is read/writeable - ANIMATABLE, ///< If the property can be animated or constrained - ACCESS_MODE_COUNT ///< The number of access modes + READ_ONLY, ///< if the property is read-only @since_tizen 2.4 + READ_WRITE, ///< If the property is read/writeable @since_tizen 2.4 + ANIMATABLE, ///< If the property can be animated or constrained @since_tizen 2.4 + ACCESS_MODE_COUNT ///< The number of access modes @since_tizen 2.4 }; diff --git a/dali/public-api/object/type-info.h b/dali/public-api/object/type-info.h index ceb4ade..e6a0121 100644 --- a/dali/public-api/object/type-info.h +++ b/dali/public-api/object/type-info.h @@ -48,9 +48,9 @@ namespace Internal DALI_INTERNAL class DALI_IMPORT_API TypeInfo : public BaseHandle { public: - typedef BaseHandle (*CreateFunction)(); ///< Function signature for creating an instance of the associated object type. + typedef BaseHandle (*CreateFunction)(); ///< Function signature for creating an instance of the associated object type. @since_tizen 2.4 - typedef bool (*ActionFunction)(BaseObject*, const std::string&, const Property::Map&); ///< Function signature for creating scriptable actions + typedef bool (*ActionFunction)(BaseObject*, const std::string&, const Property::Map&); ///< Function signature for creating scriptable actions @since_tizen 2.4 /** * @brief Connects a callback function with the object's signals. diff --git a/dali/public-api/render-tasks/render-task.h b/dali/public-api/render-tasks/render-task.h index 2cdbbc0..6ff6d54 100644 --- a/dali/public-api/render-tasks/render-task.h +++ b/dali/public-api/render-tasks/render-task.h @@ -74,10 +74,6 @@ class RenderTask; * Note that all connected signals must be disconnected before the object is destroyed. This is typically done in the * object destructor, and requires either the Dali::Connection object or Dali::RenderTask handle to be stored. * - * Signals - * | %Signal Name | Method | - * |--------------|-----------------------| - * | finished | @ref FinishedSignal() | * @since_tizen 2.4 */ class DALI_IMPORT_API RenderTask : public Handle @@ -92,9 +88,9 @@ public: { enum { - VIEWPORT_POSITION = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "viewport-position", type Vector2 - VIEWPORT_SIZE, ///< name "viewport-size", type Vector2 - CLEAR_COLOR, ///< name "clear-color", type Vector4 + VIEWPORT_POSITION = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< type Vector2 @since_tizen 2.4 + VIEWPORT_SIZE, ///< type Vector2 @since_tizen 2.4 + CLEAR_COLOR, ///< type Vector4 @since_tizen 2.4 }; }; @@ -141,8 +137,8 @@ public: */ enum RefreshRate { - REFRESH_ONCE = 0, ///< Process once only e.g. take a snap-shot of the scene. - REFRESH_ALWAYS = 1 ///< Process every frame. + REFRESH_ONCE = 0, ///< Process once only e.g. take a snap-shot of the scene. @since_tizen 2.4 + REFRESH_ALWAYS = 1 ///< Process every frame. @since_tizen 2.4 }; static const bool DEFAULT_EXCLUSIVE; ///< false @@ -293,9 +289,9 @@ public: * * The local coordinates of the actor are mapped as frame-buffer coordinates. * This is useful for hit-testing actors which are rendered off-screen. - * Note: The mapping actor needs to be rendered by the default render task to make the mapping work properly. * @since_tizen 2.4 * @param[in] mappingActor The actor used for conversion. + * @note The mapping actor needs to be rendered by the default render task to make the mapping work properly. */ void SetScreenToFrameBufferMappingActor( Actor mappingActor ); diff --git a/dali/public-api/shader-effects/shader-effect.h b/dali/public-api/shader-effects/shader-effect.h index a848fa4..2e837d1 100644 --- a/dali/public-api/shader-effects/shader-effect.h +++ b/dali/public-api/shader-effects/shader-effect.h @@ -103,10 +103,10 @@ class ShaderEffect; * *
* - * Note: In order for fade and color animations to work, the fragment shader needs to multiply the fragment color + * @since_tizen 2.4 + * @note In order for fade and color animations to work, the fragment shader needs to multiply the fragment color * with the uniform color "uColor" of the node * - * @since_tizen 2.4 */ class DALI_IMPORT_API ShaderEffect : public Handle { @@ -115,6 +115,7 @@ public: // Default Properties /** * @brief An enumeration of properties belonging to the Path class. + * * Grid Density defines the spacing of vertex coordinates in world units. * ie a larger actor will have more grids at the same spacing. * @@ -131,10 +132,10 @@ public: { enum { - GRID_DENSITY = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< name "grid-density", type float - IMAGE, ///< name "image", type Map {"filename":"", "load-policy":...} - PROGRAM, ///< name "program", type Map {"vertex-prefix":"","fragment-prefix":"","vertex":"","fragment":""} - GEOMETRY_HINTS ///< name "geometry-hints", type int (bitfield) values from enum GeometryHints + GRID_DENSITY = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< type float @since_tizen 2.4 + IMAGE, ///< type Map {"filename":"", "load-policy":...} @since_tizen 2.4 + PROGRAM, ///< type Map {"vertex-prefix":"","fragment-prefix":"","vertex":"","fragment":""} @since_tizen 2.4 + GEOMETRY_HINTS ///< type int (bitfield) values from enum GeometryHints @since_tizen 2.4 }; }; @@ -146,13 +147,13 @@ public: */ enum GeometryHints { - HINT_NONE = 0x00, ///< no hints - HINT_GRID_X = 0x01, ///< Geometry must be subdivided in X - HINT_GRID_Y = 0x02, ///< Geometry must be subdivided in Y + HINT_NONE = 0x00, ///< no hints @since_tizen 2.4 + HINT_GRID_X = 0x01, ///< Geometry must be subdivided in X @since_tizen 2.4 + HINT_GRID_Y = 0x02, ///< Geometry must be subdivided in Y @since_tizen 2.4 HINT_GRID = (HINT_GRID_X | HINT_GRID_Y), - HINT_DEPTH_BUFFER = 0x04, ///< Needs depth buffering turned on - HINT_BLENDING = 0x08, ///< Notifies the actor to use blending even if it's fully opaque. Needs actor's blending set to BlendingMode::AUTO - HINT_DOESNT_MODIFY_GEOMETRY = 0x10 ///< Notifies that the vertex shader will not change geometry (enables bounding box culling) + HINT_DEPTH_BUFFER = 0x04, ///< Needs depth buffering turned on @since_tizen 2.4 + HINT_BLENDING = 0x08, ///< Notifies the actor to use blending even if it's fully opaque. Needs actor's blending set to BlendingMode::AUTO @since_tizen 2.4 + HINT_DOESNT_MODIFY_GEOMETRY = 0x10 ///< Notifies that the vertex shader will not change geometry (enables bounding box culling) @since_tizen 2.4 }; /** @@ -166,9 +167,9 @@ public: */ enum UniformCoordinateType { - COORDINATE_TYPE_DEFAULT, ///< Default, No transformation to be applied - COORDINATE_TYPE_VIEWPORT_POSITION, ///< The uniform is a position vector in viewport coordinates that needs to be converted to GL view space coordinates. - COORDINATE_TYPE_VIEWPORT_DIRECTION ///< The uniform is a directional vector in viewport coordinates that needs to be converted to GL view space coordinates. + COORDINATE_TYPE_DEFAULT, ///< Default, No transformation to be applied @since_tizen 2.4 + COORDINATE_TYPE_VIEWPORT_POSITION, ///< The uniform is a position vector in viewport coordinates that needs to be converted to GL view space coordinates. @since_tizen 2.4 + COORDINATE_TYPE_VIEWPORT_DIRECTION ///< The uniform is a directional vector in viewport coordinates that needs to be converted to GL view space coordinates. @since_tizen 2.4 }; /** @@ -209,7 +210,7 @@ public: GeometryHints hints = GeometryHints(HINT_NONE) ); /** - * @brief Downcast an Object handle to ShaderEffect. + * @brief Downcast a handle to ShaderEffect handle. * * If handle points to a ShaderEffect the downcast produces valid * handle. If not the returned handle is left uninitialized. @@ -258,6 +259,7 @@ public: /** * @brief Set a uniform value. + * * This will register a property of type Property::FLOAT; see Object::RegisterProperty() for more details. * If name matches a uniform in the shader source, this value will be uploaded when rendering. * @since_tizen 2.4 diff --git a/dali/public-api/signals/base-signal.h b/dali/public-api/signals/base-signal.h index acbdf65..cab6068 100644 --- a/dali/public-api/signals/base-signal.h +++ b/dali/public-api/signals/base-signal.h @@ -511,8 +511,8 @@ private: */ void CleanupConnections(); - BaseSignal( const BaseSignal& ); ///< undefined copy constructor, signals don't support copying. - BaseSignal& operator=( const BaseSignal& ); ///< undefined assignment operator + BaseSignal( const BaseSignal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + BaseSignal& operator=( const BaseSignal& ); ///< undefined assignment operator @since_tizen 2.4 private: diff --git a/dali/public-api/signals/callback.h b/dali/public-api/signals/callback.h index 61e718e..4ff4980 100644 --- a/dali/public-api/signals/callback.h +++ b/dali/public-api/signals/callback.h @@ -385,7 +385,7 @@ public: // Data for deriving classes & Dispatchers */ struct Impl { - Impl(); ///< Default constructor + Impl(); ///< Default constructor @since_tizen 2.4 void* mObjectPointer; ///< Object whose member function will be called. Not owned if mDestructorDispatcher is NULL. Dispatcher mMemberFunctionDispatcher; ///< Dispatcher for member functions @@ -811,6 +811,7 @@ struct FunctorDispatcherReturn3 /** * @brief Dispatcher to call a functor. + * * This variant calls a specific void() member function. * @since_tizen 2.4 */ diff --git a/dali/public-api/signals/connection-tracker-interface.h b/dali/public-api/signals/connection-tracker-interface.h index 25575c1..6bd15df 100644 --- a/dali/public-api/signals/connection-tracker-interface.h +++ b/dali/public-api/signals/connection-tracker-interface.h @@ -78,8 +78,8 @@ public: private: - ConnectionTrackerInterface( const ConnectionTrackerInterface& ); ///< undefined copy constructor - ConnectionTrackerInterface& operator=( const ConnectionTrackerInterface& ); ///< undefined assignment operator + ConnectionTrackerInterface( const ConnectionTrackerInterface& ); ///< undefined copy constructor @since_tizen 2.4 + ConnectionTrackerInterface& operator=( const ConnectionTrackerInterface& ); ///< undefined assignment operator @since_tizen 2.4 }; /** diff --git a/dali/public-api/signals/connection-tracker.h b/dali/public-api/signals/connection-tracker.h index 3f8d5e8..b1b1379 100644 --- a/dali/public-api/signals/connection-tracker.h +++ b/dali/public-api/signals/connection-tracker.h @@ -79,8 +79,8 @@ public: private: - ConnectionTracker( const ConnectionTracker& ); ///< undefined copy constructor - ConnectionTracker& operator=( const ConnectionTracker& ); ///< undefined assignment operator + ConnectionTracker( const ConnectionTracker& ); ///< undefined copy constructor @since_tizen 2.4 + ConnectionTracker& operator=( const ConnectionTracker& ); ///< undefined assignment operator @since_tizen 2.4 private: diff --git a/dali/public-api/signals/dali-signal.h b/dali/public-api/signals/dali-signal.h index f432ab2..9283566 100644 --- a/dali/public-api/signals/dali-signal.h +++ b/dali/public-api/signals/dali-signal.h @@ -20,6 +20,7 @@ /** * @brief The class should implement Dali::ConnectionTrackerInterface, or inherit from Dali::ConnectionTracker. + * * This enforces automatic disconnection when an object is destroyed, so you don't have * to manually disconnect from signals. * @@ -293,8 +294,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -460,8 +461,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -627,8 +628,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -795,8 +796,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -966,8 +967,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -1134,8 +1135,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -1303,8 +1304,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -1474,8 +1475,8 @@ public: private: - Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. - Signal& operator=( const Signal& ); ///< undefined assignment operator + Signal( const Signal& ); ///< undefined copy constructor, signals don't support copying. @since_tizen 2.4 + Signal& operator=( const Signal& ); ///< undefined assignment operator @since_tizen 2.4 private: diff --git a/dali/public-api/signals/signal-slot-connections.h b/dali/public-api/signals/signal-slot-connections.h index 342bec7..79747b4 100644 --- a/dali/public-api/signals/signal-slot-connections.h +++ b/dali/public-api/signals/signal-slot-connections.h @@ -80,8 +80,8 @@ public: private: - SlotConnection( const SlotConnection& ); ///< undefined copy constructor - SlotConnection& operator=( const SlotConnection& ); ///< undefined assignment operator + SlotConnection( const SlotConnection& ); ///< undefined copy constructor @since_tizen 2.4 + SlotConnection& operator=( const SlotConnection& ); ///< undefined assignment operator @since_tizen 2.4 private: @@ -148,8 +148,8 @@ public: private: - SignalConnection( const SignalConnection& ); ///< undefined copy constructor - SignalConnection& operator=( const SignalConnection& ); ///< undefined assignment operator + SignalConnection( const SignalConnection& ); ///< undefined copy constructor @since_tizen 2.4 + SignalConnection& operator=( const SignalConnection& ); ///< undefined assignment operator @since_tizen 2.4 private: diff --git a/dali/public-api/signals/slot-delegate.h b/dali/public-api/signals/slot-delegate.h index 81f1813..6e2b300 100644 --- a/dali/public-api/signals/slot-delegate.h +++ b/dali/public-api/signals/slot-delegate.h @@ -139,8 +139,8 @@ public: private: - SlotDelegate( const SlotDelegate& ); ///< undefined copy constructor - SlotDelegate& operator=( const SlotDelegate& ); ///< undefined assignment operator + SlotDelegate( const SlotDelegate& ); ///< undefined copy constructor @since_tizen 2.4 + SlotDelegate& operator=( const SlotDelegate& ); ///< undefined assignment operator @since_tizen 2.4 private: diff --git a/doc/dali_doc.h b/doc/dali_doc.h index 628da4d..8ca288f 100644 --- a/doc/dali_doc.h +++ b/doc/dali_doc.h @@ -1,12 +1,77 @@ #ifndef __DALI_DOC_H__ #define __DALI_DOC_H__ +/* + * 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. + * + */ + /** * @defgroup dali_core DALi Core * - * @brief This module provides scene graph-based rendering, animation, and event handling. + * @brief DALi Core provides core functionalities such as scene graph-based rendering, animation, and event handling. + * * It is a base module and forms the biggest part of DALi. * + * @section dali_core_overview Overview + * + * DALi Core consists of the following groups of API: + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
API GroupDescription
@ref dali_core_actorsActor is the primary object for interaction in DALi applications.
@ref dali_core_animationAnimation allows your objects to move around / change their properties for a specified duration.
@ref dali_core_commonCommon classes for using DALi.
@ref dali_core_eventsInput events and gestures supported by DALi.
@ref dali_core_imagesClasses for handling images.
@ref dali_core_mathBasic math classes.
@ref dali_core_objectClasses for the handle/body pattern and property system.
@ref dali_core_rendering_effectsRender task and shader effect classes.
@ref dali_core_signalsClasses for the signal and slot structure.
+ * * @ingroup dali * @{ * @defgroup dali_core_actors Actors @@ -30,10 +95,10 @@ * @defgroup dali_core_object Object * @brief Classes for the handle/body pattern and property system. - * @defgroup dali_core_rendering_effects Rendering & Effects + * @defgroup dali_core_rendering_effects Rendering & Effect * @brief Render task and shader effect classes. - * @defgroup dali_core_signals Signals + * @defgroup dali_core_signals Signal * @brief Classes for the signal and slot structure. * @} */ -- 2.7.4