/**
* The status of the Core::Update operation.
*/
-class DALI_IMPORT_API UpdateStatus
+class UpdateStatus
{
public:
/**
* The status of the Core::Render operation.
*/
-class DALI_IMPORT_API RenderStatus
+class RenderStatus
{
public:
/**
* A Glyph holds information for a single character.
*/
-struct DALI_IMPORT_API GlyphMetrics
+struct GlyphMetrics
{
enum GlyphQuality
{
/**
* Stores font global metrics.
*/
-struct DALI_IMPORT_API GlobalMetrics
+struct GlobalMetrics
{
GlobalMetrics()
: lineHeight( 0.f ),
/**
* The abstract base class for resource types.
*/
-struct DALI_IMPORT_API ResourceType
+struct ResourceType
{
/**
* Constructor.
* BitmapResourceType describes a bitmap resource, which can be requested
* from ResourceLoader::LoadResource() or AllocateBitmapImage.
*/
-struct DALI_IMPORT_API BitmapResourceType : public ResourceType
+struct BitmapResourceType : public ResourceType
{
/**
* Constructor.
* through ResourceManager::AddNativeImage() or requested through ResourceLoader::LoadResource().
* If the adaptor does not support NativeImages, it can fall back to Bitmap type.
*/
-struct DALI_IMPORT_API NativeImageResourceType : public ResourceType
+struct NativeImageResourceType : public ResourceType
{
/**
* Constructor.
* RenderTargetResourceType describes a bitmap resource, which can injected
* through ResourceManager::AddTargetImage()
*/
-struct DALI_IMPORT_API RenderTargetResourceType : public ResourceType
+struct RenderTargetResourceType : public ResourceType
{
/**
* Constructor.
* ShaderResourceType describes a shader program resource, which can be requested
* from PlatformAbstraction::LoadResource()
*/
-struct DALI_IMPORT_API ShaderResourceType : public ResourceType
+struct ShaderResourceType : public ResourceType
{
/**
* Constructor.
* TextResourceType describes a font resource, which can be requested.
* from PlatformAbstraction::LoadResource() No font atlas is created.
*/
-struct DALI_IMPORT_API TextResourceType : public ResourceType
+struct TextResourceType : public ResourceType
{
/**
* Text quality enum
* ModelResourceType describes a model resource, which can be requested
* from PlatformAbstraction::LoadResource()
*/
-struct DALI_IMPORT_API ModelResourceType : public ResourceType
+struct ModelResourceType : public ResourceType
{
/**
* Constructor.
* MeshResourceType describes a mesh program resource, which can be created
* using ResourceManager::AllocateMesh.
*/
-struct DALI_IMPORT_API MeshResourceType : public ResourceType
+struct MeshResourceType : public ResourceType
{
/**
* Constructor.
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
#include <dali/public-api/object/constrainable.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* actor.Unparent() will be called, followed by actor.Reset().
* @param[in,out] actor A handle to an actor, or an empty handle.
*/
-void UnparentAndReset( Actor& actor );
+ DALI_IMPORT_API void UnparentAndReset( Actor& actor );
} // namespace Dali
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace BlendingMode
} // namespace BlendingEquation
-extern const BlendingFactor::Type DEFAULT_BLENDING_SRC_FACTOR_RGB; ///< BlendingFactor::SRC_ALPHA
-extern const BlendingFactor::Type DEFAULT_BLENDING_DEST_FACTOR_RGB; ///< BlendingFactor::ONE_MINUS_SRC_ALPHA
-extern const BlendingFactor::Type DEFAULT_BLENDING_SRC_FACTOR_ALPHA; ///< BlendingFactor::ONE
-extern const BlendingFactor::Type DEFAULT_BLENDING_DEST_FACTOR_ALPHA; ///< BlendingFactor::ONE_MINUS_SRC_ALPHA
+DALI_IMPORT_API extern const BlendingFactor::Type DEFAULT_BLENDING_SRC_FACTOR_RGB; ///< BlendingFactor::SRC_ALPHA
+DALI_IMPORT_API extern const BlendingFactor::Type DEFAULT_BLENDING_DEST_FACTOR_RGB; ///< BlendingFactor::ONE_MINUS_SRC_ALPHA
+DALI_IMPORT_API extern const BlendingFactor::Type DEFAULT_BLENDING_SRC_FACTOR_ALPHA; ///< BlendingFactor::ONE
+DALI_IMPORT_API extern const BlendingFactor::Type DEFAULT_BLENDING_DEST_FACTOR_ALPHA; ///< BlendingFactor::ONE_MINUS_SRC_ALPHA
-extern const BlendingEquation::Type DEFAULT_BLENDING_EQUATION_RGB; ///< BlendingEquation::ADD
-extern const BlendingEquation::Type DEFAULT_BLENDING_EQUATION_ALPHA; ///< BlendingEquation::ADD
+DALI_IMPORT_API extern const BlendingEquation::Type DEFAULT_BLENDING_EQUATION_RGB; ///< BlendingEquation::ADD
+DALI_IMPORT_API extern const BlendingEquation::Type DEFAULT_BLENDING_EQUATION_ALPHA; ///< BlendingEquation::ADD
} // namespace Dali
#include <dali/public-api/actors/actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* in world coordinates.
*
*/
-class CameraActor : public Actor
+class DALI_IMPORT_API CameraActor : public Actor
{
public:
#include <dali/public-api/object/property.h>
#include <dali/public-api/object/ref-object.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/custom-actor-impl.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace DrawMode
#include <dali/public-api/math/rect.h>
#include <dali/public-api/images/image.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/images/frame-buffer-image.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
#include <dali/public-api/common/light.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
// INTERNAL INCLUDES
#include <dali/public-api/actors/renderable-actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Material;
class Mesh;
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
#include <dali/public-api/actors/blending.h>
#include <dali/public-api/actors/sampling.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
{
* @param [in] actor root of a tree of actors.
* @param [in] effect The shader effect.
*/
-void SetShaderEffectRecursively( Actor actor, ShaderEffect effect );
+DALI_IMPORT_API void SetShaderEffectRecursively( Actor actor, ShaderEffect effect );
/**
* @brief Removes the shader effect from all RenderableActors in a tree of Actors.
*
* @param [in] actor root of a tree of actors.
*/
-void RemoveShaderEffectRecursively( Actor actor );
+DALI_IMPORT_API void RemoveShaderEffectRecursively( Actor actor );
} // namespace Dali
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace FilterMode
#include <dali/public-api/text/text-style.h>
#include <dali/public-api/text/text.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct TextActorParameters;
* @param[in] location - the location of the assertion
* @param[in] condition - The assertion condition
*/
- DALI_IMPORT_API DaliException(const char *location, const char* condition);
+ DaliException(const char *location, const char* condition);
std::string mLocation; ///< Location in code of the assertion
std::string mCondition; ///< The assertion string
/**
* The top level DALi namespace
*/
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief Encapsulates the data describing a light source.
*/
-class Light : public BaseHandle
+class DALI_IMPORT_API Light : public BaseHandle
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* Multiple stage/window support is not currently provided.
*/
-class Stage : public BaseHandle
+class DALI_IMPORT_API Stage : public BaseHandle
{
public:
*
*/
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h>
+
namespace Dali
{
-extern const unsigned int CORE_MAJOR_VERSION; ///< The major version number of the Core library.
-extern const unsigned int CORE_MINOR_VERSION; ///< The minor version number of the Core library.
-extern const unsigned int CORE_MICRO_VERSION; ///< The micro version number of the Core library.
-extern const char * const CORE_BUILD_DATE; ///< The date/time the Core library was built.
+DALI_IMPORT_API extern const unsigned int CORE_MAJOR_VERSION; ///< The major version number of the Core library.
+DALI_IMPORT_API extern const unsigned int CORE_MINOR_VERSION; ///< The minor version number of the Core library.
+DALI_IMPORT_API extern const unsigned int CORE_MICRO_VERSION; ///< The micro version number of the Core library.
+DALI_IMPORT_API extern const char * const CORE_BUILD_DATE; ///< The date/time the Core library was built.
} // namespace Dali
#endif // __DALI_CORE_VERSION_H__
// INTERNAL INCLUDES
#include <dali/public-api/dynamics/dynamics-shape.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class DynamicsWorld;
struct Vector3;
*
* Use to create multiple instances of a DynamicsBody
*/
-class DynamicsBodyConfig : public BaseHandle
+class DALI_IMPORT_API DynamicsBodyConfig : public BaseHandle
{
public:
// BASE CLASS INCLUDES
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* The body is defined with a shape giving it dimension enabling it to collide with other bodies.
*/
-class DynamicsBody : public BaseHandle
+class DALI_IMPORT_API DynamicsBody : public BaseHandle
{
public:
/**
// BASE CLASS INCLUDES
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
/**
* @brief Contains information about a collision between two actors.
*/
-class DynamicsCollision : public BaseHandle
+class DALI_IMPORT_API DynamicsCollision : public BaseHandle
{
public:
/**
// BASE CLASS INCLUDES
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
{
/**
* @brief Represents a connection (or constraint) relationship between two dynamic bodies.
*/
-class DynamicsJoint : public BaseHandle
+class DALI_IMPORT_API DynamicsJoint : public BaseHandle
{
public:
/**
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/geometry/cloth.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief Defines the shape of an object in the simulation.
*/
-class DynamicsShape : public BaseHandle
+class DALI_IMPORT_API DynamicsShape : public BaseHandle
{
public:
/**
// BASE CLASS INCLUDES
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector3;
/**
* @brief Describes the requirements/capabilities of a physics siumlation encapsulated by a DynamicsWorld.
*/
-class DynamicsWorldConfig : public BaseHandle
+class DALI_IMPORT_API DynamicsWorldConfig : public BaseHandle
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* dynamicsRootActor.Add( actor );
* @endcode
*/
-class DynamicsWorld : public BaseHandle
+class DALI_IMPORT_API DynamicsWorld : public BaseHandle
{
public:
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/object/handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* @see Gesture
*/
-class GestureDetector : public Handle
+class DALI_IMPORT_API GestureDetector : public Handle
{
public: // Creation & Destruction
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
*
* @note An instance of this class cannot be created.
*/
-struct Gesture
+struct DALI_IMPORT_API Gesture
{
/**
* @brief Copy constructor.
#include <dali/public-api/common/stage.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class RenderTask;
* @param[out] results The results of the hit-test.
* @param[in] func The function to use in the hit-test algorithm.
*/
-void HitTest( Stage stage, const Vector2& screenCoordinates, Results& results, HitTestFunction func );
+DALI_IMPORT_API void HitTest( Stage stage, const Vector2& screenCoordinates, Results& results, HitTestFunction func );
/**
* @brief Hit test specific to a given RenderTask.
* @param[out] results The results of the hit-test.
* @param[in] func The function to use in the hit-test algorithm.
*/
-void HitTest( RenderTask& renderTask, const Vector2& screenCoordinates, Results& results, HitTestFunction func );
+DALI_IMPORT_API void HitTest( RenderTask& renderTask, const Vector2& screenCoordinates, Results& results, HitTestFunction func );
} // namespace HitTestAlgorithm
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/events/touch-point.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* IMF keyboard to Core. In future IMF may communicate via its own
* module.
*/
-struct KeyEvent
+struct DALI_IMPORT_API KeyEvent
{
// Enumerations
#include <dali/public-api/events/gesture-detector.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* @see LongPressGesture
*/
-class LongPressGestureDetector : public GestureDetector
+class DALI_IMPORT_API LongPressGestureDetector : public GestureDetector
{
public: // Typedefs
#include <dali/public-api/events/gesture.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
*
* @see LongPressGestureDetector
*/
-struct LongPressGesture : public Gesture
+struct DALI_IMPORT_API LongPressGesture : public Gesture
{
// Construction & Destruction
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* There is a key modifier which relates to keys like alt, shift and control functions are
* supplied to check if they have been pressed when the mouse wheel is being rolled.
*/
-struct MouseWheelEvent
+struct DALI_IMPORT_API MouseWheelEvent
{
/**
* @brief Default constructor.
#include <dali/public-api/events/gesture-detector.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Radian;
*
* @see PanGesture
*/
-class PanGestureDetector : public GestureDetector
+class DALI_IMPORT_API PanGestureDetector : public GestureDetector
{
public:
#include <dali/public-api/events/gesture.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
*
* A pan gesture will continue to be sent to the actor under than initial pan until it ends.
*/
-struct PanGesture: public Gesture
+struct DALI_IMPORT_API PanGesture: public Gesture
{
// Construction & Destruction
#include <dali/public-api/events/gesture-detector.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* @see PinchGesture
*/
-class PinchGestureDetector : public GestureDetector
+class DALI_IMPORT_API PinchGestureDetector : public GestureDetector
{
public: // Typedefs
#include <dali/public-api/events/gesture.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* A pinch gesture will continue to be sent to the actor under the center point of the pinch
* until the pinch ends.
*/
-struct PinchGesture: public Gesture
+struct DALI_IMPORT_API PinchGesture: public Gesture
{
// Construction & Destruction
#include <dali/public-api/events/gesture-detector.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* @see TapGesture
*/
-class TapGestureDetector : public GestureDetector
+class DALI_IMPORT_API TapGestureDetector : public GestureDetector
{
public: // Typedefs
#include <dali/public-api/events/gesture.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* This is a discrete gesture so does not have any state information.
* @see TapGestureDetector
*/
-struct TapGesture : public Gesture
+struct DALI_IMPORT_API TapGesture : public Gesture
{
// Construction & Destruction
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/events/touch-point.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @brief Touch events are a collection of touch points at a specific moment in time.
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @brief A TouchPoint represents a point on the screen that is currently being touched
* or where touch has stopped.
*/
-struct TouchPoint
+struct DALI_IMPORT_API TouchPoint
{
// Enumerations
#include <dali/public-api/geometry/animatable-vertex.h>
#include <dali/public-api/modeling/material.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class AnimatableVertex;
* It is recommended that the vertices of the mesh remain in the bounds -0.5 - 0.5, which
* will match the actor size boundaries. The origin of the mesh matches the actor's position.
*/
-class AnimatableMesh : public Constrainable
+class DALI_IMPORT_API AnimatableMesh : public Constrainable
{
public:
/**
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class AnimatableMesh;
* mesh[vertex].SetColor(color);
* @endcode
*/
-class AnimatableVertex
+class DALI_IMPORT_API AnimatableVertex
{
public:
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/geometry/mesh.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* @brief A Cloth is a specialized mesh that can be used and modified
* by the Dynamics engine.
*/
-class Cloth : public Mesh
+class DALI_IMPORT_API Cloth : public Mesh
{
public:
// DECLARATION FILES
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Matrix;
* The mesh vertex shader then applies up to 4 weighted transforms to each
* vertex and vertex normal.
*/
-class MeshData
+class DALI_IMPORT_API MeshData
{
public:
static const unsigned int MAX_NUMBER_OF_BONES = 12; ///< Maximum number of bones that can affect this mesh.
* @param[in] textureCoordinates UV coordinates.
* @return A mesh data structure containing the plane mesh
*/
-Dali::MeshData NewPlane( const float width,
- const float height,
- const int xSteps,
- const int ySteps,
- const Rect<float>& textureCoordinates = Rect<float>(0.0f, 0.0f, 1.0f, 1.0f) );
+DALI_IMPORT_API Dali::MeshData NewPlane( const float width,
+ const float height,
+ const int xSteps,
+ const int ySteps,
+ const Rect<float>& textureCoordinates = Rect<float>(0.0f, 0.0f, 1.0f, 1.0f) );
} // MeshFactory
} // Dali
#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* It is used to tell the Scene Graph if the mesh data has changed.
*/
-class Mesh : public BaseHandle
+class DALI_IMPORT_API Mesh : public BaseHandle
{
public:
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/matrix.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Matrix;
* be chosen carefully. (Most useful for animation curves)
*
*/
-class Spline
+class DALI_IMPORT_API Spline
{
public:
/**
#include <dali/public-api/images/image.h>
#include <dali/public-api/math/rect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* If the image is opaque and blending is not required, then the user
* should call ImageActor::SetUseImageAlpha(false) on the containing actor.
*/
-class BitmapImage : public Image
+class DALI_IMPORT_API BitmapImage : public Image
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector2;
* @param[in] maxSize The image is scaled from this size to distanceMapSize
* @param[in] highQuality Set true to generate high quality distance fields
*/
-void GenerateDistanceFieldMap(const unsigned char* const imagePixels, const Vector2& imageSize,
- unsigned char* const distanceMap, const Vector2& distanceMapSize,
- const unsigned int fieldBorder,
- const Vector2& maxSize,
- bool highQuality = true);
+DALI_IMPORT_API void GenerateDistanceFieldMap( const unsigned char* const imagePixels, const Vector2& imageSize,
+ unsigned char* const distanceMap, const Vector2& distanceMapSize,
+ const unsigned int fieldBorder,
+ const Vector2& maxSize,
+ bool highQuality = true);
} //namespace Dali
// INTERNAL INCLUDES
#include <dali/public-api/images/image.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* Image::UploadedSignal is emitted when the decoded image data gets
* uploaded to the OpenGL ES implementation.
*/
-class EncodedBufferImage : public Image
+class DALI_IMPORT_API EncodedBufferImage : public Image
{
public:
/**
#include <dali/public-api/images/image.h>
#include <dali/public-api/math/rect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* The FrameBufferImage can then be used with an ImageActor (with optional shader
* effects) and rendered to the screen.
*/
-class FrameBufferImage : public Image
+class DALI_IMPORT_API FrameBufferImage : public Image
{
public:
/**
#include <dali/public-api/images/image.h>
#include <dali/public-api/text/font.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Character;
/**
* @brief A GlyphImage object is an image resource which represents a character.
*/
-class GlyphImage : public Image
+class DALI_IMPORT_API GlyphImage : public Image
{
public:
/**
#include <dali/public-api/math/rect.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class ImageAttributes;
*
* @note The aspect ratio of image contents is preserved by all scaling modes, so for example squares in input images stay square after loading.
*/
-class ImageAttributes
+class DALI_IMPORT_API ImageAttributes
{
public:
* @param [in] b parameter tested
* @return true if a is less than b
*/
-bool operator<(const ImageAttributes& a, const ImageAttributes& b);
+DALI_IMPORT_API bool operator<(const ImageAttributes& a, const ImageAttributes& b);
/**
* @brief Equal to comparison operator.
* @param [in] b parameter tested for equality
* @return true if a is equal to b
*/
-bool operator==(const ImageAttributes& a, const ImageAttributes& b);
+DALI_IMPORT_API bool operator==(const ImageAttributes& a, const ImageAttributes& b);
/**
* @brief Not equal to comparison operator.
* @param [in] b parameter tested for equality
* @return true if a is not equal to b
*/
-bool operator!=(const ImageAttributes& a, const ImageAttributes& b);
+DALI_IMPORT_API bool operator!=(const ImageAttributes& a, const ImageAttributes& b);
} // namespace Dali
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector2;
* Note: if a resource was shared between Image objects it exists until its last reference is gone.
*
*/
-class Image : public BaseHandle
+class DALI_IMPORT_API Image : public BaseHandle
{
public:
/**
#include <dali/public-api/images/pixel.h>
#include <dali/public-api/object/ref-object.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
virtual ~NativeImage()
{
}
+
};
/**
#include <dali/public-api/images/bitmap-image.h>
#include <dali/public-api/math/rect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* to use the cropped BitmapImage - if you don't retain a handle to this object, it will
* be automatically destroyed.
*/
-class NinePatchImage : public Image
+class DALI_IMPORT_API NinePatchImage : public Image
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @param [in] pixelformat pixel format
* @return true if format has alpha, false otherwise
*/
-bool HasAlpha(Format pixelformat);
+DALI_IMPORT_API bool HasAlpha(Format pixelformat);
/**
* @brief Returns The number of bytes per pixel for the specified pixel format.
* @param [in] pixelFormat The pixel format
* @return The number of bytes per pixel
*/
-unsigned int GetBytesPerPixel(Format pixelFormat);
+DALI_IMPORT_API unsigned int GetBytesPerPixel(Format pixelFormat);
/**
* @brief Returns the offset of the byte containing the alpha mask from the start of the pixel data
* @param[out] byteOffset the byte offset
* @param[out] bitMask the bitmask
*/
-void GetAlphaOffsetAndMask(Format pixelFormat, int& byteOffset, int& bitMask);
+DALI_IMPORT_API void GetAlphaOffsetAndMask(Format pixelFormat, int& byteOffset, int& bitMask);
} //namespace Pixel
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/math/matrix.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Matrix;
* A Bone is a named actor that can be used to deform a mesh. @see Dali::MeshData for more
* information.
*/
-class Bone
+class DALI_IMPORT_API Bone
{
public:
/**
#include <dali/public-api/animation/key-frames.h>
#include <dali/public-api/modeling/entity.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Entity;
* @brief The entity animator map class is a mapping from an entity name to raw animation
* data for that entity, stored in 3 KeyFrames for position, scale and rotation.
*/
-class EntityAnimatorMap
+class DALI_IMPORT_API EntityAnimatorMap
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/geometry/mesh.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Entity;
* It can contain zero or more meshes. The entity names are used for
* cross referencing, e.g. from animations or from bone structures.
*/
-class Entity : public BaseHandle
+class DALI_IMPORT_API Entity : public BaseHandle
{
public:
#include <dali/public-api/images/image.h>
#include <dali/public-api/common/constants.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector4;
*
* Color, opacity, shininess, shading mode, texture/normal/height mapping...
*/
-class Material : public BaseHandle
+class DALI_IMPORT_API Material : public BaseHandle
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/modeling/entity-animator-map.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct ModelAnimationMap;
#include <dali/public-api/modeling/model-animation-map.h>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Entity;
* This is usually generated by an external model loader (and is also
* used internally with the default model loader).
*/
-class ModelData : public BaseHandle
+class DALI_IMPORT_API ModelData : public BaseHandle
{
public:
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class MeshActor;
* Use ModelActorFactory::BuildActorTree() to create actors from this model.
* Use ModelActorFactory::BuildAnimation() to create animations on such actors.
*/
-class Model : public BaseHandle
+class DALI_IMPORT_API Model : public BaseHandle
{
public:
namespace WeightObject
{
-extern const Property::Index WEIGHT; ///< name "weight", type FLOAT
+DALI_IMPORT_API extern const Property::Index WEIGHT; ///< name "weight", type FLOAT
/**
* @brief Convenience function to create an object with a custom "weight" property.
*
* @return A handle to a newly allocated object.
*/
-Constrainable New();
+DALI_IMPORT_API Constrainable New();
} // namespace WeightObject
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class RenderTask;
*
* These tasks describe how the Dali scene should be rendered; @see Dali::RenderTask for more details.
*/
-class RenderTaskList : public BaseHandle
+class DALI_IMPORT_API RenderTaskList : public BaseHandle
{
public:
#include <dali/public-api/object/constrainable.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* 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.
*/
-class RenderTask : public Constrainable
+class DALI_IMPORT_API RenderTask : public Constrainable
{
public:
/**
#include <dali/public-api/animation/active-constraint-declarations.h>
#include <dali/public-api/object/constrainable.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* with the uniform color "uColor" of the node
* </B>
*/
-class ShaderEffect : public Constrainable
+class DALI_IMPORT_API ShaderEffect : public Constrainable
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* This class is provided for convenience. A user can't instantiate Characters directly.
* However, by instantiating a Text object, Characters are returned by Text::operator[].
*/
-class Character
+class DALI_IMPORT_API Character
{
public:
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/text/text.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
*
* This reduces ambiguity when using methods which accept size in pixels or points.
*/
-struct PointSize
+struct DALI_IMPORT_API PointSize
{
/**
* @brief Create size in points.
*
* This reduces ambiguity when using methods which accept size in pixels or points.
*/
-struct PixelSize
+struct DALI_IMPORT_API PixelSize
{
/**
* @brief Create size in pixels.
/**
* @brief Font size in Caps height
*/
-struct CapsHeight
+struct DALI_IMPORT_API CapsHeight
{
/**
* @brief Size in CapsHeight
/**
* @brief Encapsulates all font parameters.
*/
-struct FontParameters
+struct DALI_IMPORT_API FontParameters
{
/**
* @brief Default constructor.
};
-extern FontParameters DEFAULT_FONT_PARAMETERS; ///< Used to choose the platform's font parameters
+DALI_IMPORT_API extern FontParameters DEFAULT_FONT_PARAMETERS; ///< Used to choose the platform's font parameters
} // namespace Dali
#include <dali/public-api/text/font-parameters.h>
#include <dali/public-api/text/text.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector3;
*
* Fonts will be created from a font name (like courier or comic) and font size (specified in points).
*/
-class Font : public BaseHandle
+class DALI_IMPORT_API Font : public BaseHandle
{
public:
/**
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
// Forward declarations
/**
* @brief Encapsulates text-actor parameters.
*/
-struct TextActorParameters
+struct DALI_IMPORT_API TextActorParameters
{
/**
* @brief Enumeration of the automatic font detection medes.
Impl* mImpl;
};
-extern TextActorParameters DEFAULT_TEXT_ACTOR_PARAMETERS; ///< By default the text style is the default one and the automatic font detection is enabled.
+DALI_IMPORT_API extern TextActorParameters DEFAULT_TEXT_ACTOR_PARAMETERS; ///< By default the text style is the default one and the automatic font detection is enabled.
} // namespace Dali
#include <dali/public-api/text/character.h>
#include <dali/public-api/common/dali-vector.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief Encapsulates a string of characters implementation to support multiple languages.
*/
-class Text
+class DALI_IMPORT_API Text
{
public:
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @brief Determine the length (in bytes) of a UTF-8 character.
projects / platform / core / uifw / dali-core.git / commitdiff