#include <dali/public-api/math/degree.h>
#include <dali/public-api/math/vector3.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Radian;
// EXTERNAL INCLUDES
#include <cstddef>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
template <bool x> struct CompileTimeAssertBool; ///< Bool Template to test condition
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @brief Compile time template to calculate base to the power of N.
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Radian;
// INTERNAL INCLUDES
#include <dali/public-api/math/vector4.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Quaternion;
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/matrix.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Matrix;
#include <dali/public-api/common/constants.h>
#include <dali/public-api/math/vector4.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
// Forward declaration
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Degree;
// INTERNAL INCLUDES
#include <dali/public-api/math/vector4.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
// INTERNAL INCLUDES
#include <dali/public-api/math/math-utils.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
{
struct Vector3;
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector2;
* @param [in] source size
* @return target scaled inside source
*/
-Vector3 ShrinkInsideKeepAspectRatio( const Vector3& target, const Vector3& source );
+DALI_IMPORT_API Vector3 ShrinkInsideKeepAspectRatio( const Vector3& target, const Vector3& source );
} // namespace Dali
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector2;
struct Vector3;
// INTERNAL INCLUDES
#include <dali/public-api/math/rect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
return GetImplementation(*this).DoConnectSignal( connectionTracker, signalName, functor );
}
-bool operator<(const BaseHandle& lhs, const BaseHandle& rhs)
-{
- return lhs.GetObjectPtr() < rhs.GetObjectPtr();
-}
-
} // namespace Dali
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/signals/functor-delegate.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class BaseObject;
* A resource will not be deleted until all its Dali::BaseHandle handles are destroyed, or reset.
*
*/
-class BaseHandle
+class DALI_IMPORT_API BaseHandle
{
public:
private:
IntrusivePtr<Dali::RefObject> mObjectHandle; ///< Object this handle points at.
+
};
/**
* @return handle pointer to either a valid deriving handle or an uninitialized handle
*/
template< class T >
-T DownCast( BaseHandle handle )
+inline T DownCast( BaseHandle handle )
{
return T::DownCast( handle );
}
* @brief Equality operator
*/
template <typename T>
-bool operator==(const BaseHandle& lhs, const T& rhs)
+inline bool operator==(const BaseHandle& lhs, const T& rhs)
{
// We depart from the safe bool idiom to allow Dali::BaseHandle derived classes to be compared
return lhs == static_cast<const BaseHandle&>(rhs);
* @brief Equality operator
*/
template <typename T>
-bool operator!=(const BaseHandle& lhs, const T& rhs)
+inline bool operator!=(const BaseHandle& lhs, const T& rhs)
{
// We depart from the safe bool idiom to allow Dali::BaseHandle derived classes to be compared
return lhs != static_cast<const BaseHandle&>(rhs);
}
-// More Operators
-
/**
* @brief Less than operator
*/
-bool operator<(const BaseHandle& lhs, const BaseHandle& rhs);
+inline bool operator<(const BaseHandle& lhs, const BaseHandle& rhs)
+{
+ return lhs.GetObjectPtr() < rhs.GetObjectPtr();
+}
} // namespace Dali
#include <dali/public-api/object/property.h>
#include <dali/public-api/signals/functor-delegate.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class BaseHandle;
/**
* @brief A base class for objects.
*/
-class BaseObject : public Dali::RefObject
+class DALI_IMPORT_API BaseObject : public Dali::RefObject
{
public:
namespace Dali DALI_IMPORT_API
{
-namespace Internal DALI_INTERNAL
+namespace Internal
{
class Object;
}
* @brief Dali::Constrainable is a handle to an internal property owning Dali object that
* can have constraints applied to it.
*/
-class Constrainable : public Handle
+class DALI_IMPORT_API Constrainable : public Handle
{
public:
#include <dali/public-api/object/property-notification-declarations.h>
#include <dali/public-api/object/ref-object.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class PropertyNotification;
/**
* @brief Dali::Handle is a handle to an internal property owning Dali object.
*/
-class Handle : public BaseHandle
+class DALI_IMPORT_API Handle : public BaseHandle
{
public:
#include <dali/public-api/object/handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* registry.ObjectCreatedSignal().Connect( ObjectCreatedCallbackFunc );
*
*/
-class ObjectRegistry : public BaseHandle
+class DALI_IMPORT_API ObjectRegistry : public BaseHandle
{
public:
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/property.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief This represents a condition that can be evaluated on a Property::Value.
*/
-class PropertyCondition : public BaseHandle
+class DALI_IMPORT_API PropertyCondition : public BaseHandle
{
public:
* @param[in] arg The argument for the condition
* @return A property condition function object
*/
-PropertyCondition LessThanCondition(float arg);
+DALI_IMPORT_API PropertyCondition LessThanCondition(float arg);
/**
* @brief GreaterThanCondition compares whether property is greater than arg.
* @param[in] arg The argument for the condition
* @return A property condition function object
*/
-PropertyCondition GreaterThanCondition(float arg);
+DALI_IMPORT_API PropertyCondition GreaterThanCondition(float arg);
/**
* @brief InsideCondition compares whether property is greater than arg0 and less than arg1.
* @param[in] arg1 The second argument for the condition
* @return A property condition function object
*/
-PropertyCondition InsideCondition(float arg0, float arg1);
+DALI_IMPORT_API PropertyCondition InsideCondition(float arg0, float arg1);
/**
* @brief OutsideCondition compares whether property is less than arg0 or greater than arg1.
* @param[in] arg1 The second argument for the condition
* @return A property condition function object
*/
-PropertyCondition OutsideCondition(float arg0, float arg1);
+DALI_IMPORT_API PropertyCondition OutsideCondition(float arg0, float arg1);
/**
* @brief Detects when a property changes by stepAmount from initialValue, in both positive and negative directions. This will continue checking for multiples of stepAmount
* @param[in] initialValue The initial value to step from
* @return A property condition function object
*/
-PropertyCondition StepCondition(float stepAmount, float initialValue = 0.0f);
+DALI_IMPORT_API PropertyCondition StepCondition(float stepAmount, float initialValue = 0.0f);
/**
* @brief Receive notifications as a property goes above/below the inputted values. Values must be ordered and can be either ascending or descending
* @param[in] steps List of values to receive notifications for as a property crosses them
* @return A property condition function object
*/
-PropertyCondition VariableStepCondition(const std::vector<float>& steps);
+DALI_IMPORT_API PropertyCondition VariableStepCondition(const std::vector<float>& steps);
} // namespace Dali
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
// INTERNAL INCLUDES
#include <dali/public-api/object/property.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector2;
/**
* @brief An abstract interface for receiving property values.
*/
-class PropertyInput
+class DALI_IMPORT_API PropertyInput
{
public:
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class PropertyNotification;
#include <dali/public-api/object/property-conditions.h>
#include <dali/public-api/object/property.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/property.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @param [in] type The property type.
* @return The name of this type.
*/
-const char* GetName(Property::Type type);
+DALI_IMPORT_API const char* GetName(Property::Type type);
/**
* @brief Retrieve an enumerated property type.
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Handle;
/**
* @brief An object + property pair.
*/
-struct Property
+struct DALI_IMPORT_API Property
{
/**
* @brief A valid property index is zero or greater.
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/intrusive-ptr.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Value;
* Typically this should be used with a Boost instrusive pointer,
* instead of calling Reference() and Unreference() methods directly.
*/
-class RefObject
+class DALI_IMPORT_API RefObject
{
public:
// INTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class ConnectionTrackerInterface;
*
* See TypeRegistry for methods of type registration and TypeInfo retrieval.
*/
-class TypeInfo : public BaseHandle
+class DALI_IMPORT_API TypeInfo : public BaseHandle
{
public:
typedef BaseHandle (*CreateFunction)(); ///< Function signature for creating an instance of the associated object type.
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/type-info.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* separated ie 'next-page'. This maintains consistency with the scripted interface.
*
*/
-class TypeRegistry : public BaseHandle
+class DALI_IMPORT_API TypeRegistry : public BaseHandle
{
public:
typedef std::vector<std::string> NameContainer; ///< Container of type names
/**
* @brief Register a type from type info.
*/
-class TypeRegistration
+class DALI_IMPORT_API TypeRegistration
{
public:
/**
/**
* @brief Register a signal connector function to a registered type.
*/
-class SignalConnectorType
+class DALI_IMPORT_API SignalConnectorType
{
public:
/**
/**
* @brief Register an action function.
*/
-class TypeAction
+class DALI_IMPORT_API TypeAction
{
public:
/**
/**
* @brief Register a property for the given type.
*/
-class PropertyRegistration
+class DALI_IMPORT_API PropertyRegistration
{
public:
#include <dali/public-api/object/property-map.h>
#include <dali/public-api/object/property-value.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* @param[in] enumString The enum string
* @return true if the strings are equal as defined above
*/
-bool CompareEnums(const std::string& input, const std::string& enumString);
+DALI_IMPORT_API bool CompareEnums(const std::string& input, const std::string& enumString);
/**
* @brief Set the value if strings pass a permissive compare.
* @param[in] value The input string
* @return The corresponding color-mode.
*/
-ColorMode GetColorMode( const std::string& value );
+DALI_IMPORT_API ColorMode GetColorMode( const std::string& value );
/**
* @brief Takes a color mode and returns the appropriate string equivalent.
* @param[in] value The color mode
* @return The corresponding string.
*/
-std::string GetColorMode( ColorMode value );
+DALI_IMPORT_API std::string GetColorMode( ColorMode value );
/**
* @brief Takes a string and returns the appropriate position inheritance mode.
* @param[in] value The input string
* @return The corresponding position-inheritance-mode.
*/
-PositionInheritanceMode GetPositionInheritanceMode( const std::string& value );
+DALI_IMPORT_API PositionInheritanceMode GetPositionInheritanceMode( const std::string& value );
/**
* @brief Takes a position inheritance mode and returns the string equivalent.
* @param[in] value The position-inheritance-mode.
* @return The corresponding string.
*/
-std::string GetPositionInheritanceMode( PositionInheritanceMode value );
+DALI_IMPORT_API std::string GetPositionInheritanceMode( PositionInheritanceMode value );
/**
* @brief Takes a string and returns the appropriate draw mode.
* @param[in] value The input string
* @return The corresponding draw-mode.
*/
-DrawMode::Type GetDrawMode( const std::string& value );
+DALI_IMPORT_API DrawMode::Type GetDrawMode( const std::string& value );
/**
* @brief Takes a draw-mode and returns the string equivalent.
* @param[in] value The draw-mode.
* @return The corresponding string.
*/
-std::string GetDrawMode( DrawMode::Type value );
+DALI_IMPORT_API std::string GetDrawMode( DrawMode::Type value );
/**
* @brief Takes a string and returns the appropriate anchor-point or parent-origin constant.
* @param[in] value The input string
* @return The corresponding anchor-point or parent-origin constant.
*/
-Vector3 GetAnchorConstant( const std::string& value );
+DALI_IMPORT_API Vector3 GetAnchorConstant( const std::string& value );
/**
* @brief Creates object with data from the property value map.
*
* @return a pointer to a newly created object.
*/
-Image NewImage( const Property::Value& map );
+DALI_IMPORT_API Image NewImage( const Property::Value& map );
/**
* @brief Creates object with data from the property value map.
*
* @return a pointer to a newly created object.
*/
-ShaderEffect NewShaderEffect( const Property::Value& map );
+DALI_IMPORT_API ShaderEffect NewShaderEffect( const Property::Value& map );
/**
* @brief Creates an actor with the date from the property value map.
*
* @return Handle to the newly created actor.
*/
-Actor NewActor( const Property::Map& map );
+DALI_IMPORT_API Actor NewActor( const Property::Map& map );
/**
* @brief Creates a Property::Map from the actor provided.
* @param[in] actor The base-actor from which a Property::Map should be created
* @param[out] map This map is cleared and a property map of actor and its children is filled in
*/
-void CreatePropertyMap( Actor actor, Property::Map& map );
+DALI_IMPORT_API void CreatePropertyMap( Actor actor, Property::Map& map );
/**
* @brief Creates a Property::Map from the image provided.
* @param[in] image The image from which a Property::Map should be created
* @param[out] map This map is cleared and a property map of the image is filled in
*/
-void CreatePropertyMap( Image image, Property::Map& map );
+DALI_IMPORT_API void CreatePropertyMap( Image image, Property::Map& map );
}
projects / platform / core / uifw / dali-core.git / commitdiff