platform_abstraction_src_dir = ../../../dali/integration-api
include ../../../dali/integration-api/file.list
+package_doxy_dir = ../../../doc
+include ../../../doc/file.list
+
# Build the Dali libtool library
src_files = $(internal_src_files) \
CLEANFILES = dali-shaders.cpp \
dali-shaders.h
+# package doxygen file (contains doxygen grouping information)
+packagedoxydir = $(devincludepath)/dali/doc
+packagedoxy_HEADERS = $(package_doxy_files)
+
# linking test
noinst_PROGRAMS = linker.test
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
/**
* @brief Actor color mode.
};
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_ACTOR_ENUMERATIONS_H__
#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
* | show | %SetVisible( true ) |
* | hide | %SetVisible( false ) |
*/
+
class DALI_IMPORT_API Actor : public Handle
{
public:
}
}
-
-
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_ACTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace BlendingMode
{
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
#endif // __DALI_BLENDING_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
class CameraActor;
}
-
namespace Camera
{
/**
explicit DALI_INTERNAL CameraActor(Internal::CameraActor* actor);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CAMERA_ACTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
struct Vector2;
struct Vector3;
-
/**
* @brief Pointer to Dali::CustomActorImpl object.
*/
ActorFlags mFlags :ACTOR_FLAG_COUNT; ///< ActorFlags flags to determine behaviour
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CUSTOM_ACTOR_IMPL_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
CustomActor(Internal::CustomActor* actor);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CUSTOM_ACTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace DrawMode
{
} // namespace DrawMode
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_DRAW_MODE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
*/
DALI_IMPORT_API void RemoveShaderEffectRecursively( Actor actor );
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_IMAGE_ACTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL Layer(Internal::Layer* Layer);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif //__DALI_LAYER_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-actors
+ * @{
+ */
namespace FilterMode
{
} //namespace FilterMode
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_SAMPLING_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
typedef float (*AlphaFunctionPrototype)(float progress); ///< Prototype of an alpha function
Mode mMode : 2; //< Enum indicating the functioning mode of the AlphaFunction
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_ALPHA_FUNCTION_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
class Actor;
struct Property;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_ANIMATION_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
/**
* @brief Constraint source types.
Handle object; ///< The target object; only valid if sourceType == OBJECT_PROPERTY
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CONSTRAINT_SOURCE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
class Handle;
static Constraint New( Handle handle, Property::Index targetIndex, Property::Type targetType, CallbackBase* function );
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CONSTRAINT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
/**
* @brief EqualToConstraint
current = Quaternion( vX, vY, vForward );
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CONSTRAINTS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL KeyFrames(Internal::KeyFrames* keyFrames);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_KEY_FRAMES_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
class LinearConstrainer;
}
+
/**
* @brief
*
explicit DALI_INTERNAL LinearConstrainer(Internal::LinearConstrainer* pathConstrainer);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_LINEAR_CONSTRAINER_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
class Path;
}
+
/**
* @brief A 3D parametric curve
*
explicit DALI_INTERNAL Path(Internal::Path* path);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_KEY_FRAMES_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-animation
+ * @{
+ */
/**
* @brief A value-type representing a period of time within an animation.
float durationSeconds; ///< The duration of the time period in seconds
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_TIME_PERIOD_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
template <bool x> struct CompileTimeAssertBool; ///< Bool Template to test condition
template <> struct CompileTimeAssertBool<true> {}; ///< Specialize for true, but not for false
*/
#define DALI_COMPILE_TIME_ASSERT( x ) typedef CompileTimeAssertInt< sizeof( CompileTimeAssertBool< ( x ) > ) > CompileTimeAssertType __attribute__((__unused__))
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_COMPILE_TIME_ASSERT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
/**
* @brief ParentOrigin constants
} // namespace Math
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CONSTANTS_H__
#ifdef EMSCRIPTEN
#include <emscripten/emscripten.h>
#endif
+
/*
* Definitions for shared library support
*
*/
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
/**
* @brief Method to log assertion message in DALI_ASSERT_ALWAYS macro below.
const char* condition;
};
+/**
+ * @}
+ */
}// Dali
/**
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
/**
* @brief Base class to handle the memory of simple vector.
}
};
+/**
+ * @}
+ */
} // namespace Dali
#endif /* __DALI_VECTOR_H__ */
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
/**
* @brief Templated intrusive pointer class
return lhs != rhs.Get();
}
+/**
+ * @}
+ */
} // namespace Dali
#endif /* __DALI_INTRUSIVE_PTR_H__ */
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
/**
* @brief The status during resource loading operations.
ResourceLoadingFailed ///< The resource failed to load
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_LOADING_STATE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL Stage(Internal::Stage* stage);
};
+/**
+ * @}
+ */
+
} // namespace Dali
#endif // __DALI_STAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
/**
* @brief Basic type traits that every type has by default
{
};
+/**
+ * @}
+ */
} // namespace Dali
#endif /* __DALI_TYPE_TRAITS_H__ */
namespace Dali
{
+/**
+ * @addtogroup dali-core-common
+ * @{
+ */
/**
* Stereoscopic view modes
STEREO_INTERLACED ///< Stereoscopic. Left/Right camera views are rendered into the framebuffer on alternate frames.
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_VIEW_MODE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL GestureDetector(Internal::GestureDetector* internal);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_GESTURE_DETECTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief Base structure for different gestures that an application can receive.
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_GESTURE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief Hover events are a collection of touch points at a specific moment in time.
const TouchPoint& GetPoint(unsigned int point) const;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_HOVER_EVENT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief The key event structure is used to store a key press.
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_KEY_EVENT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_LONG_PRESS_GESTURE_DETECTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief A LongPressGesture is emitted when the user touches and holds the screen with the stated number of fingers.
Vector2 localPoint;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_LONG_PRESS_GESTURE_H__
struct PanGesture;
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
+
/**
* @brief This class looks for panning (or dragging) gestures.
*
};
+/**
+ * @}
+ */
+
} // namespace Dali
#endif // __DALI_PAN_GESTURE_DETECTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief A PanGesture is emitted when the user moves one or more fingers in a particular direction.
float GetScreenDistance() const;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PAN_GESTURE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PINCH_GESTURE_DETECTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief A PinchGesture is emitted when the user moves two fingers towards or away from each other.
Vector2 localCenterPoint;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PINCH_GESTURE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL TapGestureDetector(Internal::TapGestureDetector* internal);
};
+/**
+ * @}
+ */
+
} // namespace Dali
#endif // __DALI_TAP_GESTURE_DETECTOR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief A TapGesture is emitted when the user taps the screen with the stated number of fingers a stated number of times.
Vector2 localPoint;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_TAP_GESTURE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
+
/**
* @brief Touch events are a collection of touch points at a specific moment in time.
*
const TouchPoint& GetPoint(unsigned int point) const;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_TOUCH_EVENT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief A TouchPoint represents a point on the screen that is currently being touched
typedef TouchPointContainer::iterator TouchPointContainerIterator; ///< Iterator for Dali::TouchPointContainer
typedef TouchPointContainer::const_iterator TouchPointContainerConstIterator; ///< Const iterator for Dali::TouchPointContainer
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_TOUCH_POINT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-events
+ * @{
+ */
/**
* @brief The wheel event structure is used to store a wheel rolling, it facilitates
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_WHEEL_EVENT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL BufferImage(Internal::BufferImage*);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_BUFFER_IMAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL EncodedBufferImage(Internal::EncodedBufferImage*);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_ENCODED_BUFFER_IMAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL FrameBufferImage(Internal::FrameBufferImage*);
}; //class FrameBufferImage
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_FRAME_BUFFER_IMAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
/**
* @brief The integer dimensions of an image or a region of an image packed into
const Type DEFAULT = BOX;
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_IMAGE_OPERATIONS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL Image(Internal::Image*);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_IMAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
/**
* @brief Abstract interface to provide platform-specific support for handling image data.
*/
typedef IntrusivePtr<NativeImageInterface> NativeImageInterfacePtr;
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_INTEGRATION_NATIVE_IMAGE_INTERFACE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_NATIVE_IMAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
class NinePatchImage;
}
-
/**
* @brief NinePatchImage represents an image resource that can be added to ImageActors.
* It contains a bitmap that is synchronously loaded from the file system that contains
explicit DALI_INTERNAL NinePatchImage(Internal::NinePatchImage*);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_NINE_PATCH_IMAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
/**
* @brief Pixel format types and their properties.
} //namespace Pixel
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PIXEL_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-images
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL ResourceImage( Internal::ResourceImage* );
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_RESOURCE_IMAGE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
struct Radian;
return (lhs.angle == rhs.angle) && (lhs.axis == rhs.axis);
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_ANGLE_AXIS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
+
/**
* @brief Compile time template to calculate base to the power of N.
*
#endif
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_COMPILE_TIME_MATH_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
struct Radian;
return Degree( Clamp<float>( angle.degree, min, max ) );
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_DEGREE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
/**
* @brief Returns the next power of two.
return vect;
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_MATH_UTILS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
+
class Quaternion;
/**
// Allow Matrix to be treated as a POD type
template <> struct TypeTraits< Matrix > : public BasicTypes< Matrix > { enum { IS_TRIVIAL_TYPE = true }; };
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_MATRIX_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
class Matrix;
struct Vector2;
// Allow Matrix3 to be treated as a POD type
template <> struct TypeTraits< Matrix3 > : public BasicTypes< Matrix3 > { enum { IS_TRIVIAL_TYPE = true }; };
+/**
+ * @}
+ */
} // namespace Dali
#endif //__DALI_MATRIX3_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
// Forward declaration
class Matrix;
// Allow Quaternion to be treated as a POD type
template <> struct TypeTraits< Quaternion > : public BasicTypes< Quaternion > { enum { IS_TRIVIAL_TYPE = true }; };
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_QUATERNION_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
/**
* @brief An angle in radians.
return Radian( Clamp<float>( angle.radian, min, max ) );
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_RADIAN_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
/**
* @brief Provides methods to generate and use random values.
} // namespace Random
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_RANDOM_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
/**
* @brief Template class to create and operate on rectangles.
*/
+
template< typename T = float >
struct Rect
{
return stream << "[" << rectangle.x << ", " << rectangle.y << ", " << rectangle.width << ", " << rectangle.height << "]";
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_RECT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
/**
* @brief Simple class for passing around pairs of small unsigned integers.
};
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_UINT_16_PAIR_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
struct Vector3;
struct Vector4;
// Allow Vector2 to be treated as a POD type
template <> struct TypeTraits< Vector2 > : public BasicTypes< Vector2 > { enum { IS_TRIVIAL_TYPE = true }; };
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_VECTOR_2_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
struct Vector2;
struct Vector4;
// Allow Vector3 to be treated as a POD type
template <> struct TypeTraits< Vector3 > : public BasicTypes< Vector3 > { enum { IS_TRIVIAL_TYPE = true }; };
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_VECTOR_3_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
+
struct Vector2;
struct Vector3;
// Allow Vector4 to be treated as a POD type
template <> struct TypeTraits< Vector4 > : public BasicTypes< Vector4 > { enum { IS_TRIVIAL_TYPE = true }; };
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_VECTOR_4_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-math
+ * @{
+ */
/**
* @brief Typedef for a viewport ( a rectangle representing a screen area ).
*/
typedef Rect<int> Viewport;
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_VIEWPORT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
/**
* @brief Stores a value of any type.
return any.Get<Type>();
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_ANY_TYPE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
class BaseObject;
class ConnectionTrackerInterface;
return lhs.GetObjectPtr() < rhs.GetObjectPtr();
}
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_BASE_HANDLE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
class BaseHandle;
return handle.GetBaseObject();
}
+/**
+ * @}
+ */
} // namespace Dali
# endif // __DALI_BASE_OBJECT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
class Constraint;
class PropertyNotification;
} // namespace WeightObject
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_HANDLE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL ObjectRegistry(Internal::ObjectRegistry* objectRegistry);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_OBJECT_REGISTRY_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
/**
* @brief A Array of property values.
Impl* mImpl; ///< Pointer to private data
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_ARRAY_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
*/
DALI_IMPORT_API PropertyCondition VariableStepCondition( const Dali::Vector<float>& steps );
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_CONDITIONS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
/**
* @brief These are the property index ranges.
PROPERTY_CUSTOM_START_INDEX = 50000000, ///< The index at which custom properties start (SceneGraph and Event side properties per instance)
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_INDEX_RANGES_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
struct Vector2;
struct Vector3;
}
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_INPUT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
+
typedef std::pair<std::string, Property::Value> StringValuePair;
/**
Impl* mImpl; ///< Pointer to private data
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_MAP_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
class PropertyNotification;
*/
typedef Signal< void (PropertyNotification& source) > PropertyNotifySignalType;
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_NOTIFICATION_DECLARATIONS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
explicit DALI_INTERNAL PropertyNotification(Internal::PropertyNotification* propertyNotification);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_NOTIFICATION_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
/**
* @brief Template function instances for property getters.
}; // namespace PropertyTypes
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_TYPES_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
struct AngleAxis;
class Quaternion;
*/
DALI_IMPORT_API std::ostream& operator<<( std::ostream& ouputStream, const Property::Value& value );
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_VALUE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
class Handle;
int componentIndex; ///< Index of a property sub component, for use with Vector2, Vector3 and Vector4, -1 if using main property
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_PROPERTY_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
class Value;
volatile int mCount; ///< Reference count
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_REF_OBJECT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
class ConnectionTrackerInterface;
class FunctorDelegate;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_TYPE_INFO_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-object
+ * @{
+ */
namespace Internal DALI_INTERNAL
{
AnimatablePropertyComponentRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex );
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // header
namespace Dali
{
+/**
+ * @addtogroup dali-core-render-tasks
+ * @{
+ */
class RenderTask;
explicit DALI_INTERNAL RenderTaskList( Internal::RenderTaskList* renderTask );
};
+/**
+ * @}
+ */
} // namespace Dali
#endif //__DALI_RENDER_TASK_LIST_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-render-tasks
+ * @{
+ */
class Actor;
class CameraActor;
explicit DALI_INTERNAL RenderTask( Internal::RenderTask* renderTask );
};
+/**
+ * @}
+ */
} // namespace Dali
#endif //__DALI_RENDER_TASK_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-shader-effects
+ * @{
+ */
/**
* @brief DALI_COMPOSE_SHADER macro provides a convenient way to write shader source code.
explicit DALI_INTERNAL ShaderEffect(Internal::ShaderEffect* effect);
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_SHADER_EFFECT_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
/**
* @brief Implementation class for Dali::Signal.
bool mEmittingFlag; ///< Used to guard against nested Emit() calls
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_BASE_SIGNAL_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
class CallbackBase;
return new Callback< T >( object, function );
}
+/**
+ * @}
+ */
} // namespace DALI
#endif // __DALI_CALLBACK_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
/**
* @brief Interface used to track connections between signals and slots.
ConnectionTrackerInterface& operator=( const ConnectionTrackerInterface& ); ///< undefined assignment operator
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CONNECTION_TRACKER_INTERFACE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
class CallbackBase;
class SlotObserver;
Dali::Vector< SlotConnection* > mConnections; ///< Vector of connection pointers
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_CONNECTION_TRACKER_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
/**
* @brief Base Template class to provide signals.
BaseSignal mImpl; ///< Implementation
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_SIGNAL_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
/**
* @brief Dispatcher to call a functor
Destructor mDestructorDispatcher; ///< Destructor for owned objects
};
+/**
+ * @}
+ */
} // namespace DALI
#endif // __DALI_FUNCTOR_DELEGATE_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
class CallbackBase;
CallbackBase* mCallback; ///< The callback, has ownership.
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_SIGNAL_SLOT_CONNECTIONS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
class SlotObserver;
class CallbackBase;
virtual void SlotDisconnected( CallbackBase* callback ) = 0;
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_SIGNAL_SLOT_OBSERVERS_H__
namespace Dali
{
+/**
+ * @addtogroup dali-core-signals
+ * @{
+ */
/**
* @brief SlotDelegates can be used to connect member functions to signals, without inheriting from SlotDelegateInterface.
ConnectionTracker mConnectionTracker; ///< A connection tracker
};
+/**
+ * @}
+ */
} // namespace Dali
#endif // __DALI_SLOT_DELEGATE_H__
--- /dev/null
+#ifndef __DALI_DOC_H__
+#define __DALI_DOC_H__
+
+/**
+ * @defgroup dali-core DALi Core
+ * @ingroup dali
+ *
+ * @brief This module provides scene graph-based rendering, animation, and event handling.
+ * It is a base module and forms the biggest part of DALi.
+ *
+ * @{
+ * @defgroup dali-core-actors Actors
+ * @brief Actor is the primary object for interaction in DALi applications.
+
+ * @defgroup dali-core-animation Animation
+ * @brief Animation allows your objects to move around / change their properties for a specified duration.
+
+ * @defgroup dali-core-common Common
+ * @brief Common classes for using DALi.
+
+ * @defgroup dali-core-events Events
+ * @brief Input events and gestures supported by DALi.
+
+ * @defgroup dali-core-images Images
+ * @brief Classes for handling resource images.
+
+ * @defgroup dali-core-math Math
+ * @brief Basic math classes.
+
+ * @defgroup dali-core-object Object
+ * @brief Classes for the handle/body pattern and property system.
+
+ * @defgroup dali-core-render-tasks Render Tasks
+ * @brief Render task classes.
+
+ * @defgroup dali-core-shader-effects Shader Effects
+ * @brief Shader effect classes.
+
+ * @defgroup dali-core-signals Signals
+ * @brief Classes for the signal and slot structure.
+ * @}
+ */
+
+#endif /* __DALI_DOC_H__ */
--- /dev/null
+package_doxy_files = \
+ $(package_doxy_dir)/dali-core-doc.h
%{_libdir}/pkgconfig/*.pc
%{dev_include_path}/%{name}/public-api/*
%{dev_include_path}/%{name}/devel-api/*
+%{dev_include_path}/%{name}/doc/*
%files integration-devel
%defattr(-,root,root,-)
projects / platform / core / uifw / dali-core.git / commitdiff