.directory
Makefile.in
Makefile
+dali.doxy
*~
*.o
*.o.d
# limitations under the License.
#
-SUBDIRS = dali-toolkit
+SUBDIRS = dali-toolkit docs
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = dali-toolkit.pc
devincludepath=${includedir}
AC_SUBST(devincludepath)
+# Doxygen paths
+DOXYGEN_DOCS_DIR=../../../docs
+DOXYGEN_ROOT_DIR=../../..
+AC_SUBST(DOXYGEN_DOCS_DIR)
+AC_SUBST(DOXYGEN_ROOT_DIR)
+
AC_CONFIG_FILES([
Makefile
dali-toolkit/Makefile
dali-toolkit.pc
+ docs/Makefile
+ docs/dali.doxy
])
AC_OUTPUT
--- /dev/null
+doxygen-errors.txt
--- /dev/null
+all-local:
+ @rm -f doxygen-errors.txt
+ @-doxygen dali.doxy &> doxygen-errors.txt || rm doxygen-errors.txt
+ @touch doxygen-errors.txt
+ @cat doxygen-errors.txt
+ @if [ -s doxygen-errors.txt ]; then exit 1 ; fi
+ @rm doxygen-errors.txt
--- /dev/null
+# Doxyfile 1.5.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
+# by quotes) that should identify the project.
+
+PROJECT_NAME = Dali
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY = @DOXYGEN_DOCS_DIR@/generated
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Farsi, Finnish, French, German, Greek,
+# Hungarian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, Polish,
+# Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, Slovene,
+# Spanish, Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF = "The $name class" \
+ "The $name widget" \
+ "The $name file" \
+ is \
+ provides \
+ specifies \
+ contains \
+ represents \
+ a \
+ an \
+ the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH = .
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful is your file systems
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 2
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it parses.
+# With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this tag.
+# The format is ext=language, where ext is a file extension, and language is one of
+# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP,
+# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat
+# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C
+
+EXTENSION_MAPPING =
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = YES
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen to replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penality.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will rougly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = NO
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = NO
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = NO
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or define consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and defines in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = YES
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page. This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by
+# doxygen. The layout file controls the global structure of the generated output files
+# in an output format independent way. The create the layout file that represents
+# doxygen's defaults, run doxygen with the -l option. You can optionally specify a
+# file name after the option, if omitted DoxygenLayout.xml will be used as the name
+# of the layout file.
+
+LAYOUT_FILE = @DOXYGEN_DOCS_DIR@/DaliLayout.xml
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = YES
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = @DOXYGEN_DOCS_DIR@/content \
+ ../../../../dali-toolkit/base/dali-toolkit/public-api \
+ ../../../../dali-toolkit/optional/dali-toolkit/public-api \
+ ../../../../dali-toolkit/capi/dali-toolkit/public-api \
+ @prefix@/include/dali
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+
+FILE_PATTERNS = *.c \
+ *.cc \
+ *.cxx \
+ *.cpp \
+ *.c++ \
+ *.d \
+ *.java \
+ *.ii \
+ *.ixx \
+ *.ipp \
+ *.i++ \
+ *.inl \
+ *.h \
+ *.hh \
+ *.hxx \
+ *.hpp \
+ *.h++ \
+ *.idl \
+ *.odl \
+ *.cs \
+ *.php \
+ *.php3 \
+ *.inc \
+ *.m \
+ *.mm \
+ *.dox \
+ *.py \
+ *.f90 \
+ *.f \
+ *.vhd \
+ *.vhdl
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE = dali/integration-api
+
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix filesystem feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS = DaliInternal \
+ Dali::Internal \
+ Dali::Integration \
+ Impl \
+ ApplicationImpl
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = YES
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH = @DOXYGEN_DOCS_DIR@/content/images
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output. If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
+# is applied to all files.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code. Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header.
+
+HTML_HEADER =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET =
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
+
+GENERATE_DOCSET = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID = org.doxygen.Project
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE = dali.chm
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER
+# are set, an additional index file will be generated that can be used as input for
+# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated
+# HTML documentation.
+
+GENERATE_QHP = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE =
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add.
+# For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION =
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX = NO
+
+# This tag can be used to set the number of enum values (range [1..20])
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to FRAME, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
+# probably better off using the HTML help feature. Other possible values
+# for this tag are: HIERARCHIES, which will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list;
+# ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which
+# disables this behavior completely. For backwards compatibility with previous
+# releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE
+# respectively.
+
+GENERATE_TREEVIEW = NONE
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE = 10
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, a4wide, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader. This is useful
+# if you want to understand what is going on. On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = YES
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED = DALI_IMPORT_API DALI_INTERNAL \
+ __attribute__ ((visibility ("default"))) \
+ __attribute__ ((visibility ("hidden")))
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all function-like macros that are alone
+# on a line, have an all uppercase name, and do not end with a semicolon. Such
+# function macros are typically used for boiler-plate code, and will confuse
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option is superseded by the HAVE_DOT option below. This is only a
+# fallback. It is recommended to install and use dot, since it yields more
+# powerful graphs.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# By default doxygen will write a font called FreeSans.ttf to the output
+# directory and reference it in all dot files that doxygen generates. This
+# font does not include all possible unicode characters however, so when you need
+# these (or just want a differently looking font) you can specify the font name
+# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
+# which can be done by putting it in a standard location or by setting the
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
+# containing the font.
+
+DOT_FONTNAME = FreeSans
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the output directory to look for the
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a
+# different font using DOT_FONTNAME you can set the path where dot
+# can find it using this tag.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES
+
+#---------------------------------------------------------------------------
+# Options related to the search engine
+#---------------------------------------------------------------------------
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE = NO
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvances is that it is more difficult to setup
+# and does not have live searching capabilities.
+
+# SERVER_BASED_SEARCH = NO
--- /dev/null
+<doxygenlayout version="1.0">
+ <!-- Navigation index tabs for HTML output -->
+ <navindex>
+ <tab type="mainpage" visible="yes" title=""/>
+ <tab type="pages" visible="yes" title="" intro=""/>
+ <tab type="modules" visible="yes" title="" intro=""/>
+ <tab type="namespaces" visible="yes" title="">
+ <tab type="namespacelist" visible="yes" title="" intro=""/>
+ <tab type="namespacemembers" visible="yes" title="" intro=""/>
+ </tab>
+ <tab type="classes" visible="yes" title="">
+ <tab type="classlist" visible="yes" title="" intro=""/>
+ <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
+ <tab type="hierarchy" visible="yes" title="" intro=""/>
+ <tab type="classmembers" visible="yes" title="" intro=""/>
+ </tab>
+ <tab type="files" visible="yes" title="">
+ <tab type="filelist" visible="yes" title="" intro=""/>
+ <tab type="globals" visible="yes" title="" intro=""/>
+ </tab>
+ <tab type="dirs" visible="yes" title="" intro=""/>
+ <tab type="examples" visible="yes" title="" intro=""/>
+ <tab type="user" visible="yes" title="Deprecated" intro="" url="deprecated.html"/>
+ </navindex>
+
+ <!-- Layout definition for a class page -->
+ <class>
+ <briefdescription visible="yes"/>
+ <includes visible="$SHOW_INCLUDE_FILES"/>
+ <inheritancegraph visible="$CLASS_GRAPH"/>
+ <collaborationgraph visible="$COLLABORATION_GRAPH"/>
+ <allmemberslink visible="yes"/>
+ <memberdecl>
+ <nestedclasses visible="yes" title=""/>
+ <publictypes title=""/>
+ <publicslots title=""/>
+ <signals title=""/>
+ <publicmethods title=""/>
+ <publicstaticmethods title=""/>
+ <publicattributes title=""/>
+ <publicstaticattributes title=""/>
+ <protectedtypes title=""/>
+ <protectedslots title=""/>
+ <protectedmethods title=""/>
+ <protectedstaticmethods title=""/>
+ <protectedattributes title=""/>
+ <protectedstaticattributes title=""/>
+ <packagetypes title=""/>
+ <packagemethods title=""/>
+ <packagestaticmethods title=""/>
+ <packageattributes title=""/>
+ <packagestaticattributes title=""/>
+ <properties title=""/>
+ <events title=""/>
+ <privatetypes title=""/>
+ <privateslots title=""/>
+ <privatemethods title=""/>
+ <privatestaticmethods title=""/>
+ <privateattributes title=""/>
+ <privatestaticattributes title=""/>
+ <friends title=""/>
+ <related title="" subtitle=""/>
+ <membergroups visible="yes"/>
+ </memberdecl>
+ <detaileddescription title=""/>
+ <memberdef>
+ <inlineclasses title=""/>
+ <typedefs title=""/>
+ <enums title=""/>
+ <constructors title=""/>
+ <functions title=""/>
+ <related title=""/>
+ <variables title=""/>
+ <properties title=""/>
+ <events title=""/>
+ </memberdef>
+ <usedfiles visible="$SHOW_USED_FILES"/>
+ <authorsection visible="yes"/>
+ </class>
+
+ <!-- Layout definition for a namespace page -->
+ <namespace>
+ <briefdescription visible="yes"/>
+ <memberdecl>
+ <nestednamespaces visible="yes" title=""/>
+ <classes visible="yes" title=""/>
+ <typedefs title=""/>
+ <enums title=""/>
+ <functions title=""/>
+ <variables title=""/>
+ <membergroups visible="yes"/>
+ </memberdecl>
+ <detaileddescription title=""/>
+ <memberdef>
+ <inlineclasses title=""/>
+ <typedefs title=""/>
+ <enums title=""/>
+ <functions title=""/>
+ <variables title=""/>
+ </memberdef>
+ <authorsection visible="yes"/>
+ </namespace>
+
+ <!-- Layout definition for a file page -->
+ <file>
+ <briefdescription visible="yes"/>
+ <includes visible="$SHOW_INCLUDE_FILES"/>
+ <includegraph visible="$INCLUDE_GRAPH"/>
+ <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
+ <sourcelink visible="yes"/>
+ <memberdecl>
+ <classes visible="yes" title=""/>
+ <namespaces visible="yes" title=""/>
+ <defines title=""/>
+ <typedefs title=""/>
+ <enums title=""/>
+ <functions title=""/>
+ <variables title=""/>
+ <membergroups visible="yes"/>
+ </memberdecl>
+ <detaileddescription title=""/>
+ <memberdef>
+ <inlineclasses title=""/>
+ <defines title=""/>
+ <typedefs title=""/>
+ <enums title=""/>
+ <functions title=""/>
+ <variables title=""/>
+ </memberdef>
+ <authorsection/>
+ </file>
+
+ <!-- Layout definition for a group page -->
+ <group>
+ <briefdescription visible="yes"/>
+ <groupgraph visible="$GROUP_GRAPHS"/>
+ <memberdecl>
+ <classes visible="yes" title=""/>
+ <namespaces visible="yes" title=""/>
+ <dirs visible="yes" title=""/>
+ <nestedgroups visible="yes" title=""/>
+ <files visible="yes" title=""/>
+ <defines title=""/>
+ <typedefs title=""/>
+ <enums title=""/>
+ <enumvalues title=""/>
+ <functions title=""/>
+ <variables title=""/>
+ <signals title=""/>
+ <publicslots title=""/>
+ <protectedslots title=""/>
+ <privateslots title=""/>
+ <events title=""/>
+ <properties title=""/>
+ <friends title=""/>
+ <membergroups visible="yes"/>
+ </memberdecl>
+ <detaileddescription title=""/>
+ <memberdef>
+ <pagedocs/>
+ <inlineclasses title=""/>
+ <defines title=""/>
+ <typedefs title=""/>
+ <enums title=""/>
+ <enumvalues title=""/>
+ <functions title=""/>
+ <variables title=""/>
+ <signals title=""/>
+ <publicslots title=""/>
+ <protectedslots title=""/>
+ <privateslots title=""/>
+ <events title=""/>
+ <properties title=""/>
+ <friends title=""/>
+ </memberdef>
+ <authorsection visible="yes"/>
+ </group>
+
+ <!-- Layout definition for a directory page -->
+ <directory>
+ <briefdescription visible="yes"/>
+ <directorygraph visible="yes"/>
+ <memberdecl>
+ <dirs visible="yes"/>
+ <files visible="yes"/>
+ </memberdecl>
+ <detaileddescription title=""/>
+ </directory>
+</doxygenlayout>
--- /dev/null
+To build the documentation from a Desktop build environment
+
+On the desktop:
+- cd dali-toolkit/build/slp/docs
+- doxygen dali.doxy
+ or
+ make
+
+To view the output: firefox docs/generated/html/index.html
--- /dev/null
+<hr>\r
+<a href="http://www.samsung.com">Copyright (c) 2008-2014 Samsung Electronics, Co., Ltd.</a></body></html>\r
--- /dev/null
+/*! \mainpage
+ *
+ * \section mainintro_sec Introduction
+ *
+ * It is a quick and easy way of allowing developers to create Rich UI Applications like Home
+ * screen, Gallery, Music player, Games, Maps...
+ *
+ * DALI is based on OpenGL ES 2.0, however it hides the complexity of
+ * the OpenGL API from developers and provides a clean cross-platform C++ framework.
+ *
+ * \section Introduction Introduction
+ * - \link fundamentals Dali Fundamentals \endlink
+ * - \link dali-application Dali Application and Adaptor \endlink
+ * - \link hello-world Hello World - explained \endlink
+ *
+ * \section Actors Actors
+ * - \link image-text-mesh-actor Image, Text and Mesh actors \endlink
+ * - \link event-system Event Handling \endlink
+ * - \link custom-actor Custom Actor \endlink
+ *
+ * \section ShaderEffects Shader Effects
+ * - \link shader-intro Shader Effects\endlink
+ *
+ * \section Animation Animation
+ * - \link animation-example Example and Usage\endlink
+ * - \link animation-rotation Rotation with quaternions \endlink
+ * - \link animation-shader Shader Animation \endlink
+ * - \link animation-multi-threading-notes Multi-threading Notes \endlink
+ *
+ * \section Constraints
+ * - \link constraints-intro Introduction to Constraints \endlink
+ *
+ * \section UIControls UI Controls
+ * - \link item-view Item View \endlink
+ * - \link text-view Text View \endlink
+ * - \link text-input Text Input \endlink
+ * - \link scroll-view Scroll View \endlink
+ * - \link markup-processor Markup Processor \endlink
+ * - \link size-negotiation Size Negotiation \endlink
+ * - \link type-registration Type Registration \endlink
+ * - \link properties Properties \endlink
+ * - \link background Background \endlink
+ *
+ * \section Dynamics Dynamics
+ * - \link dynamics-intro Introduction to Dynamics\endlink
+ * - \link dynamics-initialization Initializing the Simulation\endlink
+ * - \link dynamics-bodies Bodies - adding and controlling dynamic objects \endlink
+ * - \link dynamics-joints Joints - linking objects\endlink
+ * - \link dynamics-collisions Collision Detection and Filtering\endlink
+ *
+ * \section Scripting
+ * - \link script-overview Overview \endlink
+ * - \link script-howto How to Add a Custom Control \endlink
+ * - \link script-hello Hello World in script \endlink
+ *
+ * - \link handle-body-idiom Handle – body idiom \endlink
+ * - \link boost-library Boost Library \endlink
+ * - \link boost-function Boost function usage \endlink
+ *
+ * \section Profiling
+ * - \link resource-tracking Resource Tracking \endlink
+ * - \link performance-profiling Performance Profiling \endlink
+ *
+*/
+
+/*! \page scene-graph
+ *
+ * \section scene_intro What is a scene graph?
+ * From wikipedia...
+ * A scene graph is a collection of nodes in a graph or tree structure.
+ * A node may have many children but often only a single parent,
+ * with the effect of a parent applied to all its child nodes;
+ * an operation performed on a group automatically propagates
+ * its effect to all of its members. In many programs, associating
+ * a geometrical transformation matrix (see also transformation and matrix)
+ * at each group level and concatenating such matrices together is an
+ * efficient and natural way to process such operations. A common feature,
+ * for instance, is the ability to group related shapes/objects into a
+ * compound object that can then be moved, transformed, selected,
+ * etc. as easily as a single object.
+ *
+ * \section scene_dali How does this relate to the Dali public API?
+ *
+ * Actors are effectively nodes that receive input (touch events) and act as a
+ * container for draw-able elements (which are also nodes) and other actors.
+ *
+ * For example a Button actor will be an actor with several elements such as button background,
+ * text label and button face. When the actor is moved around, it's child elements will move with it.
+ * When the button is pressed, the actor will receive an event and adjust the color of its button face
+ * element.
+ *
+ * \section scene_dali Why does Dali internally have a second scene graph?
+ * Actors and elements are contained in a scene graph which deals with input, layout and some animation
+ * it doesn't perform any drawing.
+ *
+ * All the drawing is done via the Render Manager which has it's own render scene graph, where it's nodes
+ * are just for drawing things like image/text and moving them around. So when you create an Image element
+ * it will ask the RenderManager to create an Image node. The separation allows the RenderManager to
+ * run in a separate thread to maintain a high frame rate, without being slowed down by any logic
+ * performed on the actor/element side.
+ *
+ */
--- /dev/null
+/*! \page animation-example Example and Usage
+
+ We will start by showing the steps for animating an actors position and opacity so the actor moves whilst the opacity changes.
+
+ Next more interesting animations methods (effects) with individual timing will be explained.
+
+ \section simple-anim Simple Animation moving an actor whilst altering opacity.
+
+ We declare an animation called myAnimation
+
+ @code
+ Dali::Animation myAnimation
+ @endcode
+
+ A new animation instance is created with a specified duration. Here the duration of the animation will be 0.5 seconds.
+ Some other settings are incorporated by default and will be explained later.
+ @code
+ myAnimation = Animation::New(0.5f);
+ @endcode
+
+ Here we add the animators, these are the building blocks (functions) of the animation and define what we want to see
+ @code
+ myAnimation.OpacityTo(actor, 1.0f);
+ myAnimation.MoveTo(actor, x, y, z);
+ @endcode
+
+ start animation, when this is called we want the animation to start playing so here the actor will move whilst the opacity changes.
+ @code
+ myAnimation.Play();
+ @endcode
+ \section advanced-anims Adding more advanced animators, if simply moving the actor is not enough we have further animations methods.
+
+ For actor there exists a range of methods ranging from Move, Rotate, Scale, Opacity, Color to Resize. The API explains in detail what each does and the parameters to these methods but there are some points worth noting;
+
+ xxxxBy and xxxxTo, method names are appended by 'By' or 'To' either animate to a supplied value or animate by a supplied value. For example an actor at (10,10,10) calling MoveBy(actor, 50,0,0) would mean its location is (60,0,0) whilst MoveTo(actor, 50,0,0) would result in a location (50,0,0).
+
+ Dali::AlphaFunctions can be used to give interesting effects to the animation, for example the MOVEment of an actor on screen can speed up and slow down following a sine curve by using the Dali::AlphaFunctions::EaseInOutSine instead of AlphaFunctions::Linear.
+
+ @code
+ myAnimation.MoveTo(actor, Vector3(x, y, z), AlphaFunctions::Linear, delay, ANIMATOR_DURATION);
+ myAnimation.Resize(actor, actorSize, AlphaFunctions::EaseIn, delay, ANIMATOR_DURATION);
+ @endcode
+ \section playback-control Controlling a playing animation
+
+ The 3 controls we have are start, pause and stop
+ @code
+ Dali::Animation::Play();
+ Dali::Animation::Stop();
+ Dali::Animation::Pause();
+ @endcode
+
+ \section default-settings Default settings
+ The call Dali::Animation::New provides some default settings but each has a setter function if the defaults are not suitable. (Getters also exist)
+ @code
+ Dali::Animation::SetEndAction
+ Dali::Animation::SetLooping
+ Dali::Animation::SetDefaultAlphaFunction
+ @endcode
+
+ \section end-signal End Signal
+ The following signal can be connected to if it is required to know when an animation is complete.
+ /code Dali::Animation::SignalFinish(); /endcode
+
+ */
+
--- /dev/null
+/*! \page animation-multi-threading-notes Animation: Multi-threading Notes
+ *
+
+<h2 class="pg">Multi-threaded Architecture</h2>
+
+Dali animations and rendering occur in a dedicated rendering thread. This allows animations to run smoothly, regardless of the time taken to process inputs events etc. in application code.
+
+Internally Dali contains a scene-graph, which mirrors the Actor hierachy. The scene-graph objects perform the actual animation & rendering, whilst Actors provide thread-safe access.
+
+An example actor hierachy is shown below, in which one of the actors is being animated. The objects in green are created by the application code, whilst the private objects in blue are used in the dedicated rendering thread.
+
+\image html multi-threaded-animation.png
+
+<h2 class="pg">Reading an animated value</h2>
+
+When a property is animatable, it can only be modified in the rendering thread. The value returned from a getter method, is the value used when the previous frame was rendered.
+
+For example \ref Dali::Actor::GetCurrentPosition "Dali::Actor::GetCurrentPosition" returns the position at which the Actor was last rendered. Since \ref Dali::Actor::SetPosition "Dali::Actor::SetPosition" is asynchronous, a call to \ref Dali::Actor::GetCurrentPosition "Dali::Actor::GetCurrentPosition" won't immediately return the same value.
+
+@code
+// Whilst handling an event...
+
+Actor actor = Actor::New();
+Stage::GetCurrent().Add(actor); // initial position is 0,0,0
+
+actor.SetPosition(Vector3(10,10,10));
+
+Vector3 current;
+current = actor.GetCurrentPosition();
+std::cout << "Current position: " << current.x << ", " << current.y << ", " << current.z << std::endl;
+
+std::cout << "..." << std::endl;
+
+// Whilst handling another event...
+
+current = actor.GetCurrentPosition();
+std::cout << "Current position: " << current.x << ", " << current.y << ", " << current.z << std::endl;
+
+@endcode
+
+The example code above would likely output:
+
+@code
+"Current position: 0,0,0"
+"..."
+"Current position: 10,10,10"
+@endcode
+
+<h2 class="pg">Setting a property during an animation</h2>
+
+When a property is being animated, the Animation will override any values set e.g. with Actor::SetPosition()
+
+\image html multi-threaded-animation-2.png
+
+The order of execution in the render thread is:
+
+@code
+1) Process message => SetPosition
+2) Apply animation => SetPosition
+3) Render frame
+@endcode
+
+*
+*/
--- /dev/null
+/*! \page animation-rotation Rotation with quaternions
+ *
+ * \ref Dali::Quaternion "Quaternions" are used to specify unique orientations on actors. They are also
+ * very useful for calculating smooth transitions between orientations.
+ *
+ * The Dali::Actor class provides the ability to set the orientation
+ * by both angle+axis and quaternion. It also allows you to rotate the
+ * actor around another quaternion.
+ *
+ * @code
+ * Dali::Actor actor;
+ * actor.SetRotation(Quaternion(Radian(Degree(45.0f)).value, Vector3::XAXIS)),
+ *
+ * Quaternion q(Radian(Degree(30.0f)).value, Vector3(1.0f, 1.0f, 0.0f));
+ * actor.RotateBy(q);
+ * @endcode
+ *
+ * The Dali::Animation class provides several RotateTo methods that
+ * use \ref Dali::Quaternion "Quaternions" directly. The other
+ * RotateTo methods are specified using Axis+Angle, and these convert
+ * to Quaternion internally. You will only need to use the quaternion
+ * based methods when you are doing something more complex than
+ * initialising with Axis+Angle, such as applying several rotations
+ * together.
+ * @code
+ * mAnimation = Animation::New(5.0f); // 5 seconds
+ * Quaternion q(Radian(Degree(45.0f)).value, Vector3::YAXIS);
+ * Quaternion r(Radian(Degree(30.0f)).value, Vector3::ZAXIS);
+ * q *= r;
+ * mAnimation.RotateTo(mActor, q, AlphaFunctions::EaseInOut);
+ * mAnimation.Play();
+ * @endcode
+ */
--- /dev/null
+/*! \page animation-shader Shader Effect Animation
+ *
+
+The uniforms of a shader can be animated using the Animation::AnimateTo functions.
+
+For example, to animate the center point of the Bendy shader effect:
+@code
+Dali::Animation animation = Dali::Animation::New( 1.0f );
+//...
+Vector2 newPosition( 0.0f, 0.0f );
+animation.AnimateTo( Property(shaderEffect, shaderEffect.GetPositionPropertyName()), newPosition );
+@endcode
+
+To animate a uniform of a custom shader effect, the developer must use the name of the uniform:
+@code
+Dali::Animation animation = Dali::Animation::New( 1.0f );
+//...
+// Set the initial value for the uniform
+shaderEffect.SetUniform( "myUniform", -0.5f );
+//...
+// Animate the uniform to a value
+animation.AnimateTo( Property(shaderEffect, "myUniform"), 0.5f );
+@endcode
+
+ *
+ */
--- /dev/null
+/*! \page background Background
+ *
+@section background-color Background Color
+
+It is possible to set a background color for a DALi control. If the application writer wishes to
+set a control with a red background:
+
+@code
+Dali::Toolkit::Control control = Dali::Toolkit::Control::New();
+control.SetBackgroundColor( Dali::Color::RED );
+@endcode
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html BackgroundControlColor.png
+</td>
+</table>
+
+This can be used for ALL existing controls like TextView as well:
+@code
+Dali::Toolkit::TextView textView = Dali::Toolkit::TextView::New( "Hello World" );
+textView.SetBackgroundColor( Dali::Color::RED );
+@endcode
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html BackgroundTextView.png
+</td>
+</table>
+
+@section background-image Background Image
+
+If required, the user can also set a background image as a DALi control:
+
+@code
+Dali::Toolkit::Control control = Dali::Toolkit::Control::New();
+Dali::Image image = Dali::Image::New( "image.png" );
+control.SetBackgroundImage( image );
+@endcode
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html BackgroundImage.png
+</td>
+</table>
+
+The background image is blended with the background color. If a red background color is set on the
+control:
+@code
+control.SetBackgroundColor( Dali::Color::RED );
+@endcode
+then the above image will look like:
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html BackgroundImageColor.png
+</td>
+</table>
+
+*
+*/
--- /dev/null
+/*! \page boost-function Boost function usage
+<h2 class="pg">Signal handler functions</h2>
+ boost::function is mostly used to define callback function types in Dali.
+ For example in text-actor.h:
+ \code
+class TextActor : public RenderableActor
+{
+public:
+ ...
+ typedef boost::function<void (TextActor)> TextCallbackType;
+ typedef Signal<TextSignalType, TextCallbackType> TextSignal;
+
+public:
+ TextSignal SignalTextAvailable();
+ ...
+ }
+ \endcode
+
+ \p "boost::function<void (TextActor)>" specifies a function type which has no return value and takes \p TextActor as an argument.
+ The application can set a function of this type to be called when the text available signal is emitted.
+
+ <h2 class="pg">Specifying custom functions (eg. sorting)</h2>
+ Dali::Layer::SetSortFunction() is an example where the developer should use a boost function in order to specify the sorting algorithm.\n
+ This API accepts both standalone functions or class methods.\n
+ Standalone functions can be simply given as:
+ \code
+ static float TestSortFunction(const Vector3& position, float sortModifier)
+ {
+ // do something
+ }
+
+ void TestApp::SetRootSort()
+ {
+ Layer root = Stage::GetCurrent().GetLayer( 0 );
+ root.SetSortFunction(TestSortFunction);
+ }
+ \endcode
+ For member functions \b binding needs to be done:
+ \code
+ float TestApp::TestSortFunction(const Vector3& position, float sortModifier)
+ {
+ // do something
+ }
+
+ void TestApp::SetRootSort()
+ {
+ Layer root = Stage::GetCurrent().GetLayer( 0 );
+ root.SetSortFunction(boost::bind(&TestApp::TestSortFunction, this));
+ }
+ \endcode
+ \n\n
+ For more information please see <a href="http://www.boost.org/doc/">the boost project documentation</a>.
+
+ */
+
--- /dev/null
+/*! \page boost-library Boost Library
+
+ Boost is a set of free software libraries that extend the functionality of C++.
+
+ Dali API uses the following aspects of boost:
+ - \link boost-function Boost functions\endlink
+
+ For more information on the Boost library check the project's <a href="http://www.boost.org/doc/">website</a>.
+ */
--- /dev/null
+/*! \page constraints-intro Constraints
+ *
+
+<h2 class="pg">Introduction</h2>
+
+Constraints can be used to modify the property of an actor, based on the properties of another actor. Custom a functions or functors can be supplied, to describe the relationship between these properties. A common example is alignment e.g. modifying an actor's position, when the size of the parent actor changes. Multiple constraints can be applied to the same actor at the same time.
+
+Constraints are applied in the dedicated render thread, after animations have been applied. This means that Constraints override the values set by Animations. Constraints may behave in a similar way to animations, since they can be applied or removed gradually. By default the apply-time is zero, meaning that the constraint will be applied immediately.
+
+<h2 class="pg">Local Constraints</h2>
+
+A local constraint is based on the local properties (i.e. size, position, scale, rotation, color) of an actor. For example you could change the color of an actor, based its rotation.
+
+<h2 class="pg">Parent Constraints</h2>
+
+A parent constraint is based on properties of the actor's parent. The following example shows how to constrain an actor to be 80% of its parent's size:
+
+@code
+Actor actor = Actor::New();
+Vector3 scale(0.8f, 0.8f, 0.8f); // Set width/height/depth at 80% of parent
+Constraint constraint = ParentConstraint::Size::New(Dali::ParentSize(scale));
+actor.ApplyConstraint(constraint);
+@endcode
+
+The actor's constraints can later be removed:
+
+@code
+ actor.RemoveConstraints();
+@endcode
+
+*
+*/
--- /dev/null
+/*! \page custom-actor Custom Actor
+ * The Dali::CustomActor is used as a base class for UI controls. It is a proxy object to enable derived classes access
+ * to a subset of the methods defined in the internal Actor class.
+ *
+ * Classes deriving from Custom Actor should follow the same design principle as the rest of the Dali API.
+ *
+ * One class of the new UI control should inherit from Dali::CustomActor, while a second should inherit
+ * Dali::CustomActorImpl. This implementation class contains a number of pure virtual methods that enable the new UI
+ * control to respond to a variety of events such as touch and notification of being added to the stage.
+ *
+ * For example, if creating a new button widget called myNewButton, the user would create two classes, myNewButton which
+ * derives from Dali::CustomActor and an implementation part myNewButtonImpl which would derive from Dali::CustomActorImpl.
+ *
+ * In the New() method for the myNewButton class, the user should then create a new instance of the myNewButtonImpl class
+ * and pass this to the constructor of the myNewButton object. Internally the connection will be made
+ * between the new widget actor and Dali, thus allowing messages such as OnSizeSet to be received by the new actor.
+ *
+ * It is the responsibility of the implementation of the new UI control to implement the method bodies for the inherited
+ * pure virtual methods from Dali::CustomActorImpl. Obviously the application won't compile if the methods are not
+ * overidden, but the user does not need to fill in the code for methods they don't want or need to use.
+ *
+ * The following code shows the static New() method from the implementation part of the TextView UI control:
+ * \code
+ * Dali::Toolkit::TextView TextView::New()
+ * {
+ * // Create the implementation, temporarily owned on stack
+ * boost::intrusive_ptr< TextView > textView = new TextView;
+ *
+ * // Pass ownership to CustomActor
+ * Dali::Toolkit::TextView handle( *textView );
+ *
+ * // Second-phase init of the implementation
+ * // This can only be done after the CustomActor connection has been made...
+ * textView->Initialize();
+ *
+ * return handle;
+ * }
+ * \endcode
+ *
+ * After the implementation object is created it is passed back to the basic Text View through the constructor,the
+ * constructor uses this passed in object to initialise the internal implementation objects.
+ *
+ * After both the objects are created it calls an init method on the implementation which is used to initialise
+ * objects. THis is the preferred way to do things so to avoid errors in the constructors.
+ *
+ * If desired, the user can then use the myNewButtonImpl implementation class to handle only the callback message
+ * handler methods, and do all the rest of their widget processing the the main myNewButton class. Access to the
+ * implementation class can be gained using the GetImpl(*this) method. For example:
+ *
+ * \code
+ * void TextView::SetFont(const Font newFont)
+ * {
+ * GetImpl(*this).SetFont(newFont);
+ * }
+ * \endcode
+ */
--- /dev/null
+/*! \page dali-application Dali Application and Adaptor
+ *
+<h2 class="pg">Creating an Application</h2>
+
+The Adaptor framework provides several classes which intialises and sets up Dali appropriately so that the application writer does not have to. These classes also provides many platform related services (e.g. orienation change notifications, timer services etc.).
+
+The simplest way to create an application that uses Dali is to utilise the Dali::Application class. In addition to initialising the environment used by Dali, it also provides several signals which the user can connect to when certain platform related activities occur. It also ensures that, upon system events, Dali is called in a thread-safe manner.
+
+The following example shows how to create a Dali::Application instance and connect to its initialise signal (which is where a Dali::Actor hierarchy should be created).
+
+@code
+void CreateProgram(Application& app)
+{
+ // Create Dali components...
+ Dali::Actor actor = Actor::New();
+ ...
+}
+
+int main (int argc, char **argv)
+{
+ Application app = Application::New(argc, argv);
+ app.SignalInit().Connect(&CreateProgram);
+ app.MainLoop();
+}
+@endcode
+
+Please see the Dali::Application class for other signals to which the application can connect.
+
+<h2 class="pg">Using an Adaptor or EvasPlugin instead of the Application class</h2>
+
+If the application requires finer grained control, an Dali::Adaptor can be created instead. This allows the application writer to create other platform related functionality themselves (e.g managing the main loop, providing a surface to render to etc.).
+
+When using the Adaptor, the application writer can specify the use of normal window creation and drawing by using the New method with an appropriate Window.
+
+If the application writer wants Dali to draw to a specific surface then they need to create a Dali::RenderSurface instance and use the Adaptor constructor which takes the Dali::RenderSurface as the parameter.
+
+The only signal provided by the adaptors is a <i>surface resized signal</i>; the application writer will have to handle system signals like <i>initialise, pause, terminate </i> etc. themselves. It is also important that any calls to Dali are made in a thread-safe manner from your application when using the adaptor directly.
+
+An adaptor can be created as shown below:
+
+@code
+void CreateProgram(void* data)
+{
+ // Start Adaptor
+ Dali::Adaptor* adaptor = reinterpret_cast<Dali::Adaptor*>(data);
+ adaptor->Start();
+
+ // Create Dali components...
+ // Can instantiate here, if required
+}
+
+int main ()
+{
+ // Initialise platform
+ MyPlatform.Init();
+
+ // Create an 800 by 1280 window positioned at (0,0).
+ Dali::PositionSize positionSize(0, 0, 800, 1280);
+ Dali::Window window = Dali::Window::New( positionSize, "My Application" );
+ Dali::Adaptor& adaptor = Dali::Adaptor::New( window );
+
+ // Assuming second parameter takes in data which is passed back to the callback function
+ MyPlatform.InitialisationConnection(&CreateProgram, &adaptor);
+
+ // Start Main Loop of your platform
+ MyPlatform.StartMainLoop();
+
+ return 0;
+}
+@endcode
+
+A Dali::EvasPlugin instance can be created by EFL applications that wish to use Dali. Like the Adaptor, it also provides a means for initialising the resources required by the Dali::Core.
+
+The Dali::EvasPlugin emits several signals which the user can connect to. The user should not create any Dali objects in the main function and instead should connect to the Init signal of the EvasPlugin and create the Dali objects in the connected callback.
+
+A Dali::EvasPlugin can be used in an EFL application as shown below:
+
+@code
+void Created(EvasPlugin& evasPlugin)
+{
+ // Create Dali components...
+ // Can instantiate here, if required
+}
+
+void Resized(EvasPlugin& evasPlugin)
+{
+ // Set size properties of Dali components
+ // Set screen layout
+}
+
+int main (int argc, char **argv)
+{
+ // Initialise Elementary
+ elm_init(&argc, &argv);
+
+ // Create an Evas Window
+ Evas_Object* win = elm_win_add(...);
+
+ // Get the actual window
+ Evas* e = evas_object_evas_get(win);
+
+ // Create the EvasPlugin and pass the actual window
+ Dali::EvasPlugin evasPlugin = Dali::EvasPlugin(e);
+
+ evasPlugin.SignalInit().Connect(&Created);
+ evasPlugin.SignalResize().Connect(&Resized);
+
+ // Retrieve the Evas_Object from the plugin and show it.
+ Evas_Object* evasObject = evasPlugin.GetEvasObject();
+ evas_object_show(evasObject);
+
+ // add evasObject to layout such as elm_box
+
+ // Start main loop
+ elm_run();
+}
+@endcode
+
+<h2 class="pg">Window</h2>
+Dali provides a Window class to manage drawing to a default surface. It is also responsible for drawing the Indicator bar if required. The Application class automatically creates a Window which the application author can access after the SignalInit has fired.
+
+@code
+void CreateProgram(Application& app)
+{
+ app.GetWindow().ShowIndicator(true);
+}
+
+int main (int argc, char **argv)
+{
+ Application app = Application::New(argc, argv);
+ app.SignalInit().Connect(&CreateProgram);
+ app.MainLoop();
+}
+@endcode
+
+<h2 class="pg">Orientation</h2>
+
+The Adaptor Framework also provides a means of retrieving the current device orientation and connection to a signal when the orientation of the device changes. The Dali::Application class provides access to an already created Dali::Orientation object. If using a Dali::Adaptor, an instance of the Dali::Orientation class has to be created in the application.
+
+The following example shows how to connect to an orientation changed signal through the Dali::Application class:
+
+@code
+void OrientationChanged(const Orientation& orientation)
+{
+ int degrees = orientation.GetDegrees();
+ ...
+}
+
+int main(int argc, char **argv)
+{
+ Application app = Application::New(&argc, &argv);
+ app.GetOrientation().SignalChanged().Connect(&OrientationChanged);
+}
+@endcode
+
+<h2 class="pg">Timers</h2>
+
+Timers are also provided by the Adaptor Framework so that the application writer can execute a portion of their code periodically or just once, after a delay. The example below shows how a Dali::Timer can be created and used:
+
+@code
+bool Tick()
+{
+ ...
+ return true; // Timer continues, i.e. this function will be called again after the specified time has elapsed.
+}
+
+...
+
+// Elsewhere
+Timer timer = Timer::New(2000); // 2 second timeout
+timer.SignalTick().Connect(&Tick);
+...
+@endcode
+
+ */
--- /dev/null
+/**
+ * \page dynamics-bodies Dynamics - Bodies
+ * A Dali::DynamicsBody can be "Rigid" or "Soft". Rigid bodies require much less processing and should be used
+ * in preference to a soft body.\n
+ * All bodies are controlled by the simulation, the application developer can influence them by setting their
+ * linear or angular velocities, but direct control of their position is not possible until the Dali::DynamicsBody is flagged
+ * as a \ref kinematic-body "kinematic object".\n
+ *
+ * \section create-body Creating a body
+ * <p>
+ * Each Dali::DynamicsBody is created by an Dali::Actor through its Dali::Actor::EnableDynamics method using a
+ * Dali::DynamicsBodyConfig object to specify options for the Dali::DynamicsBody.
+ * \code
+ * // Initialize and get a handle to the Dali::DynamicsWorld
+ * Dali::DynamicsWorldConfig worldConfig( Dali::DynamicsWorldConfig::New() );
+ * Dali::DynamicsWorld dynamicsWorld( Dali::Stage::GetCurrent().InitializeDynamics( worldConfig ) );
+ * // Create an actor to represent the world
+ * Dali::Actor dynamicsRootActor( Dali::Actor::New() );
+ * dynamicsWorld.SetRootActor( dynamicsRootActor );
+ * Dali::Stage::GetCurrent().Add( dynamicsRootActor );
+ *
+ * // create an actor to represent a rigid body
+ * Dali::Actor actor( Dali::Actor::New() );
+ * actor.SetParentOrigin( Dali::ParentOrigin::CENTER );
+ * dynamicsRootActor.Add( actor );
+ * // Enable dynamics for the actor, creating a rigid body with default configuration
+ * actor.EnableDynamics( Dali::DynamicsBodyConfig::New() );
+ * \endcode
+ *
+ * \section create-body-advanced Specifying options
+ * <h4>Mass</h4>
+ * Use Dali::DynamicsBodyConfig::SetMass to specify the mass of the body [default: 1].
+ * <h4>Elasticity</h4>
+ * Use Dali::DynamicsBodyConfig::SetElasticity to specify the elasticity of the body [default: 0.85].\n
+ * This may also be known as the co-efficient of restitution or 'bounciness'.
+ * <h4>Damping</h4>
+ * Use Dali::DynamicsBodyConfig::SetLinearDamping to specify the linear damping coefficient [default: 0].\n
+ * and Dali::DynamicsBodyConfig::SetAngularDamping to specify the angular damping coefficient [default: 0].\n
+ * <h4>Friction</h4>
+ * Use Dali::DynamicsBodyConfig::SetFriction to specify the friction of the body [default: 0.5].\n
+ * <h4>Collision Filtering</h4>
+ * See \link dynamics-collisions Collision Detection and Filtering \endlink\n\n
+ * Use Dali::DynamicsBodyConfig::SetCollisionGroup to specify the collision filter group.\n
+ * Use Dali::DynamicsBodyConfig::SetCollisionMask to specify the collision filter mask.\n
+ * <h3>Soft body specific options</h3>
+ * <h4>Stiffness</h4>
+ * Use Dali::DynamicsBodyConfig::SetStiffness to specify the stiffness of the links between the mesh vertices used to
+ * define the soft body. Values clamped between 0 and 1 [default: 1].\n
+ * <h4>Anchor hardness</h4>
+ * Use Dali::DynamicsBodyConfig::SetAnchorHardness to specify the hardness or drift correction applied to anchors.
+ * Values clamped between 0 and 1 [default: 0.7]. Smaller values mean less drift correction.\n
+ * <h4>Conservation</h4>
+ * Use Dali::DynamicsBodyConfig::SetShapeConservation to specify the shape conservation coefficient,
+ * or the magnitude of the force which will attempt to maintain the soft bodies shape (see \ref Dali::DynamicsBody::ConserveShape).\n
+ * Use Dali::DynamicsBodyConfig::SetVolumeConservation to specify the volume conservation coefficient,
+ * or the magnitude of the force which will attempt to maintain the soft bodies volume (see \ref Dali::DynamicsBody::ConserveVolume).
+ * Smaller values mean less conservation.\n
+ * <h4>Create a rigid body with advanced options</h4>
+ * \code
+ * Dali::DynamicsBodyConfig bodyConfig( Dali::DynamicsBodyConfig::New() );
+ * // increase mass from the default
+ * bodyConfig.SetMass( 2.5f );
+ * // set elasticity so that the velocity of the object will be halved after a collision
+ * // (assuming the other body has a mass = 1 and a velocity 0f 0).
+ * bodyConfig.SetElasticity( 0.5f );
+ * // increase the rate at which a bodies linear velocity will decrease
+ * bodyConfig.SetLinearDamping( 0.5f );
+ * // reduce the friction to zero
+ * bodyConfig.SetFriction( 0.0f );
+ * // Ignore all collisions
+ * bodyConfig.SetCollisionGroup( 0 );
+ * bodyConfig.SetCollisionMask( 0 );
+ *
+ * // create an actor for the Dali::DynamicsBody
+ * Actor actor( Actor::New() );
+ * actor.SetParentOrigin( Dali::ParentOrigin::CENTER );
+ * // create the Dali::DynamicsBody
+ * actor.EnableDynamics( bodyConfig );
+ *
+ * // add to the simulation
+ * dynamicsRootActor.Add( actor );
+ * \endcode
+ * <h4>Create a soft body with advanced options</h4>
+ * \code
+ * // Create a unit mesh with 25 vertices
+ * Dali::Mesh mesh( Dali::Mesh::NewPlane(1.0f, 1.0f, 5, 5) );
+ *
+ * Dali::DynamicsBodyConfig bodyConfig( Dali::DynamicsBodyConfig::New() );
+ * // select a soft body
+ * bodyConfig.SetType( Dali::DynamicsBodyConfig::SOFT );
+ * // set the mesh as the soft body shape
+ * bodyConfig.SetShape( Dali::DynamicsShape::NewMesh( mesh ) );
+ * // decrease the stiffness of the links between the soft body vertices
+ * bodyConfig.SetStiffness( 0.25f );
+ * // Make anchors very loose/weak
+ * bodyConfig.SetAnchorHardness( 0.1f );
+ *
+ * // create an actor for the Dali::DynamicsBody
+ * Actor actor( MeshActor::New(mesh) );
+ * actor.SetParentOrigin( Dali::ParentOrigin::CENTER );
+ * // create the Dali::DynamicsBody
+ * actor.EnableDynamics( bodyConfig );
+ *
+ * // add to the simulation
+ * dynamicsRootActor.Add( actor );
+ * \endcode
+ * \image html dynamics/dynamics-soft.png "A soft body (with debug rendering enabled)"
+ * \section kinematic-body Kinematic bodies
+ * A kinematic body is not controlled by the simulation, there is a one-way interaction with other dynamic objects
+ * under control of the simulation, where other objects will be pushed away, but the kinematic object will be unaffected.\n
+ * Kinematic objects can be animated with DALi's \ref animation-example "animation system", each DALi update the simulation will
+ * get the current position of associated DALi actor.\n Use Dali::DynamicsBody::SetKinematic to make a kinematic object.
+ * <h3>Animating a kinematic object</h3>
+ * Other dynamics enabled actors that collide with the kinematic object during the animation will be pushed
+ * away.
+ * \code
+ * ...
+ * // create an actor to represent a rigid body
+ * Dali::Actor actor( Dali::Actor::New() );
+ * dynamicsRootActor.Add( actor );
+ * // Enable dynamics for the actor, creating a rigid body with default configuration
+ * actor.EnableDynamics( Dali::DynamicsBodyConfig::New() );
+ * // get the DynamicsBody handle
+ * DynamicsBody body( actor.GetDynamicsBody() );
+ * body.SetKinematic( true );
+ * // create a second animation to move the actor 100 units to the right
+ * Animation animation( Animation::New( 1 ) );
+ * animation.MoveBy( actor, Vector3( 100, 0, 0 ), AlphaFunctions::Linear );
+ * animation.Play();
+ * \endcode
+ * <hr>
+ * <p>See also
+ * <ul>
+ * <li>Dali::DynamicsBodyConfig</li>
+ * <li>Dali::Actor::EnableDynamics</li>
+ * <li>\link dynamics-initialization DynamicsWorld Initialization and Usage\endlink</li>
+ * </ul>
+ * </p>
+ */
+
--- /dev/null
+/**
+ * \page dynamics-collisions Collisions
+ * \section collision-detection Collision Detection
+ * <p>
+ * Collision detection is automatic and occurs between all Dali::DynamicsBody objects in the simulation.@n
+ * To respond to a detected collisions, the application developer can connect to a signal provided by
+ * a Dali::DynamicsWorld object.
+ * \code
+ * ...
+ *
+ * // DynamicsWorld initialization code
+ *
+ * ...
+ *
+ * // Connect a signal handler to the signal
+ * Dali::DynamicsWorld theWorld( Stage::GetCurrent().GetDynamicsWorld() );
+ * theWorld.SignalCollision().Connect( this, &myClass::OnDynamicsCollision );
+ *
+ * ...
+ *
+ * // Implement a signal handler
+ * void myClass::OnDynamicsCollision( Dali::DynamicsWorld world, Dali::DynamicsCollision collisionData )
+ * {
+ * std::cout << "Collision between "
+ * << collisionData.GetActorA().GetName() << " and "
+ * << collisionData.GetActorB().GetName() << " ";
+ *
+ * if( collisionData.GetImpactForce() != 0.0f )
+ * {
+ * std::cout << "detected (impact force: " << collisionData.GetImpactForce() << " )";
+ * }
+ * else
+ * {
+ * std::cout << "ended";
+ * }
+ * std::cout << std::endl;
+ * }
+ * \endcode
+ *
+ * <hr>
+ * \section collision-filtering Collision Filtering
+ *
+ * <p>
+ * When a large number of Dali::DynamicsBody objects are added to the simulation, collision detection can become a
+ * significant performance drain, where every possible pairing of objects needs to be checked for collisions.</p>
+ * <p>You can significantly reduce the number of pairs considered for collision detection by using a collision filter.</p>
+ * <p>Each Dali::DynamicsBody can belong to a user defined collision filter group and have a user defined collision filter mask.<p>
+ * <p>A Dali::DynamicsBody pair are considered for collision detection if one or more bits in the filter group from each Dali::DynamicsBody
+ * matches one or more bits in the filter mask of the other Dali::DynamicsBody.
+ * </p>
+ * <center><table border="1">
+ * <caption>Truth table</caption>
+ * <tr align="center">
+ * <th> P </th>
+ * <th> Q </th>
+ * <th>tested for collision?</th>
+ * </tr>
+ * <tr align="center">
+ * <td>0</th>
+ * <td>0</th>
+ * <td>no</th>
+ * </tr>
+ * <tr align="center">
+ * <td>0</th>
+ * <td>1</th>
+ * <td>no</th>
+ * </tr>
+ * <tr align="center">
+ * <td>1</th>
+ * <td>0</th>
+ * <td>no</th>
+ * </tr>
+ * <tr align="center">
+ * <td>1</th>
+ * <td>1</th>
+ * <td>yes</th>
+ * </tr>
+ * </table></center>
+ * <p>
+ * where <b>P</b> = bitwise AND of the collision group from the first Dali::DynamicsBody and the collision mask from the second Dali::DynamicsBody\n
+ * and <b>Q</b> = bitwise AND of the collision group from the second Dali::DynamicsBody and the collision mask from the first Dali::DynamicsBody.
+ * </p><br>
+ * <p>
+ * <b>Pseudo code for the filter check.</b>
+ * \code
+ * const bool canCollide( ( firstBody->GetCollisionGroup() & secondBody->GetCollisionMask() &&
+ * ( secondBody->GetCollisionGroup() & firstBody->GetCollisionMask() );
+ * \endcode
+ * </p>
+ * <h3 class="pg">Code example - Illustrating how to create multiple filter groups and masks.</h3>
+ * \code
+ * // Define some collision groups
+ * const short int group0( 1 << 1 );
+ * const short int group1( 1 << 2 );
+ * const short int group2( 1 << 3 );
+ *
+ * // Create some Dali::DynamicsBodyConfig objects
+ * Dali::DynamicsBodyConfig bodyConfig0( Dali::DynamicsBodyConfig::New() );
+ * Dali::DynamicsBodyConfig bodyConfig1( Dali::DynamicsBodyConfig::New() );
+ * Dali::DynamicsBodyConfig bodyConfig2( Dali::DynamicsBodyConfig::New() );
+ *
+ * // Assign the collision filters to the configurations
+ * bodyConfig0->SetCollisionGroup(group0);
+ * bodyConfig0->SetCollisionMask( group1 | group2 );
+ * bodyConfig1->SetCollisionGroup(group1);
+ * bodyConfig1->SetCollisionMask(group0);
+ * bodyConfig2->SetCollisionGroup(group2);
+ * bodyConfig2->SetCollisionMask(group0 | group2);
+ * \endcode
+ * <p>
+ * Collision detection is \b enabled between Dali::DynamicsBody pairs of...
+ * <ul>
+ * <li>group0 and group1 objects.</li>
+ * <li>group0 and group2 objects.</li>
+ * <li>group2 objects.</li>
+ * </ul>
+ * Collision detection is \b disabled between Dali::DynamicsBody pairs of...
+ * <ul>
+ * <li>group0 objects.</li>
+ * <li>group1 objects.</li>
+ * <li>group1 and group2 objects.</li>
+ * </ul>
+ * </p>
+ *
+ * See
+ * <ul>
+ * <li>Dali::DynamicsWorld::SignalCollision</li>
+ * <li>Dali::DynamicsCollision</li>
+ * <li>\ref Dali::DynamicsBodyConfig::SetCollisionGroup - to set the collision group</li>
+ * <li>\ref Dali::DynamicsBodyConfig::SetCollisionMask - to set the collision mask</li>
+ * </ul>
+ */
+
--- /dev/null
+/**
+ * \page dynamics-initialization Initializing the Simulation
+ * \section dynamics-prerequisites Dynamics prerequisites
+ * <p>
+ * In order to reduce binary size on devices, by default Dali core is built without Dynamics support. \n
+ * This can be enabled by adding the --enable-debug option to configure. The configure command should output this: \n
+ * \code
+ * Configuration
+ * -------------
+ * Dynamics support: yes
+ * \endcode
+ * <p>In addition to rebuilding Dali, a physics plugin (e.g. bullet, havok) should be installed on the target device.
+ * Dali adaptor provides the bullet plugin e.g. install dali-adaptor-dali-bullet-plugin-X.armv7l.rpm.
+ *
+ * \section initializing-world Initializing the World
+ * <p>
+ * The simulation is encapsulated and controlled by a instance of a Dali::DynamicsWorld object.\n
+ * \code
+ * // DynamicsWorld initialisation code
+ * Dali::DynamicsWorldConfig worldConfig( Dali::DynamicsWorldConfig::New() );
+ * Dali::Stage::GetCurrent().InitializeDynamics( worldConfig );
+ * \endcode
+ * <p>If the DynamicsWorld handle empty, then a prerequisite is missing (see above).
+ * Use a Dali::DynamicsWorldConfig object to specify options for the type of simulation required.\n
+ * Dali::DynamicsWorldConfig::RIGID supports rigid body dynamics only, while Dali::DynamicsWorldConfig::SOFT supports
+ * both rigid and soft body dynamics. Rigid body dynamics uses less CPU than soft body dynamics and is simpler to set up.
+ * \code
+ * // DynamicsWorld initialisation code
+ * Dali::DynamicsWorldConfig worldConfig( Dali::DynamicsWorldConfig::New() );
+ * // Choose a rigid body capable simulation
+ * worldConfig.SetType( Dali::DynamicsWorldConfig::RIGID );
+ * // or a soft and rigid body simulation
+ * worldConfig.SetType( Dali::DynamicsWorldConfig::SOFT );
+ * // Request Dali::Stage to create an instance of the DynamicsWorld
+ * Dali::Stage::GetCurrent().InitializeDynamics( worldConfig );
+ * \endcode
+ *
+ * \section initializing-world-advanced Advanced Initialization
+ * <h3>Units</h3>
+ * <p>All distance units in the simulation are based on meters, so positioning an actor at (0, -500, -1000)
+ * will position it 0.5km in the air and 1km away from the camera.\n So if the actor was to fall under
+ * the control of gravity it will seem to fall in slow motion. To counteract this the simulation units can
+ * be modified using Dali::DynamicsWorldConfig::SetUnit. The default value is set to 0.01 to change the
+ * simulation units to centimeters.
+ * </p>
+ * \code
+ * // change simulation back to meters
+ * worldConfig.SetUnit(1.0f);
+ * // or change simulation unit to millimeters
+ * worldConfig.SetUnit(1.0f/1000.0f);
+ * \endcode
+ *
+ * <h3>Simulation update ticks</h3>
+ * <p>The application developer can set the number of simulation time steps / DALi update tick using
+ * Dali::DynamicsWorldConfig::SetSimulationSubSteps.\n
+ * Use this to advance the simulation in smaller time steps, thus gaining a more accurate
+ * simulation for collision detection.\n
+ * Using this API may adversely affect performance, as the dynamics simulation is performing many more
+ * calculations each DAli tick than normal.</p>
+ * \code
+ * // Assume DAli is updating at 60Hz (16.667ms / update)
+ * //Setting subSteps to 1 will update the simulation once per DALi update.
+ * worldConfig.SetSimulationSubSteps(1);
+ * //Setting subSteps to 4 will perform 4 simulation updates per DALi update each with a time step of Approx 4.2ms.
+ * worldConfig.SetSimulationSubSteps(1);
+ * \endcode
+ * \section manipulating-world Using the World
+ * <h3>The Dynamics Simulation Root Actor</h3>
+ * <p>To manipulate the world within the scene-graph it must be connected to a Dali::Actor.\n
+ * All Rigid or Soft bodies that will be simulated must each be connected to a Dali::Actor which is a
+ * direct child of the dynamics root actor.</p>
+ * \code
+ * // Create an actor to represent our view of the simulation
+ * Dali::Actor dynamicsRootActor( Dali::Actor::New() );
+ * // retrieve a handle to the DynamicsWorld object initialized previously
+ * Dali::DynamicsWorld dynamicsWorld( Dali::Stage::GetCurrent().GetDynamicsWorld() );
+ * // Connect the Dali::DynamicsWorld and the Dali::Actor
+ * dynamicsWorld.SetRootActor( dynamicsRootActor );
+ * // Add root actor to Dali::Stage
+ * Dali::Stage::GetCurrent().Add( dynamicsRootActor );
+ * \endcode
+ * <h3>Gravity</h3>
+ * <p>The gravity applicable to the entire simulation can be set through Dali::DynamicsWorld::SetGravity.\n
+ * The gravity will apply a constant force on all Dali::DynamicsBody objects added to the world which have a
+ * non zero mass and are not flagged as kinematic.</p>
+ * \code
+ * // Set gravity to apply a force on the negative Y axis
+ * dynamicsWorld.SetGravity( Vector3( 0.0f, -10.0f, 0.0f ) );
+ * \endcode
+ * <hr>
+ * <p>See also
+* <p>See
+ * <ul>
+ * <li>Dali::DynamicsWorldConfig</li>
+ * <li>Dali::DynamicsWorld</li>
+ * <li>Dali::Stage::InitializeDynamics</li>
+ * </ul>
+ * </p>
+ *
+ */
+
--- /dev/null
+/*! \page dynamics-intro Dynamics - Introduction
+ *
+ * Dynamics gives the application developer a means to simulate physical kinetic properties on solid shapes.
+ * Simple physical shapes can be associated with a given actor, e.g., an actor representing a ball would have
+ * a spherical shape. Other simple shapes include cube, cone, cylinder and capsule (a pill or lozenge shape).
+ * \image html dynamics/dynamics-shapes.png "Simple Shapes"
+ * The application developer can provide more complex shapes using arbitrary meshes, however, this will use more
+ * CPU than the simple shapes.\n\n
+ * Dali supports both rigid body and soft body simulations.
+ * <ul>
+ * <li>Rigid body simulation means that the shapes used in the simulation cannot deform. This is simpler, and requires
+ * less processing power.</li>
+ * <li>Soft body simulation allows the shapes used in the simulation to deform, e.g. a rubber ball will squash and change
+ * shape when it hits a wall; or a cloth flag will flutter, etc.</li>
+ * </ul>
+ * Both forms of simulation provide automatic collision detection, and can be detected on all bodies in the simulation.
+ * The application developer can use signals to listen for detected collisions.
+ *
+ * \image html dynamics/dynamics-rigid.png "Example application"
+ */
+
--- /dev/null
+/**
+ * \page dynamics-joints Joints
+ * A Dali::DynamicsJoint represents a connection (or link) between a Dali::DynamicsBody pair.
+ * A Joint can optionally allow \ref linear "linear motion" and/or \ref angular "angular rotation" around its origin on one or more axis, and
+ * can have a \ref motors "motor" or \ref springs "spring" enabled on those axis.
+ * \image html dynamics/dynamics-joint2.png
+ * \section create-joint Creating a joint
+ * <p>Each Dali::DynamicsJoint is created by a Dali::Actor through its Dali::Actor::AddDynamicsJoint method.\n
+ * This method takes two parameters\n
+ * 1. The other Dali::Actor in the joint relationship.\n
+ * 2. A Dali::Vector3 relative offset from the owning Dali::Actor's current position.\n
+ * A joint is active in the simulation when both of the actors are connected to the Stage via the Dali::Actor
+ * set with Dali::DynamicsWorld::SetRootActorDynamics.
+ * </p>
+ * <h3>A code example creating two actors connected by a joint</h3>
+ * \code
+ * // create an actor to represent a rigid body
+ * Dali::Actor actor1( Dali::Actor::New() );
+ * // Enable dynamics for the actor, creating a rigid body with default configuration
+ * actor1.EnableDynamics( Dali::DynamicsBodyConfig::New() );
+ * actor1.SetPosition( Vector3( 0, 0, 0 ) );
+ * // create an actor to represent a second rigid body
+ * Dali::Actor actor2( Dali::Actor::New() );
+ * actor1.SetPosition( Vector3( 100, 0, 0 ) );
+ * // Enable dynamics for the actor, creating a rigid body with default configuration
+ * actor2.EnableDynamics( Dali::DynamicsBodyConfig::New() );
+ * // create the joint
+ * Vector3 relativeOffset( 25, 0, 0 );
+ * actor1.AddDynamicsJoint( actor2, relativeOffset );
+ * \endcode
+ * The joint is 25 units to the right of actor1 and 75 units to the left of actor2. If
+ * either actor is moved the joint will follow pulling the other actor with it.
+ * \section linear Linear Limits
+ * \image html dynamics/dynamics-joint.png "A joint allowing linear motion on the Y Axis"
+ * Limits control how much translation is allowed relative to the joints origin point, use Dali::DynamicsJoint::SetLinearLimit
+ * to set linear limits.
+ * \code
+ * ...
+ * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
+ * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
+ *
+ * // Allow translation from the joint's origin along the X axis of +/- 50 units
+ * joint.SetLinearLimit( Dali::DynamicsJoint::LINEAR_X, -50, 50);
+ * \endcode
+ * \section angular Angular Limits
+ * Limits control how much rotation is allowed around the joint's origin point, use Dali::DynamicsJoint::SetAngularLimit
+ * to set angular limits.
+ * \code
+ * ...
+ * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
+ * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
+ *
+ * // Allow rotation around the joint's origin on the Z axis of - 45 degrees and +90 degrees
+ * joint.SetAngularLimit( Dali::DynamicsJoint::ANGULAR_Z, -Dali::Degree(45), Dali::Degree(90) );
+ * \endcode
+ * \section motors Motors
+ * Motors apply a force along a given axis towards the lower or upper limit set on that axis.\n
+ * Use Dali::DynamicsJoint::EnableMotor to enable/disable a motor.\n
+ * The torque of the motor can be set with Dali::DynamicsJoint::SetMotorForce and the velocity
+ * with Dali::DynamicsJoint::SetMotorVelocity.
+ * \code
+ * ...
+ * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
+ * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
+ *
+ * // allow angular rotation on the Z axis
+ * joint.SetAngularLimit(Dali::DynamicsJoint::ANGULAR_Z, -Dali::Degree(90), Dali::Degree(90));
+ * // enable the Z axis angular motor
+ * joint.EnableMotor(Dali::DynamicsJoint::ANGULAR_Z, true);
+ * // set the motor torque
+ * joint.SetMotorForce(Dali::DynamicsJoint::ANGULAR_Z, 0.5f);
+ * // set the motor velocity (acts towards lower limit)
+ * joint.SetMotorVelocity(Dali::DynamicsJoint::ANGULAR_Z, -10.0f);
+ * \endcode
+ * \section springs Springs
+ * Springs apply a force to keep the Dali::DynamicsJoint origin at the spring's center point.
+ * A spring can be enabled for a given axis using Dali::DynamicsJoint::EnableSpring.\n
+ * The center point is set as a ratio between the lower and upper limits on the given axis using
+ * Dali::DynamicsJoint::SetSpringCenterPoint.\n
+ * The magnitude of the spring's centering force can be set with Dali::DynamicsJoint::SetSpringStiffness.\n
+ * Dali::DynamicsJoint::SetSpringDamping can be used to limit the amount of overshoot and oscillations
+ * of the spring as it settles at its center point.
+ * \code
+ * ...
+ * actor1.AddDynamicsJoint( actor2, Vector3(0, 0, 0) );
+ * DynamicsJoint joint( actor1.GetDynamicsJoint(actor2) );
+ *
+ * // allow linear motion on Y axis
+ * joint.SetLinearLimit(Dali::DynamicsJoint::LINEAR_Y, -50, 50);
+ * // enable the Y axis linear spring
+ * joint.EnableSpring(Dali::DynamicsJoint::LINEAR_Y, true);
+ * // set the center point of the spring at -40 ( 10% of the limits set )
+ * joint.SetSpringCenterPoint(Dali::DynamicsJoint::LINEAR_Y, 0.1f);
+ * // set the springs stiffness or centering force
+ * joint.SetSpringStiffness(Dali::DynamicsJoint::LINEAR_Y, 40.0f);
+ * // allow more oscillations before the spring comes to reset
+ * joint.SetSpringDamping(Dali::DynamicsJoint::LINEAR_Y, 0.1f);
+ * \endcode
+ * <hr>
+ * <p>See also
+ * <ul>
+ * <li>Dali::DynamicsJoint</li>
+ * <li>Dali::Actor::AddDynamicsJoint</li>
+ * <li>Dali::Actor::GetDynamicsJoint</li>
+ * </ul>
+ * </p>
+ */
+
--- /dev/null
+/*! \page event-system Event Handling
+
+Dali emits several signals to an application to inform it of user actions.
+
+<h2 class="pg">Touch Events</h2>
+
+An application can be notified when a user interacts with the touch screen on the device by connecting to the touch signal provided by Dali::Actor. This signal will be emitted by Dali whenever the touch occurs within the connected actor's bounds.
+
+Each point on the screen that is currently being touched or where touch has stopped is represented by a Dali::TouchPoint. This object stores information about the state of the touch point (down, up, motion etc.) and the co-ordinates of the touch.
+
+A collection of touch points at a specific moment in time is collated into a Dali::TouchEvent. When a multi-touch event occurs, each touch point represents the points that are currently being touched or the points where touch has stopped.
+
+The following example shows how a connection to a touch event signal can be established:
+
+@code
+bool OnTouch(Actor actor, const TouchEvent& touch)
+{
+ bool handled = false;
+
+ switch(touch.GetPointCount())
+ {
+ case 1: // Single touch
+ if (touch.GetPoint(0).GetState == TouchPoint::Down)
+ {
+ // Do action when first touches the touch screen.
+ ...
+ handled = true;
+ }
+ ...
+ break;
+
+ case 2: // Multi-touch event
+ ...
+ break;
+ ...
+ }
+
+ return handled; // true if we have handled the touch, false otherwise
+}
+
+// Elsewhere
+Actor actor = Actor::New();
+actor.SignalTouch().Connect(&OnTouch);
+@endcode
+
+The primary touch point is the first point that the user touches.
+
+The touch event is first emitted to the actor which is hit by the primary touch point. If this hit actor does not handle the event, then the event is offered to the hit actor's parent. Again, if the parent does not handle this event, it is then offered to its parent and so on until the stage is reached or the event is consumed.
+
+If a parent and child both connect to the Touch signal, then the touch event is first offered to the child. If it is consumed by the child, then the parent will not be informed.
+
+<h2 class="pg">Gestures</h2>
+
+A Dali::GestureDetector analyses a stream of touch events and attempts to determine the intention of the user. An actor is attached to a gesture detector and if the detector recognises a pattern, it will emit a detected signal to the application.
+
+The following gesture detectors are currently supported in Dali:
+
+- Dali::PinchGestureDetector - When the user moves two fingers towards or away from each other.
+- Dali::PanGestureDetector - When the user moves one or more fingers in the same direction.
+
+The example below shows how an application can be notified of a pinch gesture:
+
+@code
+void OnPinch(Actor actor, PinchGesture pinch)
+{
+ // Scale your actor according to the pinch scale
+ Vector3 newSize = actor.GetCurrentSize() * pinch.GetScale();
+ actor.SetSize(newSize);
+}
+
+// Elsewhere
+PinchDetector detector = PinchDetector::New();
+detector.Attach(myActor);
+detector.SignalDetected().Connect(&OnPinch);
+@endcode
+
+ */
+
+// @TODO: Add "Key Events" section
--- /dev/null
+/*! \page fundamentals Dali Fundamentals
+ *
+<h2 class="pg">Actors and the Stage</h2>
+
+A Dali application uses a hierachy of Dali::Actor objects to position visible content. An actor inherits a position relative to its parent, and can be moved relative to this point. UI controls can be built by combining multiple actors.
+
+To display the contents of an actor, it must be connected to the Dali::Stage. This provides an invisible root (top-level) actor, to which all other actors are added. A direct or indirect child of the root actor is considered "on-stage". Multi-touch events are received through signals emitted by on-stage actors.
+
+The following example shows how to connect a new actor to the stage:
+
+@code
+Actor actor = Actor::New();
+Stage::GetCurrent().Add(actor);
+@endcode
+
+<h2 class="pg">The Coordinate System</h2>
+
+The Stage has a 2D size, which matches the size of the application window. The default coordinate system in Dali has the origin at the top-left corner, with positive X to right, and position Y going
+downwards. This is intended to be convenient when laying-out 2D views.
+
+\image html coordinate-system-and-stage.png
+
+<h2 class="pg">Positioning Actors</h2>
+
+An actor inherits its parent's position. The relative position between the actor & parent is determined by 3 properties:
+
+1) ParentOrigin. This Vector3 property defines a point within the parent actor's area.
+
+\image html parent-origin.png
+
+The default is "top-left", which can be visualized in 2D as (0, 0), but is actually Vector3(0, 0, 0.5) in the 3D Dali world. The actor's position is relative to this point.
+
+2) AnchorPoint. This Vector3 property defines a point within the child actor's area.
+
+\image html anchor-point.png
+
+The default is "center", which can be visualized in 2D as (0.5, 0.5), but is actually Vector3(0.5, 0.5, 0.5) in the 3D Dali world. The actor's position is also relative to this point.
+
+3) Position. This is the position vector between the parent-origin and anchor-point.
+
+\image html actor-position.png
+
+Therefore by default, an actors position is the distance between its center and the top-left corner of its parent.
+
+An actor added directly to the stage with position (X = stageWidth*0.5, Y = stageHeight*0.5), would appear in the center of the screen. Likewise an actor with position (X = actorWidth*0.5, Y = actorWidth*0.5), would appear at the top-left of the screen.
+
+Note that since Dali is a 3D toolkit, this behaviour is the result of a default perspective camera setup.
+
+*
+*/
--- /dev/null
+/*! \page handle-body-idiom Handle – body
+<h2 class="pg">What is the Handle/Body (Pimpl) pattern?</h2>
+It is a technique for hiding implementation details in the header file.
+Dali achieves it by using "handles" in the public API. These handles internally contain a reference counted pointer to the concrete implementation.
+
+<h2 class="pg">Why does Dali::Object use the Handle/Body (Pimpl) pattern?</h2>
+It provides:
+- Better encapsulation
+- Easier memory management
+
+\par Better encapsulation
+Implementation details are hidden, only the required API is visible for the application developer.
+This way the danger of API/ABI breaks is also reduced since the implementation of a class can change without modifying the public API.
+
+\par Easier memory management
+Dali objects have implicit smart-pointer semantics.
+Each Dali::Object contains a single reference counted object which can be intitialized with the static "New" methods in the Dali API.
+This means that C++ new/delete operators do not have to be used (or paired) in the user code (RAII idiom).
+Of course there's no way of stopping users from allocating heap memory, but calls to the new operator can be minimised.
+
+<h2 class="pg">What does 'implicit smart-pointer semantics' mean in the case of Dali?</h2>
+
+Since Dali objects are just handles, they can be copied by value. When a Dali object is copied, both the copy and original will point to the same Dali resource.
+The internal Dali resources are reference counted; copying a Dali object will increase the reference count. A resource will not be deleted until all its Dali::Object handles are destroyed, or reset.
+
+\code
+class AnimationTest
+{
+...
+private:
+ Animation mAnimation; // animation handle
+}
+
+void AnimationTest::Initialize ()
+{
+ mAnimation = Animation::New(10.0f); // ref.count will be 1, animation object stays alive when method returns
+ ...
+}
+
+void AnimationTest::SetAnimation (Animation anim)
+{
+ mAnimation = anim; // ref.count of original animation decreased, 'anim' is referenced instead
+ // if nobody else had a reference on the initial animation, the object is destroyed
+}
+\endcode
+
+In some cases an internal resource may be referenced by other internal objects.
+A common example is when an actor is added to a container with Dali::Actor::Add() i.e. the container will reference its child.
+
+\code
+// At this point we own a Dali::Actor named "container"
+// Enter a code block
+{
+ // Create an image actor
+ Image img = Image::New(SomeImageFile);
+ Actor actor = ImageActor::New(img);
+
+ // Add the image actor to a container
+ container.Add(actor);
+}
+// Exit the code block
+// At this stage the image actor is still alive
+// We don't keep a Dali::Object handle to the image actor, but it can be retrieved from the container
+\endcode
+
+Objects can be implicitly converted to pointer-to-member type for validity checks.
+\code
+// Enter a code block
+{
+ // Create a NULL object
+ Object object;
+ // At this stage we cannot call any of the objects methods
+
+ if (!object) // This test is will pass, since the object is NULL
+ {
+ object = SomeClass::New();
+ ...
+ }
+ ...
+}
+\endcode
+
+Objects can be compared, this actually checks if the handles point to the same resource or not.
+\code
+void AnimationTest::SetAnimation (Animation anim)
+{
+ if (anim != mAnimation)
+ {
+ mAnimation = anim; // ref.count of original animation decremented (if valid), anim's reference count is increased
+ ...
+ }
+}
+\endcode
+
+To sum up implicit pointer semantics, Objects can be:
+- compared
+- passed by value; this increases the reference count
+- tested as a boolean value
+- used directly as member data
+- returned from functions
+
+*/
+
--- /dev/null
+/*! \page hello-world Hello World - explained
+
+The following steps are required for displaying the sentence 'Hello World' with Dali:
+
+- initialize the Dali library
+- create an Actor showing text
+- add it to the Stage
+
+To understand the basic building blocks of the UI make sure to read the chapter on \link fundamentals Dali Fundamentals\endlink first.
+
+Let's take a look at the code for this test application.
+
+<h2 class="pg"> Example code </h2>
+\code
+#include <dali/dali.h>
+
+using namespace Dali;
+
+/******************************************************
+ * Demonstrates how to display "Hello World" on screen
+ ******************************************************/
+
+class ExampleApp
+{
+public:
+ ExampleApp(Application &app)
+ : mApp(app)
+ {
+ // Connect to Dali::Application init signal. Do not make calls to Dali before this signal is received.
+ app.SignalInit().Connect(this, &ExampleApp::Create);
+ }
+
+ ~ExampleApp()
+ {
+ // Remove Hello World TextActor from stage
+ Stage::GetCurrent().Remove(mTextActor);
+ }
+
+public:
+
+ void Create(Application& app)
+ {
+ // Initialize the actor
+ mTextActor = TextActor::New("Hello World");
+
+ // Center the actor. Note: default anchor point is CENTER
+ mTextActor.SetParentOrigin(ParentOrigin::CENTER);
+
+ // Display the actor on the stage
+ Stage::GetCurrent().Add(mTextActor);
+ }
+
+private:
+ Application& mApp;
+ TextActor mTextActor;
+};
+
+int
+main(int argc, char **argv)
+{
+ Application daliApp(&argc, &argv);
+
+ ExampleApp helloApp (daliApp);
+ daliApp.MainLoop();
+
+ return 0;
+}
+
+\endcode
+
+ There are a couple of steps which are very important to understand.
+
+ <h2 class="pg"> Initializing Dali </h2>
+ The application should not use the Dali library until it has sent the init complete signal!
+ That's why we connect our ExampleApp::Create callback to Dali::Application's SignalInit signal:
+ \code
+ ...
+ app.SignalInit().Connect(this, &ExampleApp::Create);
+ ...
+ \endcode
+
+ <h2 class="pg"> Reference counting </h2>
+ The application should store Actors' and resources' handles.
+ Dali objects are reference counted, which makes sure they exist only as long as they are needed.
+ That's why we store the Actor's handle:
+ \code
+ ...
+ mTextActor = TextActor::New("Hello World");
+ ...
+ \endcode
+ Even if the TextActor is removed from the stage, it will be kept alive through our reference.\n
+ You can read more about implicit smart-pointer semantics in chapter \link handle-body-idiom Handle – body\endlink.
+
+ <h2 class="pg"> Main loop </h2>
+ To 'run' the application, it's main loop should be started.
+ This ensures that images are displayed, events, signals are dispatched and captured and so on.
+ \code
+ ...
+ daliApp.MainLoop();
+ ...
+ \endcode
+ \n \n
+ On X11 platform you can compile the above example with:
+ \code
+ g++ `pkg-config --libs --cflags dali` hello-dali.cpp -o hello
+ \endcode
+
+ After running './hello' this should be visible on the screen:
+
+ \image html Text-Actor.png "Hello world example"
+
+*/
--- /dev/null
+/*! \page image-text-mesh-actor Image, Text and Mesh actors
+ *
+ *
+ * <h1 class="pg">Overview</h1>
+ * The Dali::ImageActor, Dali::TextActor, Dali::MeshActor are inherited from Dali::Actor and provide means to display resources like Images, Text and Geometries (Triangle meshes) on the stage.
+ * All the Dali::Actor methods can be called on them.<br>
+ *
+ * - <b>ImageActor:</b> An actor for displaying Images. It allows the developer to display a Dali::Image object on the stage.<br>
+ * - <b>TextActor:</b> An actor for displaying text.<br>
+ * - <b>MeshActor:</b> An actor for displaying one or more mesh geometries. It may have children, which may be plain actors or other mesh actors.<br>
+ *
+ * <h1 class="pg">Image Actor</h1>
+ *
+ * <h2 class="pg">Construction</h2>
+ * The Image Actor is constructed by passing a Dali::Image object
+ *
+ * @code
+ * Dali::Image image = Image::New(myImageFilename);
+ * Dali::ImageActor myImageActor = ImageActor::New(image);
+ * @endcode
+ *
+ *
+ * <h2 class="pg">Style</h2>
+ * The Actor can render an image in two different ways.<br>
+ * -# STYLE_QUAD: A simple flat quad style for redering image.<br>
+ * -# STYLE_NINE_PATCH: This style gives the flexibility to stretch images by dividing it into 9 sections.
+ * The four corners are unscaled; the four edges are scaled in one axis, and the middle is scaled in both axes.<br>
+ *
+ * @code
+ * // default : ImageActor::STYLE_QUAD
+ * myImageActor.SetStyle (Dali::ImageActor::STYLE_NINE_PATCH);
+ * @endcode
+ *
+ *
+ * <h2 class="pg">Border</h2>
+ * The border is used in the ImageActor::STYLE_NINE_PATCH. It defines the border values of the image for stretching.<br>
+ *
+ * @code
+ * Dali::ImageActor::Border border(0.45,0.15,0.45,0.15);
+ * myImageActor.SetBorder(border);
+ * @endcode
+ *
+ *
+ * <h2 class="pg">Pixel area</h2>
+ * The area of the image to be displayed by the Image Actor can be set by setting the Pixel area. Pixel area is relative to the top-left (0,0) of the image.
+ * @code
+ * Rect<int> pixel1( myX, myY, myWidth, myHeight );
+ * if(!myImageActor.IsPixelAreaSet())
+ * {
+ * myImageActor.SetPixelArea( pixel1 );
+ * }
+ *
+ * //Removes the pixel are set
+ * myImageActor.ClearPixelArea();
+ * @endcode
+ *
+ *
+ * <h2 class="pg">Changing the image</h2>
+ * The Image Actor needs a reference to a Dali::Image object on creation. However the Image object can be later changed by calling DaliActor:SetImage
+ * @code
+ * myImageActor.SetImage( newImage );
+ * @endcode
+ *
+ * <h2 class="pg">Fade in</h2>
+ * It's possible to fade in the image gradually when first rendered.
+ * @code
+ * if (!myImageActor.GetFadeIn())
+ * {
+ * myImageActor.SetFadeIn(true);
+ * }
+ *
+ * // default : 1 Second
+ * myImageActor.SetFadeInDuration(seconds);
+ * @endcode
+ *
+ *
+ *
+ *
+ *
+ * <h1 class="pg">Text Actor</h1>
+ *
+ *
+ * <h2 class="pg">Displaying Text</h2>
+ * The text displayed by the text actor is initialised/set on construction, which can be changed later.
+ *
+ * @code
+ * Dali::TextActor myTextActor = Dali::TextActor::New("Hi");
+ * std::string str("Hello");
+ * if (myTextActor.GetText() != str)
+ * {
+ * myTextActor.SetText(str);
+ * }
+ * @endcode
+ *
+ *
+ * <h2 class="pg">Fonts</h2>
+ * It's possible to specify a font for the text displayed by the text actor.
+ * @code
+ * Dali::Font freeSerif = Dali::Font::New("FreeSerif", 8);
+ * myTextActor.SetFont(freeSerif);
+ * @endcode
+ *
+ *
+ * <h2 class="pg">Ellipsis</h2>
+ * It is possible to display an ellipsis in the TextActor when the text is truncated.
+ * @code
+ * std::string str("...");
+ * if (myTextActor.GetEllipsis() != str)
+ * {
+ * myTextActor.SetEllipsis(str);
+ * }
+ * @endcode
+ *
+ * <h2 class="pg">Style</h2>
+ *
+ * By calling the Dali::TextActor::SetTextStyle or by passing a Dali::TextStyle to the constructor, it's possible to define styling parameters such as color, font, size, outline, glow, shadow, italics or bold.
+ * @code
+ * TextStyle style;
+ * style.SetItalic( true );
+ *
+ * myTextActor.SetTextStyle( style );
+ * @endcode
+ *
+ * @see Dali::TextActor::SetTextStyle()
+ *
+ * It is possible to specify the text fit style for the text actor. The developer can specify whether the ellipsis should appear on the left, centre, or at the end
+ * @code
+ * // default : NONE
+ * myTextActor.SetTextFitStyle(TextUtilities::EllipsizeRight);
+ * @endcode
+ *
+ * <h2 class="pg">Loading state</h2>
+ * It is possible to get the font loading status for the text and do processing accordingly.
+ * @code
+ * // observe text loading and do some processing when it's done
+ * if( Dali::ResourceLoadingSucceeded == myTextActor.GetLoadingState() )
+ * {
+ * // text already loaded, Do the processing here
+ * OnTextFontLoaded();
+ * }
+ * else
+ * {
+ * // text not yet loaded, Connect to the SignalTextAvailable signal and Do the processing when it occurs
+ * myTextActor.SignalTextAvailable().Connect(this, &MyClass::OnTextFontLoaded);
+ * }
+ * @endcode
+ *
+ *
+ *
+ *
+ * <h1 class="pg">Mesh Actor</h1>
+ *
+ * <h2 class="pg">Construction</h2>
+ * The mesh actor is created by passing a reference to Dali::Mesh object
+ *
+ * @code
+ * Dali::Mesh mesh = Dali::Mesh::New();
+ * Dali::MeshActor myMeshActor = Dali::MeshActor::New(mesh);
+ * @endcode
+
+ *
+ * <h2 class="pg">Modifying material</h2>
+ * The developer can change the material of mesh actor using the material entity name.
+ *
+ * @code
+ * Dali::Image image = Dali::Image::New(myTextureFile);
+ * myCustomMaterial = Dali::Material::New("CustomMaterial");
+ * myCustomMaterial.SetDiffuseTexture(image);
+ * Dali::MeshActor::SetMaterial(myMeshActor, materialEntityNameInModel, 0, myCustomMaterial);
+ *
+ * @endcode
+ *
+ *
+ */
+
--- /dev/null
+/*! \page item-view Item View
+ * Your text here
+ *
+ * References to Dali::Toolkit::ItemView will work...
+ *
+ */
+
--- /dev/null
+/*! \page markup-processor Markup processor
+ *
+ * <h1 class="pg">Overview</h1>
+ *
+ * Dali::Toolkit::MarkupProcessor functions provide mechanisms to build and modify a Dali::Toolkit::MarkupProcessor::StyledTextArray used to store text with style.
+ *
+ * <h1 class="pg">Build a styled text array from a markup string</h1>
+ *
+ * Dali::Toolkit::MarkupProcessor::GetStyledTextArray() could be used to convert an html-ish markup string into a styled text array. This string uses html-ish tags to
+ * define the text's style as follows:
+ *
+ * <ul>
+ * <li>\e \<b\>\</b\> Bold text.
+ * i.e. \<b\>Bold text\</b\>"
+ * \image html text-view/Bold.png
+ *
+ * <li>\e \<i\>\</i\> Italic text.
+ * i.e. \<i\>Italic text\</i\>"
+ * \image html text-view/Italic.png
+ *
+ * <li>\e \<u\>\</u\> Underlined text.
+ * i.e. \<u\>Underline text\</u\>"
+ * \image html text-view/Underline.png
+ *
+ * <li>\e \<br /\> New line.
+ *
+ * <li>\e \<font\>\</font\> Specifies font properties:
+ * <ul>
+ * <li> \e face The name of a font or font family.
+ * <li> \e style The style of a font.
+ * <li> \e size Font point size. @see Dali::PointSize.
+ * <li> \e color Font color. See the \ref color section for more details.
+ * </ul>
+ *
+ * i.e. \<font face='FreeSerif' style='Regular'\>FreeSerif font\</font\>
+ * \image html text-view/FreeSerifFont.png
+ *
+ * <li>\e \<shadow\>\</shadow\> Specifies shadow properties.
+ * <ul>
+ * <li> \e paramx X offset.
+ * <li> \e paramy Y offset.
+ * <li> \e color Shadow color. See the \ref color section for more details.
+ * </ul>
+ *
+ * i.e. \<shadow color='black' paramx='1.5' paramy='1.5'\>Black shadow\</shadow\>
+ * \image html text-view/Black-Shadow.png
+ *
+ * @see Dali::TextActor::SetShadow()
+ * <br><br>
+ * <li>\e \<glow\>\</glow\> Specifies glow properties.
+ * <ul>
+ * <li> \e param Glow around the text.
+ * <li> \e color Glow color. See the \ref color section for more details.
+ * </ul>
+ *
+ * i.e. \<smooth param='0.65'\>\<glow color='blue' param='0.05'\>Blue glow\</glow\>\</smooth\>
+ * \image html text-view/Blue-Glow.png
+ *
+ * @see Dali::TextActor::SetGlow()
+ * <br><br>
+ * <li>\e \<outline\>\</outline\> Specifies outline properties.
+ * <ul>
+ * <li> \e paramx X thickness.
+ * <li> \e paramy Y thickness.
+ * <li> \e color Outline color. See the \ref color section for more details.
+ * </ul>
+ *
+ * i.e. \<outline color='red' paramx='0.5' paramy='0.5'\>Red outline\</outline\>
+ * \image html text-view/Red-Outline.png
+ *
+ * @see Dali::TextActor::SetOutline()
+ * <br><br>
+ * <li>\e \<smooth\>\</smooth\> Specify the smooth edge.
+ * <ul>
+ * <li> \e param Distance field.
+ * </ul>
+ *
+ * i.e. \<smooth param='0.3'\>Smooth text\</smooth\>
+ * \image html text-view/Smooth-Text.png
+ *
+ * @see Dali::TextActor::SetSmoothEdge()
+ * </ul>
+ *
+ * See also \ref color, \ref special_characters and \ref example for more details.
+ *
+ * <h1 class="pg">Get a markup string from a styled text array</h1>
+ *
+ * Dali::Toolkit::MarkupProcessor::GetMarkupString() could be used to convert a styled text array into an html-ish markup string.
+ *
+ * <h1 class="pg">Modify a styled text array</h1>
+ *
+ * Different functions are provided to modify whole or part of a styled text array with a given style. A mask could be used to modify only some properties of the style.
+ *
+ * @see Dali::Toolkit::MarkupProcessor::SetTextStyle( StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask )
+ * @see Dali::Toolkit::MarkupProcessor::SetTextStyle( const Text& text, StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask )
+ * @see Dali::Toolkit::MarkupProcessor::SetTextStyleToRange( StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask, std::size_t begin, std::size_t end )
+ *
+ * <h1 class="pg">Appendix</h1>
+ * \section color Color
+ *
+ * Different options could be used to define a color:
+ *
+ * <ul>
+ * <li> Hexadecimal with alpha channel. 0xAARRGGBB with the alpha channel in the most significant bits.
+ * <li> Hexadecimal without alpha channel. 0xRRGGBB.
+ * <li> Web color format (six or three digits). \#RRGGBB, \#RGB
+ * <li> Some colors could be defined with natural language: <em>black, white, red, green, blue, yellow, magenta, cyan</em> and \e transparent.
+ * </ul>
+ *
+ * \section special_characters Special characters
+ *
+ * \< and \> characters are used to build the html-ish tags. To type them is needed to add a back slash character in front of them.
+ * @note in c and c++ the back slash is represented with a double back slash '\\\\'.
+ *
+ * i.e. text.SetText("a \\< b \\< c");
+ * \image html text-view/AlessBlessC.png
+ *
+ * It transform any pair CR+LF new line characters into a single LF new line character.
+ *
+ * \section fonts Font Style, Weight and Smooth
+ *
+ * This appendix shows the differences and relations between the font style, the font weight, the smoothness and the italics.
+ *
+ * When a font is loaded, Dali uses different mechanisms to modify the render of glyphs.<br><br>
+ * i.e \<font face='Samsung Sans' size='24'\>Hello World\</font\> produces the "Hello World" bellow.
+ * \image html text-view/FontAppendix01.png
+ * By adding the \<i\> \<b\> \<smooth\> tags to the markup string or using the Dali::TextStyle::SetItalics(), Dali::TextStyle::SetWeight() or Dali::TextStyle::SetSmoothEdge() methods,
+ * Dali modifies how glyphs of the same font are rendered.<br><br>
+ * i.e \<i\>\<font face='Samsung Sans' size='24'\>Hello World\</font\>\</i\>
+ * \image html text-view/FontAppendix02.png
+ * i.e \<b\>\<font face='Samsung Sans' size='24'\>Hello World\</font\>\</b\>
+ * \image html text-view/FontAppendix03.png
+ *
+ * The smooth parameter can be used to adjust the thickness of the rendered glyphs.<br><br>
+ * i.e<br> \<smooth param=0.65\>\<font face='Samsung Sans' size='24'\>Hello World\</font\>\</smooth\>\<br /\><br>
+ * \<font face='Samsung Sans' size='24'\>Hello World\</font\>\<br /\><br>
+ * \<smooth param=0.4\>\<font face='Samsung Sans' size='24'\>Hello World\</font\>\</smooth\>\<br /\><br>
+ * \<b\>\<font face='Samsung Sans' size='24'\>Hello World\</font\>\</b\>\<br /\><br>
+ * \<smooth param=0.2\>\<font face='Samsung Sans' size='24'\>Hello World\</font\>\</smooth\>
+ *
+ * \image html text-view/FontAppendix04.png
+ *
+ * All "Hello World" above have been rendered using the same font, saving some memory. Alternatively, the platform can provide fonts with different styles.<br>
+ *
+ * i.e. Samsung platform provides among others:<br>
+ * Samsung Sans:style=Light<br>
+ * Samsung Sans:style=Regular<br>
+ * Samsung Sans:style=Medium<br>
+ *
+ * \<font face='Samsung Sans' style='Light' size='24'\>Hello World\</font\>\<br /\><br>
+ * \<font face='Samsung Sans' style='Regular' size='24'\>Hello World\</font\>\<br /\><br>
+ * \<font face='Samsung Sans' style='Medium' size='24'\>Hello World\</font\>
+ * \image html text-view/FontAppendix05.png
+ *
+ * The three "Hello World" above have been rendered with three different fonts.<br>
+ *
+ * The <i>fc-list</i> command can be executed on the platform command line to check with fonts and which styles are supported.
+ *
+ * \section example Example
+ *
+ * \code
+ * const std::string text( "<font size='16' color='black'>"
+ * "<i>Italics: 기울임 꼴</i><br/>"
+ * "<u>Underline: 밑줄</u><br/>"
+ * "<b>Bold: 두꺼운</b><br/>"
+ * "<font face='FreeSerif'>Font FreeSerif</font><br/>"
+ * "<font color='white'><shadow color='black' paramx='1.5' paramy='1.5'>Shadow: 그림자</shadow></font><br/>"
+ * "<font color='white'><smooth param='0.75'><glow color='blue' param='0.1'>Glow: 빛나다</glow></smooth></font><br/>"
+ * "<font color='white'><outline color='red' paramx='0.5' paramy='0.5'>Outline: 윤곽선</outline></font><br/>"
+ * "<smooth param='0.3'>Smooth: 부드럽게</smooth><br/>"
+ * "</font>" );
+ *
+ * Toolkit::MarkupProcessor::StyledTextArray styledText;
+ * Toolkit::MarkupProcessor::GetStyledTextArray( text, styledText, true );
+ *
+ * Toolkit::TextView textView = Toolkit::TextView::New( styledText );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ *
+ * \image html text-view/text-view.png
+ * Text generated with the example above.
+ */
--- /dev/null
+/*! \page performance-profiling Performance Profiling
+ *
+ * <h2 class="pg">Enable Logging</h2>
+ *
+ * Setting DALI_LOG_PERFORMANCE environment variable will enable performance profiling <br>
+ * It uses a bit mask to decide what to log. <br>
+ * The log options are:<br>
+ * \code
+ * Bit 0 = Log update and render threads (e.g. DALI_LOG_PERFORMANCE=1 dali-demo)
+ * Bit 1 = Log event process time (e.g. DALI_LOG_PERFORMANCE=2 dali-demo)
+ * Bit 2 = Log Dali markers to trace file (e.g. DALI_LOG_PERFORMANCE=4 dali-demo)
+ *
+ * To log both update, render and event times, then combine bits 0 and 1.<br>
+ * DALI_LOG_PERFORMANCE=3 dali-demo
+ * \endcode
+ *
+ *
+ * <h2 class="pg">Background</h2>
+ * The Dali rendering pipeline has 2 stages.
+ * Each stage is typically run once per frame.
+ *
+ * <ul>
+ * <li> 1. Update
+ * <ul>
+ * <li> Run animations
+ * <li> Run constraints
+ * <li> Run physics
+ * <li> Update the scene-graph
+ * </ul>
+ * <li> 2. Render
+ * <ul>
+ * <li> Upload 3D data using OpenGL ( textures, vertex buffers etc).
+ * <li> Draw the scene using OpenGL
+ * </ul>
+ * </ul>
+ *
+ * To run at 60 FPS (16 milliseconds per frame), it is recommended to stay below the following times:
+ * <ul>
+ * <li> Update: 4 milliseconds
+ * <li> Render: 4 milliseconds
+ * </ul>
+ *
+ * This will leave enough time for the output to be composited (if the system uses a compositor) and to avoid using
+ * too much CPU power.
+ * The main Dali application thread which deals with event processing is independent of the update / render threads. <br>
+ * This means animations won't stop if the main thread decides to do a long operation like downloading a file from the internet.
+ *
+ * Performance logging uses Dali log output which on Tizen is dlog, but this can also be used on desktop by redirecting stderr to a file.<br>
+ *
+ * Example:
+ * \code
+ * $ export DALI_LOG_PERFORMANCE=1
+ * $ dali-demo
+ * $
+ * $ ...
+ * $ I/DALI ( 5692): slp-logging.cpp: LogMessage(40) > Update , min 0.59 ms, max 6.43 ms, total (3.4 secs), avg 1.26 ms
+ * $ I/DALI ( 5692): slp-logging.cpp: LogMessage(40) > Render , min 1.67 ms, max 5.01 ms, total (4.5 secs), avg 3.71 ms
+ * \endcode
+ *
+ * If nothing is animating Dali will enter a paused state to save power. At this
+ * point nothing will be logged.
+ *
+ * <h2 class="pg">Performance advice </h2>
+ *
+ *
+ * <h3> Tips to reduce update times: </h3>
+ * <ul>
+ * <li> Keep the actor count as small as possible.
+ * <ul>
+ * <li> Less actors == less processing
+ * <li> Try to keep invisible or un-used actors off the stage. Don't have hidden views on the stage.
+ * </ul>
+ * <li> Ensure constraints are kept as simple as possible
+ * </ul>
+ *
+ * <h3> Tips to reduce render times: </h3>
+ *
+ * <ul>
+ * <li> Keep the visible actor count as small as possible == less draw calls
+ * <li> If using a fixed set of images, try pre-generating a texture-atlas.
+ * <ul>
+ * <li> For each image within the Atlas, use ImageActor.SetPixelArea() to use it.
+ * <li> This reduces texture state changes when rendering.
+ * </ul>
+ * <li> Try to use 9-patch when you need to stretch an image while maintaining the border size.
+ * <ul>
+ * <li> See ImageActor::STYLE_NINE_PATCH
+ * </ul>
+ * <li> When using layers try to disable the depth test to avoid the depth buffer being cleared.
+ * <li> If writing custom shaders, try to keep them as simple as possible.
+ * <li> Try to keep texture sizes as small as possible.
+ * </ul>
+ *
+ * <h2 class="pg">Application profiling</h2>
+ *
+ * The main application thread in Dali is used to process and respond to events such as touch, key, mouse, gestures and timers. <br>
+ * The time taken to process events can be measured by setting DALI_LOG_PERFORMANCE environment variable to 2 <br>
+ *
+ * Example:
+ * \code
+ * $ export DALI_LOG_PERFORMANCE=2
+ * $ dali-demo
+ * $
+ * $ ...
+ * $ INFO: DALI: Event , min 0.01 ms, max 14.99 ms, total (2.4 secs), avg 1.83 ms
+ * \endcode
+ *
+ * Inside the event processing, the application may be listening for certain events. <br>
+ * For example when an actor is touched, some application code may be run in an OnTouchEvent callback. <br>
+ * By checking the max times you can check for any spikes that occur when interacting with the application.
+ *
+ * Example:
+ * \code
+ * $ INFO: DALI: Event , min 0.10 ms, max 500.01 ms, total (6.4 secs), avg 20.83 ms
+ *
+ * - Something has taken 500 ms = 1/2 second during event processing.
+ * - Need to investigate what the application is doing for 1/2 a second.
+ * \endcode
+ *
+ *
+ * <h2 class="pg">Logging performance markers to Kernel trace file</h2>
+ *
+ * Ftrace is a kernel tracer designed to help developers find out what is going on inside the kernel.<br>
+ * It can be used for analysing how long Dali takes to perform different tasks and <br>
+ * what Dali is doing in relation to other system processes / interrupts.
+ *
+ * On Tizen if the kernel has been built with ftrace enabled, then Dali can log out to ftrace.<br>
+ * This gives exact time stamps of the main events in Dali.
+ * Current markers that are logged:
+ * <ul>
+ * <li> DALI_V_SYNC. The heart beat which represents Dali should start creating a new frame if anything has changed.<br>
+ * Typically runs 60 Frames per second, depending on display refresh rate.
+ * <li> DALI_UPDATE_START. Dali update task has started.
+ * <li> DALI_UPDATE_START. Dali update task has finished
+ * <li> DALI_RENDER_START. Dali render task has started
+ * <li> DALI_RENDER_END. Dali render task has finished
+ * </ul>
+ *
+ * <h3> Checking ftrace is working on Tizen</h3>
+ *
+ * Documentation for ftrace:
+ * Follow these instructions to ensure the debugfs has been mounted, and the kernel you are using
+ * has been built with ftrace enabled. <br>
+ * https://www.kernel.org/doc/Documentation/trace/ftrace.txt
+ *
+ * To check ftrace is working:
+ * \code
+ * $ cd /sys/kernel/debug/tracing
+ * $ echo 1 > tracing_enabled (enabled tracing)
+ * $ echo "test" > trace_marker
+ * $ echo 0 > tracing_enabled (disable tracing)
+ * $ cat trace
+ * #
+ * # TASK-PID CPU# TIMESTAMP FUNCTION
+ * # | | | | |
+ * <...>-2539 [001] 267964.345607: tracing_mark_write: test
+ *
+ *
+ * If the message did not get added to the trace, then check the write permissions on trace_marker file. E.g.
+ * $ chmod ugoa+w trace_marker
+ * \endcode
+ *
+ * To view Dali markers in trace file<br>
+ *
+ * \code
+ * $ export DALI_LOG_PERFORMANCE=4
+ * $ dali-demo
+ * $
+ * $ cat /sys/kernel/debug/tracing/trace
+ *
+ * <...>-3330 [000] 785155.216611: tracing_mark_write: SPI_EV_DALI_V_SYNC
+ * <...>-3328 [003] 785155.216644: tracing_mark_write: SPI_EV_DALI_UPDATE_START
+ * <...>-3328 [003] 785155.217045: tracing_mark_write: SPI_EV_DALI_UPDATE_END
+ * <...>-3329 [001] 785155.227418: tracing_mark_write: SPI_EV_DALI_RENDER_START
+ * <...>-3329 [001] 785155.227807: tracing_mark_write: SPI_EV_DALI_RENDER_END
+ * <...>-3330 [000] 785155.233336: tracing_mark_write: SPI_EV_DALI_V_SYNC
+ * <...>-3328 [002] 785155.233374: tracing_mark_write: SPI_EV_DALI_UPDATE_START
+ * <...>-3328 [002] 785155.233672: tracing_mark_write: SPI_EV_DALI_UPDATE_END
+ * <...>-3329 [001] 785155.235161: tracing_mark_write: SPI_EV_DALI_RENDER_START
+ * <...>-3329 [001] 785155.235475: tracing_mark_write: SPI_EV_DALI_RENDER_END
+ * <...>-3330 [000] 785155.250029: tracing_mark_write: SPI_EV_DALI_V_SYNC
+ * <...>-3328 [003] 785155.250065: tracing_mark_write: SPI_EV_DALI_UPDATE_START
+ * <...>-3328 [003] 785155.250330: tracing_mark_write: SPI_EV_DALI_UPDATE_END
+ * <...>-3329 [001] 785155.252860: tracing_mark_write: SPI_EV_DALI_RENDER_START
+ * <...>-3329 [001] 785155.253178: tracing_mark_write: SPI_EV_DALI_RENDER_END
+ * <...>-3329 [001] 785155.264508: tracing_mark_write: SPI_EV_DALI_RENDER_START
+ * <...>-3329 [001] 785155.265006: tracing_mark_write: SPI_EV_DALI_RENDER_END
+ * \endcode
+ */
--- /dev/null
+/*! \page properties Properties
+ *
+@section property-indices Property Indices
+
+DALi has a property system and provides several different kinds of properties. The following table
+shows the index range of the different properties in place.
+
+<table>
+ <tr> <td><b>Kind</b></td> <td><b>Description</b></td> <td style="text-align:center;"><b>Range</b></td> </tr>
+ <tr> <td>Default</td> <td>Properties defined within DALi Core, e.g. Dali::Actor, Dali::ShaderEffect default properties etc.</td> <td style="text-align:center;">0 to 9999999</td> </tr>
+ <tr> <td>Registered</td> <td>Properties registered using Dali::PropertyRegistration</td> <td style="text-align:center;">10000000 to 19999999</td> </tr>
+ <tr> <td>Control</td> <td>Property range reserved by Dali::Toolkit::Control</td> <td style="text-align:center;">10000000 to 10001000<br>
+ \link Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_START_INDEX CONTROL_PROPERTY_START_INDEX\endlink
+ to \link Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_END_INDEX CONTROL_PROPERTY_END_INDEX\endlink</td> </tr>
+ <tr> <td>Derived Control</td> <td>Property range for control deriving directly from Dali::Toolkit::Control</td> <td style="text-align:center;">10001001 to 19999999</td> </tr>
+ <tr> <td>Custom</td> <td>Custom properties added to instance using Dali::Handle::RegisterProperty</td> <td style="text-align:center;">50000000 onwards</td> </tr>
+</table>
+
+*
+*/
--- /dev/null
+/*! \page resource-tracking Resource Tracking
+ *
+ *
+ * <h2 class="pg">Enable Logging</h2>
+ * Setting DALI_ENABLE_LOG environment variable to RESOURCE_LOG will enable resource usage logging in Dali applications.<br>
+ *
+ * On target resource logging utilizes dlog, but this can also be used on desktop by redirecting stderr to a file.<br>
+ *
+ * The generated information includes any image files that are loaded with their dimensions,<br>
+ * GPU memory consumption, CPU RAM used and details of texture atlases created.
+ *
+ * <h2 class="pg">Viewing Resource Logs</h2>
+ * dalireslog.sh is installed as part of the dali-adaptor package and can be found in the adaptors/tizen/scripts folder.<br>
+ * The script shows a summary of memory used by resources.
+ *
+ * USAGE:
+ * ./dalireslog.sh [FILE]<br>
+ * if FILE isn't specified, the script will try to use dlogutil.
+ *
+ * Example:
+ *
+ * sh-4.1$ ./dalireslog.sh<br>
+ *
+ * <i>On a separate terminal:</i><br>
+ * sh-4.1$ DALI_ENABLE_LOG=RESOURCE_LOG /opt/apps/com.samsung.dali-demo/bin/album.example
+ *
+ * Example on desktop:<br><br>
+ * jon-doe\@ws-1234$ DALI_ENABLE_LOG=RESOURCE_LOG blind-effect.example 2>/home/SERILOCAL/john.doe/log.txt<br>
+ *
+ * <i>On a separate terminal:</i><br>
+ * dalireslog.sh ~/log.txt
+ *
+ * Displayed information:<br>
+ *
+ * <ul>
+ * <li>3D - amount of GPU memory used by application.<br>
+ * <li>MEM Atlas - amount of GPU memory used by texture atlases (usually this refers to font atlases). <br>
+ * <li>Number of atlases - how many texture atlases are present in memory.<br>
+ * </ul>
+ * A list of files is displayed in the main view, with different color codes representing different states:<br>
+ *
+ * <ul>
+ * <li>CPU - resource is in memory, but hasn't been uploaded to a GL texture.<br>
+ * <li>GPU - resource has been uploaded to a GL texture, bitmap buffer discarded.<br>
+ * <li>CPUGPU - resource has been uploaded to a GL texture, but still present in CPU memory as well.<br>
+ * <li>DISCARDED - resource has been discarded, memory freed up.
+ * </ul>
+ */
--- /dev/null
+/*! \page script-hello Scripting Hello World
+ *
+ * <h2 class="pg">Hello World - JSON layout</h2>
+ *
+ * The following JSON code is the minimum required to put the sentence "Hello World" on the screen.
+ *
+ * @code
+ * {
+ * "fonts":
+ * {
+ * "freesans": {"name": "FreeSans", "point-size": 12.0, "weight": "WEIGHT_REGULAR" }
+ * },
+ * "actors":
+ * [
+ * {"name":"text-actor",
+ * "type":"Text",
+ * "text":"Hello World",
+ * "font":"freesans",
+ * "parent-origin":"CENTER"
+ * }
+ * ]
+ * }
+ * @endcode
+ *
+ * The following c++ code loads the JSON file
+ *
+ * @code
+ * Builder builder = Builder::New();
+ *
+ * std::string json_data(ReadFile("layout.json"));
+ *
+ * builder.LoadFromString(json_data);
+ *
+ * Actor actor = builder.GetActor("text-actor");
+ *
+ * Stage::GetCurrent().Add(actor);
+ * @endcode
+ *
+ * <h2 class="pg">Hello World - Javascript</h2>
+ *
+ * Hello world can also be executed via Javascript.
+ *
+ * The Dali script application is needed to run the Javascript which provides a Javascript runtime and an interface to Dali.
+ *
+ * @code
+ * daliscript hello-world.js
+ * @endcode
+ *
+ * The TextActor control to display Hello World can be constructed using Javascript dot notation accessing Dali Actor Properties.
+ *
+ * @code
+ * var textActor = Dali.TextActor();
+ *
+ * textActor.text = "Hello World";
+ * textActor.font = "FreeSans";
+ * textActor.font-weight = "WEIGHT_REGULAR";
+ * textActor.parent-origin = "CENTER";
+ *
+ * Dali.Run();
+ * @endcode
+ *
+ */
+
+
--- /dev/null
+/*! \page script-howto Scripting HowTo
+ *
+ * <h2 class="pg">Scripting A Custom Control</h2>
+ *
+ * These steps must be taken to provide scripting access for your control.
+ *
+ * <ul>
+ * <li>Register your class Type.
+ * <li>Register Signals and Actions (optional).
+ * <li>Register properties (optional).
+ * </ul>
+ *
+*
+ * <h3 class="pg">Registering your Type, Signals and Actions</h3>
+ *
+ * As part of your <b>my-actor.cpp</b> a <em>static</em> "Dali::TypeRegistration" object is created to register MyActor for scripting.
+ *
+ * Functions for Creation, Signal Connection and Action are registered with this object.
+ *
+ * @code
+ * namespace // type registration
+ * {
+ *
+ * // Register MyActor with base actor CustomActor and creation function CreateCustom
+ * Dali::TypeRegistration mCustomType( typeid(MyActor), typeid(Dali::CustomActor), MyActor::Create );
+ *
+ * // Add a signal to the type registration
+ * Dali::TypeSignalConnector signal1( mCustomType, "page-changed", MyActor::DoConnectSignalCustom);
+ *
+ * // Add an action to the type registration
+ * Dali::TypeAction action1( mCustomType, "SelectPage", MyActor::DoActionCustom);
+ *
+ * }
+ * @endcode
+ *
+ * The registered handling functions are also static. For example.
+ *
+ * @code
+ * BaseHandle MyActor::Create(void)
+ * {
+ * return MyActor::New();
+ * }
+ *
+ * Dali::Connection MyActor::DoConnectSignalCustom(BaseObject* object, const std::string& signalName, SignalCallback callback)
+ * {
+ * Dali::Connection connection ;
+ *
+ * MyActor* actor = dynamic_cast<MyActor*>(object);
+ *
+ * if(actor && "page-changed" == signalName)
+ * {
+ * connection = return actor->SignalPageChanged().Connect((boost::lambda::bind(callback)));
+ * }
+ *
+ * return connection ;
+ * }
+ *
+ * bool MyActor::DoActionCustom(BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes)
+ * {
+ * bool actioned = false ;
+ *
+ * MyActor* actor = dynamic_cast<MyActor*>(object) ;
+ *
+ * if(actor && "SelectPage" == actionName)
+ * {
+ * actor->DoSelectPage() ;
+ * actioned = true;
+ * }
+ *
+ * return actioned ;
+ * }
+ * @endcode
+ *
+ * <h3 class="pg">Providing Properties for scripting</h3>
+ *
+ * Properties can be registered by name to allow script access.
+ *
+ * A RegisterProperty() call with property attributes allows the custom class to register non animatable properties.
+ *
+ * @code
+ * void MyActor::Initialize()
+ * {
+ * // Register a non animatable and writeable property.
+ * mPropertyAlphaIndex = Self().RegisterProperty("alpha", 0.0f, Dali::Property::WRITEABLE);
+ * }
+ * @endcode
+ *
+ * If a non animatable property is set then the class is notified via the OnPropertySet virtual function.
+ *
+ * @code
+ * void MyActor::OnPropertySet(Property::Index index, Property::Value propertyValue)
+ * {
+ * if(index == mPropertyAlphaIndex)
+ * {
+ * SetAlpha(propertyValue.<float>Get());
+ * }
+ * }
+ *
+ * @endcode
+ *
+ */
--- /dev/null
+/*! \page script-overview Scripting Overview
+ *
+ * Dali has scripting support to
+ *
+ * <ul>
+ * <li>Provide a mechanism to allow custom controls in scripting.
+ * <li>Support layouts using JSON.
+ * <li>Support a dynamic Javascript runtime.
+ * </ul>
+ *
+ * This is accessed via the Dali script external application which wraps Dali with a scripting engine. For example
+ *
+ * @code
+ * daliscript hello-world.js
+ * @endcode
+ *
+ * <h1 class="pg">A Mechanism To Allow Custom Controls in Scripting</h1>
+ *
+ * <h2 class="pg">The TypeRegistry</h2>
+ *
+ * The TypeRegistry allows class 'types' to register themselves as creatable from a scripting environment.
+ *
+ * Custom controls can register a creation function using class run time type information (RTTI).
+ *
+ * The RTTI typeid provides Dali with a unique name to register the type. In this registration the creation function is responsible for creating new instances of the custom class.
+ *
+ * Signals can be added to this type registration with a signal connection function.
+ *
+ * Actions can be similarly added with an action function.
+ *
+ *
+ * <h2 class="pg">Non Animatable Properies</h2>
+ *
+ * The property system has non animatable properties that can be used by the scripting runtime to set actor attributes.
+ *
+ * Custom controls can register properties for scripting access. The custom control is notified of a non animatable property value change.
+ *
+ *
+ * <h2 class="pg">A Javascript example</h2>
+ *
+ * A Javascript runtime wrapping Dali and the V8 Javacript engine is being developed to allow the creation of pure Javascript applications.
+ *
+ * ie 'daliscript helloworld.js'.
+ *
+ * This example shows how a Javacript file relates to the TypeRegistry and Property system.
+ *
+ * @code
+ * // Creation
+ * // This line looks for a type registered as "MyActor" and calls its creation function
+ * var custom = new MyActor();
+ *
+ * // Property access
+ * // This line finds a property called "alpha" and Sets with SetProperty(index, Property::Value(2.0))
+ * // If the property is non animatable it calls OnPropertySet(Property::Value(2.0))
+ * custom.alpha = 2.0;
+ *
+ * // NB: non animatable properties can be strings
+ * custom.text = "a label";
+ *
+ * // Actions
+ * // This line finds the action function registered as "SelectPage" and calls its with a list of arguments
+ * // (NB: arguments are currently limited to non aggregate types ie no list, maps or objects)
+ * custom.SelectPage("one");
+ *
+ * // Signals
+ * // This line finds the signal registered as "touched" and sets the "OnTouch" callback function
+ * custom.signals.touched = OnTouch;
+ *
+ * // OnTouch could have been previously defined as
+ * function OnTouch(name)
+ * {
+ * custom.text = name
+ * }
+ * @endcode
+ *
+ * <h1 class="pg">Supporting Layouts Using JSON</h1>
+ *
+ * The builder in Dali Toolkit provides a means to define layouts using the JSON file format.
+ *
+ * This format defines a text representation for key value pairs and lists of data. Lists and Maps can hold the fundamental Javascript data types of string, number(float/int), true, false, nil.
+ *
+ * *** Current Status
+ *
+ * Currently the builder supports internal Toolkit and Dali controls.
+ *
+ * *** Next Iteration
+ *
+ * The builder will be improved to make use of the TypeRegistry and non animatable properties and allow Custom Controls to be added into Scripting.
+ *
+ * This means the current JSON format will alter slightly (for example; properties will not be defined as a tree but as one level below the actor definition)
+ *
+ * An actor tree defined in JSON will be retrievable as a "Buildable" class instance.
+ *
+ * This buildable class allows the creation of the actor tree. It will also aid resource managment as a buildable can store the layout representation and unload resources when off stage (reconstructing the object when its added back onto the stage).
+ *
+ * <h1 class="pg">Supporting A Javascript Runtime</h1>
+ *
+ * As a separate project an application will be available that can execute Javascript.
+ *
+ * This application will provide a wrapping layer between V8 and Dali and allow a natural interface to the Javascript developer.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
--- /dev/null
+/*! \page scroll-view Example and Usage
+
+ We will start by showing the steps to creating a ScrollView, adding to the stage, and adding content to the ScrollView.
+
+ Then we look at some of the options to achieve commonly desired ScrollView effects, from ruler snap points to domains.
+
+ \section intro Simple ScrollView setup, and ruler configuration.
+
+ We declare a ScrollView component called myScrollView
+
+ @code
+ Dali::Toolkit::ScrollView myScrollView;
+ @endcode
+
+ A new ScrollView instance is then created by calling the following
+ @code
+ myScrollView = ScrollView::New();
+ @endcode
+
+ We then add it to the stage.
+ @code
+ Stage::GetCurrent().Add(myScrollView);
+ @endcode
+
+ Then we specify the size. We'll make it cover the entire stage
+ @code
+ Stage stage = Dali::Stage::GetCurrent();
+ Size size = stage.GetSize();
+ myScrollView.SetSize( size );
+ @endcode
+
+ Add Actors to this ScrollView
+ @code
+ Image image = Image::New(DALI_IMAGE_DIR "button-background.png");
+ ImageActor imageActor = ImageActor::New(image);
+ myScrollView.Add( imageActor );
+ @endcode
+
+ The ScrollView contents are now draggable by the user using touch (panning gestures).
+
+ To enforce horizontal-only scrolling, the Y-axis ruler can be disabled
+ @code
+ RulerPtr rulerY = new DefaultRuler();
+ rulerY->Disable();
+ myScrollView.SetRulerY(rulerY);
+ @endcode
+
+ To enable snapping, a FixedRuler can be applied to the X-axis, with snap points spaced to the width of the stage.
+ @code
+ Stage stage = Dali::Stage::GetCurrent();
+ Size size = stage.GetSize();
+ RulerPtr rulerX = new FixedRuler(size.width);
+ myScrollView.SetRulerX(rulerX);
+ @endcode
+
+ A domain can be applied to rulers to prevent scrolling beyond this boundary. In this case to 4 times the width of the stage, allowing for 4 pages to be scrolled.
+ @code
+ Stage stage = Dali::Stage::GetCurrent();
+ Size size = stage.GetSize();
+ RulerPtr rulerX = new FixedRuler(size.width);
+ rulerX->SetDomain(RulerDomain(0.0f, size.width*4.0f));
+ myScrollView.SetRulerX(rulerX);
+ @endcode
+
+ Ruler Domain Wrap Behaviour
+ ===== ====== ==== =========
+
+ Disabled Disabled No-Wrap "No Movement in axis"
+ Disabled Disabled Wrap "No Movement in axis"
+ Disabled Enabled No-Wrap "No Movement in axis"
+ Disabled Enable Wrap "No Movement in axis"
+ Enabled Disabled No-Wrap "Free Movement in axis"
+ Enabled Disabled Wrap "Free Movement in axis, but will wrap based on domain min-max"
+ Enabled Enabled No-Wrap "Movement limited to domain min-max"
+ Enabled Enabled Wrap "Movement limited to domain min-max"
+
+ @note It is important to note that Actors within ScrollView are controlled by constraints,
+ and thus undefined behaviour will occur when applying constraints to these Actors externally.
+ If you wish to apply additional constraints that may conflict with the ScrollView's constraints,
+ then it is recommended that you place the Actors within container Actors. So that the container
+ Actors are affected by the constraints.
+
+ */
+
--- /dev/null
+/*! \page shader-intro Shader Effects
+ *
+
+<h2 class="pg">Introduction</h2>
+
+The shader effects allow the developer to apply visual deformations on the actors.
+They can affect the geometry, the colors and textures of the actor.
+
+There are some built-in shader effects in Dali Toolkit:
+- \ref Dali::Toolkit::BendyEffect "Bendy", bends the geometry around a point, useful to do a page turn effect,
+- \ref Dali::Toolkit::DissolveEffect "Dissolve", does a dissolve effect on the actor texture,
+- \ref Dali::Toolkit::RippleEffect "Ripple", does a concentric wave effect on the actor texture.
+
+@image html shader-effect-ripple.png "Ripple Effect"
+
+<br>
+<br>
+<h2 class="pg">Example and Usage</h2>
+Here is an example on how to use a shader effect, using the RippleEffect.
+
+First create the shader effect.
+@code
+Dali::RippleEffect effect = Dali::RippleEffect::New();
+@endcode
+
+Then set the values of the uniforms.
+@code
+// Set the radius of the bending
+effect.SetAmplitude( 45.0f );
+// Set the point around which the geometry will bend
+effect.SetCenter( Vector2() );
+// Set the direction of the bending
+effect.SetDirection( Vector2( 1.0f, 0.0f ) );
+@endcode
+
+Finally apply the shader effect to an actor:
+@code
+actor.SetShaderEffect( effect );
+@endcode
+
+
+<br>
+<br>
+<h2 class="pg">Custom Shader Effects</h2>
+The \ref Dali::ShaderEffect "ShaderEffect" lets the developers create their own shader effects by specifying the vertex and pixel shaders.
+
+A custom shader effect can be created like this:
+@code
+String myVertexShader; // This variable would contain the code for a vertex shader.
+Dali::ShaderEffect myEffect = Dali::ShaderEffect::New( myVertexShader,
+ "" // use default pixel shader
+ );
+@endcode
+
+The value of a uniform can be set like this:
+@code
+// if the uniform was declared like this in the shader: uniform float myUniform;
+myEffect.SetUniform( "myUniform", 0.5f );
+@endcode
+
+The custom shader effect can be applied to an actor like any other shader:
+@code
+actor.SetShaderEffect( myEffect );
+@endcode
+
+ *
+ */
--- /dev/null
+/*! \page size-negotiation Size Negotiation
+ *
+<h2 class="pg">Overview</h2>
+
+Size negotiation provides the ability for controls to be resized without the application having to set a size.
+A parent control can resize itself according to its children. Each control can provide hints to using policies for the width and height.
+Controls will be relaid just once and only when requested to, rather than relaid out several times when different properties are set.
+Using size negotiation avoids the need for using size constraints to resize children, which would need to be calculated in the update
+thread every time even minor changes occur.
+
+This topic covers size policies, deriving from ControlImpl, size policy examples and the size negotiation algorithm.
+
+<h2 class="pg">Size Policies</h2>
+
+Each control has a policy for both width and height:
+- <b>Fixed:</b> The size is fixed to the size set by the application. If no size is set, then the size is fixed to the <i>natural</i> size of the control.
+- <b>Mininum:</b> The size can grow and shrink but cannot be smaller than the <i>minimum</i> size specified.
+- <b>Maximum:</b> The size can grow and shrink but cannot be larger than the <i>maximum</i> size specified.
+- <b>Range:</b> The size can grow or shrink but within the <i>minimum</i> and <i>maximum</i> sizes specified.
+- <b>Flexible:</b> The size of the control can grow or shrink as required without any limits.
+
+Currently, by default, controls use a fixed size policy for width and height. If one dimension is set, and the other dimension is set to zero, then the latter
+dimension is assumed to have a non fixed policy.
+
+<h2 class="pg">Deriving from ControlImpl</h2>
+
+The size negotiation utilises several methods to work out the best size of a control. The default behaviour is in the ControlImpl class.
+The following methods can be overridden.
+@code Vector3 GetNaturalSize() @endcode
+This method should return the natural size of the control. This can be dependent on the control's children or the control may decide to have a fixed size.
+
+@code float GetHeightForWidth( float width ) @endcode
+This method should return the height it needs to be when given a certain width.
+
+@code float GetWidthForHeight( float height ) @endcode
+This method should return the width it needs to be when given a certain height.
+
+All these methods can be overridden by deriving classes. This allows each control to dictate what size it would like to be. If you want the default behaviour,
+then you do not have to override these methods. A parent control can call the child's methods to determine its size if it needs to.
+
+<h2 class="pg">Size Policies and Virtual Methods</h2>
+
+The table below shows the methods that are called when certain width and height policies are in place.
+
+<table>
+ <tr>
+ <td></td>
+ <td><b>Fixed Height</b></td>
+ <td><b>Height Not Fixed (All other policies)</b></td>
+ </tr>
+ <tr>
+ <td><b>Fixed Width</b></td>
+ <td>
+ - Use size set by application
+ - If only height set by application
+ - Use height set by application
+ - Use <b>GetWidthForHeight()</b> for width
+ - If only width set by application
+ - Use width set by application
+ - Use <b>GetHeightForWidth()</b> for height
+ - If not set, then get size by calling <b>GetNaturalSize()</b>
+ </td>
+ <td>
+ - Use width set by application
+ - Use allocated width if not set
+ - Ensure it satisfies our width policy
+ - Adjust if required
+ - Use <b>GetHeightForWidth()</b> for height
+ - Ensure height satisfies our height policy
+ - Adjust if required
+ </td>
+ </tr>
+ <tr>
+ <td><b>Width Not Fixed (All other policies)</b></td>
+ <td>
+ - Use height set by application
+ - Use allocated height if not set
+ - Ensure it satisfies our height policy
+ - Adjust if required
+ - Use <b>GetWidthForHeight()</b> for width
+ - Ensure width satisfies our width policy
+ - Adjust if required
+ </td>
+ <td>
+ - Constrain the allocated width and height according to the two policies
+ </td>
+ </tr>
+</table>
+
+<h2 class="pg">Size Policy Examples</h2>
+
+<h3 class="pg">Policy: Fixed Width and Height (1)</h3>
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FixedWidthHeight.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 200 x 300
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> 1 to 1
+- <b>Width Policy:</b> Fixed
+- <b>Height Policy:</b> Fixed
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- None
+
+Result
+- <b>Allocated size:</b> 200 x 300
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Fixed Width and Height (2)</h3>
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FixedWidthHeight2.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 0 x 0 (No size set)
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> 1 to 1
+- <b>Width Policy:</b> Fixed
+- <b>Height Policy:</b> Fixed
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- GetNaturalSize() = 400 x 400
+
+Result
+- <b>Allocated size:</b> 400 x 400
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Flexible Width and Height</h3>
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FlexibleWidthHeight.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 200 x 300
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> 1 to 1
+- <b>Width Policy:</b> Flexible
+- <b>Height Policy:</b> Flexible
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- None
+
+Result
+- <b>Allocated size:</b> 480 x 800 (Assume stage size 480 x 800)
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Fixed Width and Flexible Height (1)</h3>
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FixedWidthFlexibleHeight.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 200 x 300
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> 1 to 1
+- <b>Width Policy:</b> Fixed
+- <b>Height Policy:</b> Flexible
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- GetHeightForWidth( 200 ) = 200
+
+Result
+- <b>Allocated size:</b> 200 x 200
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Fixed Width and Flexible Height (2)</h3>
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FixedWidthFlexibleHeight.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 200 x 0 (No height set)
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> 1 to 1
+- <b>Width Policy:</b> Fixed
+- <b>Height Policy:</b> Flexible
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- GetHeightForWidth( 200 ) = 200
+
+Result
+- <b>Allocated size:</b> 200 x 200
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Fixed Width and Flexible Height (3)</h3>
+
+If the control did not have the GetHeightForWidth() method, then the <i>size set</i> is used to calculate the ratio.
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FixedWidthFlexibleHeight2.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 200 x 0 (No height set)
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> Not set
+- <b>Width Policy:</b> Fixed
+- <b>Height Policy:</b> Flexible
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- GetHeightForWidth( 200 ) = 200 <i>(Unable to calculate ratio using size set)</i>
+
+Result
+- <b>Allocated size:</b> 200 x 800 <i>(Allocate entire height)</i>
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Fixed Width and Flexible Height (4)</h3>
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FlexibleWidthHeight.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 0 x 0 (No size set)
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> 1 to 1
+- <b>Width Policy:</b> Fixed
+- <b>Height Policy:</b> Flexible
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- GetHeightForWidth( 0 ) = 0
+
+Result
+- <b>Allocated size:</b> 480 x 800 <i>(Allocate entire size)</i>
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Flexible Width and Fixed Height (1)</h3>
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FlexibleWidthFixedHeight.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 0 x 300 (No width set)
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> 1 to 1
+- <b>Width Policy:</b> Flexible
+- <b>Height Policy:</b> Fixed
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- GetWidthForHeight( 300 ) = 300
+
+Result
+- <b>Allocated size:</b> 300 x 300
+</td>
+</tr></table>
+
+<h3 class="pg">Policy: Flexible Width and Fixed Height (2)</h3>
+
+If the control did not have the GetWidthForHeight() method, then the <i>size set</i> is used to calculate the ratio.
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html FlexibleWidthFixedHeight2.png
+</td>
+<td>
+The application/control has set the following settings:
+- <b>SetSize:</b> 0 x 300 (No width set)
+- <b>Natural Size:</b> 400 x 400
+- <b>Width To Height Ratio:</b> Not set
+- <b>Width Policy:</b> Flexible
+- <b>Height Policy:</b> Fixed
+- <b>ParentOrigin:</b> TopLeft
+- <b>AnchorPoint:</b> TopLeft
+
+Control methods called:
+- GetWidthForHeight( 300 ) = 0 <i>(Unable to calculate ratio using size set)</i>
+
+Result
+- <b>Allocated size:</b> 480 x 300 <i>(Allocate entire width)</i>
+</td>
+</tr></table>
+
+<h2 class="pg">The Size Negotiation Algorithm</h2>
+
+<h3 class="pg">The Algorithm</h3>
+
+-# The algorithm starts at the stage
+ - All top level controls are found and offered the size of the stage
+ - The control negotiates the size offered by using the policy rules to determine the size that it should be allocated
+ - The control is then set to that allocated size
+-# The control is responsible for setting the sizes of all its children
+ - Can set a size on an Actor
+ - Or can call relayout on a Control directly
+-# Children that a control does not handle, the control can add to a container so that the top-level algorithm delas with it instead
+ - The control should call Relayout with the child and size of itself as parameters
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html Algorithm1.png
+</td>
+<td>
+\image html Algorithm2.png
+</td>
+</tr></table>
+
+<h3 class="pg">A closer look at Control A</h3>
+
+Taking a closer look at Control A we see in this example that children should share the width equally and that the height of Control A
+is the maximum height of the children.
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html Algorithm3.png
+</td>
+<td>
+<table border=0 cellpadding=10><tr>
+<td>
+\image html Algorithm4.png
+</td>
+</tr></table>
+</td>
+</tr></table>
+
+@code
+class ControlA : public Control
+{
+ ...
+private:
+ // Data
+ Actor mActorC; // Container to store children
+ TextView mControlD; // Some text we want to display
+ ImageActor mActorD; // An image
+};
+@endcode
+
+@code
+Vector3 ControlA::GetNaturalSize()
+{
+ // Width is total of ControlD and ActorD
+ // Height is max of ControlD and ActorD
+ // Don't care about the Depth
+ Vector3 naturalSize; // Initialised to (0.0f, 0.0f, 0.0f)
+
+ if ( mControlD )
+ {
+ // We know ControlD is a control, so just ask its natural size
+ naturalSize = mControlD.GetNaturalSize();
+ }
+
+ if ( mActorD )
+ {
+ // We know ActorD is an ImageActor, we can get the image's natural size
+ Image image = mActorD.GetImage();
+ naturalSize.width += image.GetWidth;
+ naturalSize.height = std::max( naturalSize.height, image.GetHeight() );
+ }
+
+ return naturalSize;
+}
+@endcode
+
+GetHeightForWidth() and GetWidthForHeight() can be created in a similar manner.
+
+@code
+void ControlA::OnRelaidOut( Vector2 size, ActorSizeContainer& container )
+{
+ // Width to be shared between ControlD and ActorD
+ Vector2 childSize( size.width * 0.5f, size.height );
+
+ if ( mActorC )
+ {
+ // ActorC is the same size as ControlA
+ mActorC.SetSize( size );
+ }
+
+ if ( mControlD )
+ {
+ Relayout( mControlD, childSize );
+ // Can add more complex calculations to preserve aspect ratio etc.
+ }
+
+ if ( mActorD )
+ {
+ mActorD.SetSize( childSize );
+ // Can add more complex calculations to preserve aspect ratio etc.
+ }
+}
+@endcode
+
+The allocated layout is as follows.
+<table border=0 cellpadding=10><tr>
+<td>
+\image html Algorithm8.png
+</td>
+</tr></table>
+
+<h3 class="pg">A closer look at Control B</h3>
+
+In this example we have the following requirements:
+- Control B creates a small border around its children
+- Control B just allocates whatever its given to its children (minus the border)
+- Actor E is a simple container actor and contains one control (Control E)
+- Control B is not aware of the actors it contains
+
+<table border=0 cellpadding=10><tr>
+<td>
+\image html Algorithm9.png
+</td>
+<td>
+\image html Algorithm10.png
+</td>
+</tr></table>
+
+@code
+void ControlA::OnRelaidOut( Vector2 size, ActorSizeContainer& container )
+{
+ // Width of children is our size minus border
+ Vector3 childSize( size.width - mBorder.width * 2.0f,
+ size.height - mBorder.height * 2.0f );
+
+ // Our children should be set to the childSize
+ ActorContainer children( Self().GetChildren() );
+ for ( ActorIter iter = children.begin(), endIter = children.end();
+ iter != endIter;
+ ++iter )
+ {
+ Relayout( *iter, childSize, container );
+ }
+}
+@endcode
+
+The Relayout method will add ControlB's children to the size negotiation algorithm container where the child's size will be negotiated. Control E's
+size will be negotiated with the childSize as the allocation.
+
+*
+*/
--- /dev/null
+/*! \page text-input Text Input
+ *
+ TextInput is a Dali::Actor which allows the input of text from an on-screen virtual keyboard or attached hardware keyboard.
+
+
+<h2 class="pg">Basic Text Input Set-up</h2>
+
+ The below code creates a new TextInput
+
+ @code
+ Dali::Toolkit::TextInput myTextInput;
+ myTextInput = Dali::Toolkit::TextInput::New();
+ @endcode
+
+ The following code sets the size and adds it to the stage
+ @code
+ myTextInput.SetParentOrigin(ParentOrigin::CENTER);
+ myTextInput.SetSize(stageWidth*0.25f, stageWidth*0.5f);
+ Stage::GetCurrent().Add(myTextInput);
+ @endcode
+
+ For a TextInput to receive input from the keyboard it must be in edit mode.
+
+ To enter edit mode the below call can be made. If the virtual on-screen keyboard is supported then it will be displayed.
+ Internally TextInput will set focus to this TextInput and key events will be sent to it.
+
+ @code myTextInput.SetEditable(true);@endcode
+
+ After this call the TextInput will receive any key press. If you have more than one TextInput the focus will change between them when the edit mode is
+ initiated on any Text Input.
+
+ To automatically start edit mode when the TextInput is "tapped" you can call the following:
+
+ @code myTextInput.SetEditOnTouch()@endcode
+
+ You will then need to end edit mode by making the call below or swiping away the keyboard (Virtual On-screen Keyboard)
+ @code myTextInput.SetEditable(false);@endcode
+
+ The call will hide the virtual keyboard if previously shown by Text Input.
+
+ Then the input string as plain text can be retrieved using
+ @code Dali::Toolkit::TextInput::GetText()@endcode
+
+<h2 class="pg"> Text Selection </h2>
+
+ The SetTextSelectable API when set to true enables text to be highlighted, once highlighted the text style can be changed,
+ the text can be cut, or copied, overwritten with new text or deleted.
+
+ The user does a Long-Press on the text to get the option of text selection.
+
+ @code Dali::Toolkit::TextInput::SetTextSelectable( true ) @endcode
+
+<h2 class="pg"> Text Styling </h2>
+
+ In conjunction with TextView and the Markup processor, TextInput enables text to be styled.
+
+ There are 3 ways to effect the text styling.
+
+ SetActiveStyle, new input text is set to the Red glow style
+ @code
+ TextStyle style;
+ style.SetGlow ( true, Dali::Color::RED );
+ myTextInput.SetActiveStyle( style, MarkupProcessor::GLOW );
+ @endcode
+
+ ApplyStyle, selected/highlighted text now has the Red glow style
+ @code
+ TextStyle style;
+ style.SetGlow ( true, Dali::Color::RED );
+ myTextInput.ApplyStyle( style, MarkupProcessor::GLOW );
+ @endcode
+
+ ApplyStyleToAll, all text now has the Red glow style
+ @code
+ TextStyle style;
+ style.SetGlow ( true, Dali::Color::RED );
+ myTextInput.ApplyStyleToAll( style, MarkupProcessor::GLOW );
+ @endcode
+
+ Then the input string with Mark-up defining the style can be retrieved using
+ @code Dali::Toolkit::TextInput::GetMarkupText()@endcode
+ This would be usefull if you wish to save the styled text the user has input so it can be re-displayed another time.
+
+ Signals are emitted when style changes.
+
+ See Dali::Toolkit::TextInput::StyleMask for available styling options.
+
+
+
+
+ */
+
--- /dev/null
+/*! \page text-view Text View
+ *
+ * \section overview Overview
+ *
+ * The Dali::Toolkit::TextView class is a UI Dali::Toolkit::Control designed to extend the capabilities of the basic Dali::TextActor.
+ * It provides support for multi-line wrapping, multi-language font detection, text alignment, scrolling and styling.
+ *
+ * Dali::Toolkit::TextView also provides text layout information which could be used in other UI Dali::Toolkit::Control classes or other applications.
+ *
+ * \section multiline Multi-line wrapping
+ *
+ * Different multi-line and exceed policies could be set to layout the given text.
+ *
+ * Both multi-line and exceed policies work together.
+ * Dali::Toolkit::TextView::MultilinePolicy policies define how to wrap a line if it doesn't fit inside the boundary's width
+ * whereas Dali::Toolkit::TextView::ExceedPolicy policies define what to do if the wrapped text is bigger than the text view's boundary.
+ *
+ * i.e. \e SplitByWord could be used as 'multi-line policy' to wrap a line if it's too long. If one of the words is longer than the text-view's width, \e Split could be
+ * used as 'width exceed policy' to split a word in different lines. If the text is too long and exceeds the text-view's height, \e EllipsizedEnd could be
+ * used as 'height exceed policy' to render only the text which fits inside the boundaries of the text-view.
+ *
+ * @see more \ref examples.
+ *
+ * \subsection multiline_policies Multi-line policies
+ *
+ * <ul>
+ * <li><em>Split by new line character</em>.
+ * Text will be wrapped when an <em>end of line \\n</em> or <em>\<br /\></em> is found.
+ *
+ * <li><em>Split by word</em>.
+ * Text will be wrapped when an <em>end of line \\n</em> or <em>\<br /\></em> is found or if the text doesn't fit in the text view width.
+ * In that case, some words will be moved to a new line.
+ *
+ * <li><em>Split by character</em>.
+ * Text will be wrapped when an <em>end of line \\n</em> or <em>\<br /\></em> is found or if the text doesn't fit in the text view width.
+ * In that case, words which don't fit will be wrapped in two and the remaining text moved to a new line.
+ * </ul>
+ * Dali::Toolkit::TextView::SplitByNewLineChar is set by default.
+ *
+ * \subsection exceed_policies Exceed policies
+ *
+ * <ul>
+ * <li><em>Original size</em>.
+ * Text will be displayed with its original size.
+ *
+ * <li><em>Fade</em>.
+ * Text will be faded out.
+ *
+ * <li><em>Split</em>.
+ * Text will be wrapped and moved to a new line.
+ *
+ * <li><em>Shrink to fit</em>.
+ * Text will be shrunk to fit in the text view's boundary.
+ *
+ * <li><em>Ellipsize at the end</em>.
+ * Text will be truncated to fit in the text view's boundary and the ellipsize text will be added. ( '...' by default).
+ * </ul>
+ * Dali::Toolkit::TextView::Original is set by default.
+ *
+ * @see Dali::Toolkit::TextView::SetMultilinePolicy
+ * @see Dali::Toolkit::TextView::SetWidthExceedPolicy
+ * @see Dali::Toolkit::TextView::SetHeightExceedPolicy
+ * @see Dali::Toolkit::TextView::SetFadeBoundary
+ * @see Dali::Toolkit::TextView::SetEllipsizeText
+ *
+ * @note Multiple combinations are possible but not all of them are already implemented.
+ * @see \ref exceed_policies_combinations table to check which combinations are implemented
+ *
+ * \section scroll Scroll
+ *
+ * Text could be scrolled if it exceeds the boundaries of the text-view.
+ *
+ * @see Dali::Toolkit::TextView::SetScrollEnabled
+ * @see Dali::Toolkit::TextView::SetScrollPosition
+ *
+ * \section line_height_spacing Line height spacing
+ *
+ * The default space between lines could be modified by setting an offset with Dali::Toolkit::TextView::SetLineHeightOffset().
+ *
+ * <h1 class="pg">Font support and multi-language detection</h1>
+ *
+ * Dali::Toolit::TextView uses the font specified in the styled text array to display the given text.
+ *
+ * See \link markup-processor Markup Processor \endlink for more details on how to create styling markup strings and styled text arrays.
+ *
+ * To support multi-language texts, text-view does the following actions per character:
+ * <ul>
+ * <li> Check if there is a font defined in the styled text array.
+ * <li> If there isn't, try to use the default platform font.
+ * <li> Check if the character is supported by the font.
+ * <li> If isn't, find the most suitable font for the character.
+ * </ul>
+ *
+ * \section text_alignment Text alignment and justification
+ *
+ * Dali::Toolkit::TextView provides a method to align the whole text inside the text view's boundary as well as a method to justify each line
+ * inside the text.
+ *
+ * The Dali::Toolkit::Alignment::Type is used to align the whole text in the text view's area.
+ * A text could be horizontally aligned (left, center, right) and/or vertically aligned (top, center, bottom).
+ * Dali::Toolkit::Alignment::HorizontalCenter | Dali::Toolkit::Alignment::VerticalCenter is set by default.
+ *
+ * The Dali::Toolkit::TextView::LineJustification is used to justify each line inside the text (left, center, right, justified).
+ * Dali::Toolkit::TextView::Left is set by default.
+ *
+ * @see Dali::Toolkit::TextView::SetTextAlignment @see Dali::Toolkit::TextView::SetLineJustification
+ *
+ * \section text_styling Text styling
+ *
+ * Dali::Toolkit::TextView supports all text styling features provided by Dali::TextActor (font type, color, size, outline, etc).
+ *
+ * Different techniques are provided to set or modify the text view's style:
+ *
+ * <ul>
+ * <li> By setting a Dali::Toolkit::MarkupProcessor::StyledTextArray with the Dali::Toolkit::TextView::SetText(const MarkupProcessor::StyledTextArray& text) method.
+ * <li> By setting a new Dali::TextStyle to the current text with the Dali::Toolkit::TextView::SetStyleToCurrentText() method.
+ * <li> By setting an html-ish markup string which contains both text and style with the Dali::Toolkit::TextView::SetText(const std::string& text) method.
+ @note By default the style markup processor is disabled. @see Dali::Toolkit::TextView::SetMarkupProcessingEnabled to enable the markup processing.
+ * </ul>
+ *
+ * See \link markup-processor Markup Processor \endlink for more details on how to create styling markup strings and styled text arrays.
+ *
+ * \section retrieve Retrieve text layout information
+ *
+ * The Dali::Toolkit::TextView::GetTextLayoutInfo() retrieves how the input text has been laid out.
+ *
+ * For each character it retrieves its size and position, visibility, etc. @see Dali::Toolkit::TextView::CharacterLayoutInfo.
+ *
+ * For each laid-out line it retrieves the index of the first character of the line, size, etc. @see Dali::Toolkit::TextView::LineLayoutInfo.
+ *
+ * \section appendix Appendix
+ * \subsection examples Examples
+ *
+ * The following examples show how to use TextView. The grey square is an actor which has been added just to show the size of the text-view.
+ *
+ * Creation of a text view actor with all its parameters by default.
+ * \code
+ * Toolkit::TextView textView = Toolkit::TextView::New( "Hello world!" );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ *
+ * This example wraps the text in lines only when a \\n character is found. The size of the text-view will be automatically resized to fit the whole text inside.
+ * \code
+ * const std::string text( "<font color='black'>"
+ * "Lorem ipsum dolor sit amet, consectetur adipisicing elit,\n"
+ * "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
+ * "</font>" );
+ *
+ * Toolkit::TextView textView = Toolkit::TextView::New( "" );
+ * textView.SetMarkupProcessingEnabled( true );
+ * textView.SetText( text );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ *
+ * textView.SetMultilinePolicy( Toolkit::TextView::SplitByNewLineChar );
+ * textView.SetWidthExceedPolicy( Toolkit::TextView::Original );
+ * textView.SetHeightExceedPolicy( Toolkit::TextView::Original );
+ * textView.SetLineJustification( Toolkit::TextView::Center );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ * \image html text-view/text-view-example-01.png
+ *
+ * This example wraps the lines by the next word when it exceeds the width of the text-view. The height exceed policy is set to \e Original so it may exceed the height of the text-view.
+ *
+ * \code
+ * const std::string text( "<font color='black'>"
+ * "Lorem ipsum dolor sit amet, consectetur adipisicing elit, "
+ * "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
+ * "</font>" );
+ *
+ * Toolkit::TextView textView = Toolkit::TextView::New( "" );
+ * textView.SetMarkupProcessingEnabled( true );
+ * textView.SetText( text );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ * textView.SetSize( 300.f, 125.f );
+ *
+ * textView.SetMultilinePolicy( Toolkit::TextView::SplitByWord );
+ * textView.SetWidthExceedPolicy( Toolkit::TextView::Original );
+ * textView.SetHeightExceedPolicy( Toolkit::TextView::Original );
+ * textView.SetLineJustification( Toolkit::TextView::Center );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ * \image html text-view/text-view-example-02.png
+ *
+ * This example wraps the lines by the next word when it exceeds the width of the text-view. If a word is bigger than the text-view's width, it splits the word. If the text exceeds the height of the text-view, the text is ellipsized.
+ *
+ * \code
+ * const std::string text( "<font color='black'>"
+ * "Loremipsumdolorsitametconsectetur adipisicing elit,\n"
+ * "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
+ * "</font>" );
+ * const std::string ellipsizeText( "<font color='black'>...</font>" );
+ *
+ * Toolkit::TextView textView = Toolkit::TextView::New( "" );
+ * textView.SetMarkupProcessingEnabled( true );
+ * textView.SetText( text );
+ * textView.SetEllipsizeText( ellipsizeText );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ * textView.SetSize( 300.f, 125.f );
+ *
+ * textView.SetMultilinePolicy( Toolkit::TextView::SplitByWord );
+ * textView.SetWidthExceedPolicy( Toolkit::TextView::Split );
+ * textView.SetHeightExceedPolicy( Toolkit::TextView::EllipsizeEnd );
+ * textView.SetLineJustification( Toolkit::TextView::Center );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ * \image html text-view/text-view-example-03.png
+ *
+ * This example is similar to the one above but the ellipsized text has been set to "" so nothing is shown.
+ *
+ * \code
+ * const std::string text( "<font color='black'>"
+ * "Loremipsumdolorsitametconsecteturadipisicingelit"
+ * "seddoeiusmodtemporincididuntutlaboreetdoloremagnaaliqua."
+ * "</font>" );
+ * const std::string ellipsizeText( "" );
+ *
+ * Toolkit::TextView textView = Toolkit::TextView::New( "" );
+ * textView.SetMarkupProcessingEnabled( true );
+ * textView.SetText( text );
+ * textView.SetEllipsizeText( ellipsizeText );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ * textView.SetSize( 300.f, 125.f );
+ *
+ * textView.SetMultilinePolicy( Toolkit::TextView::SplitByWord );
+ * textView.SetWidthExceedPolicy( Toolkit::TextView::Split );
+ * textView.SetHeightExceedPolicy( Toolkit::TextView::EllipsizeEnd );
+ * textView.SetLineJustification( Toolkit::TextView::Center );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ * \image html text-view/text-view-example-04.png
+ *
+ * This example shows how to fade the text out when it exceeds the boundaries of the text-view.
+ *
+ * \code
+ * const std::string text( "<font color='black'>"
+ * "Lorem ipsum dolor sit amet,\n"
+ * "consectetur adipisicing elit,\n"
+ * "sed do eiusmod tempor incididunt\n"
+ * "ut labore et dolore magna aliqua."
+ * "</font>" );
+ *
+ * Toolkit::TextView textView = Toolkit::TextView::New();
+ * textView.SetMarkupProcessingEnabled( true );
+ * textView.SetText( text );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ * textView.SetSize( 300.f, 100.f );
+ *
+ * Toolkit::TextView::FadeBoundary fadeBoundary( PixelSize( 10 ), PixelSize( 10 ), PixelSize( 10 ), PixelSize( 10 ) );
+ * textView.SetFadeBoundary( fadeBoundary );
+ *
+ * textView.SetMultilinePolicy( Toolkit::TextView::SplitByNewLineChar );
+ * textView.SetWidthExceedPolicy( Toolkit::TextView::Fade );
+ * textView.SetHeightExceedPolicy( Toolkit::TextView::Fade );
+ * textView.SetLineJustification( Toolkit::TextView::Center );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ * \image html text-view/text-view-example-05.png
+ *
+ * This example enables the scroll feature. The screen-shots show three different images of the same text in different scroll positions.
+ *
+ * \code
+ * const std::string text( "<font color='black'>"
+ * "Lorem ipsum dolor sit amet, consectetur adipisicing elit,\n"
+ * "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
+ * "</font>" );
+ *
+ * Toolkit::TextView textView = Toolkit::TextView::New();
+ * textView.SetMarkupProcessingEnabled( true );
+ * textView.SetText( text );
+ * textView.SetParentOrigin( ParentOrigin::CENTER );
+ * textView.SetSize( 300.f, 60.f );
+ *
+ * textView.SetMultilinePolicy( Toolkit::TextView::SplitByNewLineChar );
+ * textView.SetWidthExceedPolicy( Toolkit::TextView::Original );
+ * textView.SetHeightExceedPolicy( Toolkit::TextView::Original );
+ * textView.SetLineJustification( Toolkit::TextView::Center );
+ *
+ * textView.SetScrollEnabled( true );
+ *
+ * Stage::GetCurrent().Add( textView );
+ * \endcode
+ * \image html text-view/text-view-example-06.png
+ * \image html text-view/text-view-example-07.png
+ * \image html text-view/text-view-example-08.png
+ *
+ * See \link markup-processor Markup Processor \endlink \ref example for more styling markup string examples.
+ *
+ * \subsection exceed_policies_combinations Implemented exceed policies combinations
+ *
+ * The following tables show which exceed policies are implemented for each multi-line policy. Each column has one width exceed policy (Original, Fade, Split, ShrinkToFit and EllipsizeEnd),
+ * each row has one height exceed policy (Original, Fade, ShrinkToFit and EllipsizeEnd).
+ *
+ * @note The Split value is not valid for the height exceed policy.
+ *
+ * \htmlonly
+ * <table border="1" align="center">
+ * <tr align="center">
+ * <th align="center" colspan="7">SplitByNewLineChar</th>
+ * </tr>
+ * <tr align="center">
+ * <th colspan="2" rowspan="2"></th><th align="center" colspan="6">Width exceed policies</th>
+ * </tr>
+ * <tr>
+ * <th>Original</th><th>Fade</th><th>Split</th><th>ShrinkToFit</th><th>EllipsizeEnd</th>
+ * </tr>
+ * <tr align="center">
+ * <th rowspan="4">Height<br />exceed<br />policies</th>
+ * <th>Original</th>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>Fade</th>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>ShrinkToFit</th>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>EllipsizeEnd</th>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * </tr>
+ * </table>
+ * \endhtmlonly
+ *
+ * \n
+ *
+ * \htmlonly
+ * <table border="1" align="center">
+ * <tr align="center">
+ * <th align="center" colspan="7">SplitByWord</th>
+ * </tr>
+ * <tr align="center">
+ * <th colspan="2" rowspan="2"></th><th align="center" colspan="6">Width exceed policies</th>
+ * </tr>
+ * <tr>
+ * <th>Original</th><th>Fade</th><th>Split</th><th>ShrinkToFit</th><th>EllipsizeEnd</th>
+ * </tr>
+ * <tr align="center">
+ * <th rowspan="4">Height<br />exceed<br />policies</th>
+ * <th>Original</th>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>Fade</th>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>ShrinkToFit</th>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>EllipsizeEnd</th>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * </tr>
+ * </table>
+ * \endhtmlonly
+ *
+ * \n
+ *
+ * \htmlonly
+ * <table border="1" align="center">
+ * <tr align="center">
+ * <th align="center" colspan="7">SplitByChar</th>
+ * </tr>
+ * <tr align="center">
+ * <th colspan="2" rowspan="2"></th><th align="center" colspan="6">Width exceed policies</th>
+ * </tr>
+ * <tr>
+ * <th>Original</th><th>Fade</th><th>Split</th><th>ShrinkToFit</th><th>EllipsizeEnd</th>
+ * </tr>
+ * <tr align="center">
+ * <th rowspan="4">Height<br />exceed<br />policies</th>
+ * <th>Original</th>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>Fade</th>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#0A0>✓</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>ShrinkToFit</th>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * <tr align="center">
+ * <th>EllipsizeEnd</th>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * <td><font color=#A00>✗</font></td>
+ * </tr>
+ * </table>
+ * \endhtmlonly
+ */
+
--- /dev/null
+/*! \page type-registration Type Registration
+ *
+@section Overview
+
+DALi has a \link Dali::TypeRegistry type registration \endlink system which can be used to register
+a derived actor/control type along with specifying a method which is used to create this type. This
+type registration normally takes place at library load time.
+
+Once a type is registered, signals, actions and properties can also be registered for all instances
+of this type.
+
+This then allows the application writer to create instances using just the type name; connect to
+signals using only the signal name; activate an action by just using the action name; and finally,
+getting and setting properties using a property name or index.
+
+This topic covers:
+
+ - @ref register-type
+ - @ref register-signal
+ - @ref register-action
+ - @ref register-property
+ - @ref using-type
+ - @ref using-signal
+ - @ref using-action
+ - @ref using-property
+
+@section register-type Registering a Type
+
+A type can be registered using Dali::TypeRegistration. This is normally done in an unnamed namespace
+within the source file of the deriving control as shown in the code below.
+
+<b>Please note:</b> This snippet assumes knowledge of the \link Dali::Toolkit::Control Control
+\endlink / \link Dali::Toolkit::ControlImpl ControlImpl \endlink creation process where
+<i><b>MyControl</b></i> derives from a Control and <i><b>MyControlImpl</b></i> derives from ControlImpl.
+
+@code
+namespace
+{
+
+Dali::BaseHandle Create()
+{
+ // Create an instance of MyControl and return the handle.
+ return MyControlImpl::New();
+}
+
+Dali::TypeRegistration type(
+ typeid( MyControl ), // Type ID of our Control
+ typeid( Dali::Toolkit::Control ), // Type ID of what our Control derives from
+ Create // Function which creates our Control, signature shown above
+);
+
+} // unnamed namespace
+@endcode
+
+This registration informs DALi of the existence of MyControl type.
+
+@section register-signal Registering a Signal
+
+Once we've registered a type, we can then inform the type-registry about any signals that our type has:
+
+@code
+// Define the names of the signals
+static const char * const SIGNAL_ONE( "signal1" );
+static const char * const SIGNAL_TWO( "signal2" );
+static const char * const SIGNAL_THREE( "signal3" );
+
+Dali::SignalConnectorType signal1(
+ type, // Reference to type registration object (see above)
+ SIGNAL_ONE, // Name of our signal
+ &MyControl::DoConnectSignal // Function to call when a call to connect to this signal is received
+);
+
+// Register more signals
+Dali::SignalConnectorType signal2( type, SIGNAL_TWO, &MyControl::DoConnectSignal );
+Dali::SignalConnectorType signal3( type, SIGNAL_THREE, &MyControl::DoConnectSignal );
+@endcode
+
+It is recommended to use static members (of MyControl class) for the signal names. That way
+applications can also use the static member rather than have to look up the name.
+
+The method that handles the signal connection has to be static and takes the form:
+
+@code
+bool MyControl::DoConnectSignal(
+ Dali::BaseObject* object, // A pointer to an instance of MyControl
+ Dali::ConnectionTrackerInterface* tracker, // The object connecting to the signal
+ const std::string& signalName, // The name of the signal to connect to
+ Dali::FunctorDelegate* functor // The functor
+)
+{
+ bool connected( false );
+
+ // DownCast to MyControl so that we can call the signal connection methods
+ MyControl control = MyControl::DownCast( Dali::BaseHandle ( object ) );
+
+ if ( control )
+ {
+ if ( signalName == SIGNAL_ONE )
+ {
+ control.SignalOne().Connect( tracker, functor );
+ connected = true;
+ }
+ else if ( signalName == SIGNAL_TWO )
+ {
+ control.SignalTwo().Connect( tracker, functor );
+ connected = true;
+ }
+ else if ( signalName == SIGNAL_THREE )
+ {
+ control.SignalThree().Connect( tracker, functor );
+ connected = true;
+ }
+ }
+
+ return connected; // Return true if connection successfully created
+}
+@endcode
+
+@section register-action Registering an Action
+
+Created controls are able to perform a variety of default actions. Registering an action with the
+type registry allows application writers to perform this action by using the name.
+
+An action can be added to a type as shown below:
+
+@code
+// Define the names of the actions
+static const char * const ACTION_ONE( "action1" );
+static const char * const ACTION_TWO( "action2" );
+static const char * const ACTION_THREE( "action3" );
+
+Dali::TypeAction action1(
+ type, // Reference to type registration object (see above)
+ ACTION_ONE, // Name of the action
+ &MyControl::DoAction // Function to call when someone wants to perform this action
+);
+
+// Register mode actions
+Dali::TypeAction action2( type, ACTION_TWO, &MyControl::DoAction );
+Dali::TypeAction action3( type, ACTION_THREE, &MyControl::DoAction );
+@endcode
+
+It is recommended to use static members (of MyControl class) for the action names. That way
+applications can also use the static member rather than have to look up the name.
+
+The method that handles the action has to be static and takes the form:
+
+@code
+bool MyControl::DoAction(
+ Dali::BaseObject* object, // A pointer to an instance of MyControl
+ const std::string& actionName, // The name of the action to perform
+ const std::vector< Dali::Property::Value >& attributes // Any passed in attributes
+)
+{
+ bool performed( false );
+
+ Dali::BaseHandle handle(object);
+
+ // DownCast to MyControl so that we can do the specific behaviour
+ MyControl control = MyControl::DownCast( Dali::BaseHandle ( object ) );
+
+ if ( control )
+ {
+ if ( actionName == ACTION_ONE )
+ {
+ // Do action1 e.g. button click etc.
+ }
+ else if ( actionName == ACTION_TWO )
+ {
+ // Do action2, which can have attributes
+ if ( !attributes.empty() )
+ {
+ // Let's assume action2 expects a std::string as an attribute, here's how we'd extract that
+ std::cout << "action2 printing out: " << attributes[0].Get< std::string >() ) << std::endl;
+ }
+ }
+ else if ( actionName == ACTION_THREE )
+ {
+ // Do action3
+ }
+ }
+
+ return performed; // Return true if action successfully performed
+}
+@endcode
+
+@section register-property Registering a Property
+
+DALi has a property system which can be extended by registering more properties through the type
+registry. The property index is <b><i>very important</i></b> when registering these properties and
+all property indices should be between Dali::PROPERTY_REGISTRATION_START_INDEX and
+Dali::PROPERTY_REGISTRATION_MAX_INDEX.
+
+Furthermore, if deriving from \link Dali::Toolkit::Control Control\endlink, the control writer
+needs to be aware of their parent class's property range. Control reserves a property range between
+\link Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_START_INDEX ControlImpl::CONTROL_PROPERTY_START_INDEX\endlink
+and \link Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_END_INDEX ControlImpl::CONTROL_PROPERTY_END_INDEX\endlink.
+Any deriving control should start their property indices from
+\link Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_END_INDEX ControlImpl::CONTROL_PROPERTY_END_INDEX\endlink + 1.
+
+Please have a look at \ref property-indices for more information.
+
+The following code shows how a property can be added to a type.
+
+@code
+// Define the indices we will use for the properties
+static const int PROPERTY_ONE( Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_END_INDEX + 1 );
+static const int PROPERTY_TWO( Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_END_INDEX + 2 );
+static const int PROPERTY_THREE( Dali::Toolkit::ControlImpl::CONTROL_PROPERTY_END_INDEX + 3 );
+
+Dali::PropertyRegistration property1(
+ type, // Reference to type registration object (see above)
+ "property1", // Name of the property
+ PROPERTY_ONE, // Index of this property
+ Dali::Property::BOOLEAN, // The property type
+ &MyControl::SetProperty, // Method called when property is set
+ &MyControl::GetProperty // Method called when retrieving the value of the property
+);
+
+// Register more properties
+Dali::PropertyRegistration property2(
+ type, "property2", PROPERTY_TWO, Dali::Property::FLOAT,
+ NULL, // SetProperty is NULL, means that this property is a read-only property
+ &MyControl::GetProperty
+);
+Dali::PropertyRegistration property3( type, "property3", PROPERTY_THREE, Dali::Property::FLOAT, &MyControl::SetProperty, &MyControl::GetProperty);
+@endcode
+
+It is recommended to use static members (of MyControl class) for the property indices. That way
+applications can also use the static member as well. If they require the property name, they can
+just call the Dali::Handle::GetPropertyName().
+
+The method that deals with setting the property has to be static, and follows the format:
+
+@code
+void MyControl::SetProperty(
+ Dali::BaseObject* object, // A pointer to an instance of MyControl
+ Dali::Property::Index index, // The index of the property to set
+ const Dali::Property::Value& value // The value to set the property to
+)
+{
+ // DownCast to MyControl so that we can do the specific behaviour
+ MyControl control = MyControl::DownCast( Dali::BaseHandle ( object ) );
+
+ if ( control )
+ {
+ MyControlImpl& controlImpl( GetImplementation( control ) );
+
+ switch ( index )
+ {
+ case PROPERTY_ONE:
+ {
+ // Assume we already have a method in MyControl which sets the appropriate value and takes in a boolean
+ controlImpl.SetPropertyOne( value.Get< bool >() );
+ break;
+ }
+
+ // PROPERTY_TWO is read-only so does not need to be handled
+
+ case PROPERTY_THREE
+ {
+ // Assume we already have a method in MyControl which sets the appropriate value and takes in a float
+ controlImpl.SetPropertyThree( value.Get< float >() );
+ break;
+ }
+ }
+ }
+}
+@endcode
+
+And the function to retrieve the property value also has to be static and takes the form:
+
+@code
+Property::Value MyControl::GetProperty(
+ BaseObject* object, // A pointer to an instance of MyControl
+ Property::Index index // The index of the property to retrieve
+)
+{
+ Property::Value value;
+
+ // DownCast to MyControl so that we can do the specific behaviour
+ MyControl control = MyControl::DownCast( Dali::BaseHandle ( object ) );
+
+ if ( control )
+ {
+ MyControlImpl& controlImpl( GetImplementation( control ) );
+
+ switch ( index )
+ {
+ case PROPERTY_ONE:
+ {
+ // Assume we have a member variable that stores the value of this property
+ value = controlImpl.mPropertyOne;
+ break;
+ }
+
+ case PROPERTY_TWO:
+ {
+ // Assume we have a member variable that stores the value of this property
+ value = controlImpl.mPropertyTwo;
+ break;
+ }
+
+ case PROPERTY_THREE:
+ {
+ // Assume we have a member variable that stores the value of this property
+ value = controlImpl.mPropertyThree;
+ break;
+ }
+ }
+ }
+}
+@endcode
+
+@section using-type Creating an instance of a Registered Type
+
+When a type is registered with the \link Dali::TypeRegistry type registry\endlink, it allows the
+application writer to get information about the type and even create an instance of it.
+
+@code
+Dali::TypeInfo type = Dali::TypeRegistry::Get().GetTypeInfo( "MyControl" );
+
+// If type specified is not found, then type will be NULL.
+if ( type )
+{
+ Dali::BaseHandle handle = type.CreateInstance();
+
+ // Can use DownCast to change to MyControl type if required
+ if ( handle )
+ {
+ MyControl control = MyControl::DownCast( handle );
+ }
+}
+@endcode
+
+Normally we would not do the DownCast, just utilise the signals, actions and properties.
+
+@section using-signal Connecting to a Registered Signal
+
+The advantage of registering a signal using the \link Dali::TypeRegistry type registry \endlink is
+that you can connect to a particular signal using just the name of the signal.
+
+The application code would look as follows:
+
+@code
+class MyApp
+{
+public:
+
+ // Assume this is called when creating MyApp
+ void Create()
+ {
+ Dali::TypeInfo type = Dali::TypeRegistry::Get().GetTypeInfo( "MyControl" );
+
+ if ( type )
+ {
+ mHandle = type.CreateInstance();
+
+ if ( mHandle )
+ {
+ // Connect to signal1 by using its name
+ handle.ConnectSignal( &mConnectionTracker, "signal1", &MyApp::SignalReceived ) )
+ }
+ }
+ }
+
+ // This method will be called when "signal1" is emitted
+ void SignalReceived()
+ {
+ // Do Something when "signal1" is received
+ std::cout << "signal1 received" << std::endl;
+ }
+
+private:
+ Dali::BaseHandle mHandle; // Handle to MyControl created via the type-registry
+ Dali::ConnectionTracker mConnectionTracker; // Used for automatic signal disconnection upon its destruction
+};
+@endcode
+
+@section using-action Performing a Registered Action
+
+Once an action is registered, the application writer can perform that action using the action name:
+
+@code
+Dali::TypeInfo type = Dali::TypeRegistry::Get().GetTypeInfo( "MyControl" );
+
+if ( type )
+{
+ Dali::BaseHandle handle = type.CreateInstance();
+
+ if ( handle )
+ {
+ // Perform action1, no attributes
+ handle.DoAction( "action1", std::vector< Dali::Property::Value >() );
+
+ // Create an attribute vector for action2
+ std::vector< Dali::Property::Value > action2Attributes;
+ action2Attributes.push_back( Dali::Property::Value( "Hello-Action-2" ) );
+
+ // Perform action2, with attributes
+ handle.DoAction( "action2", action2Attributes );
+ }
+}
+@endcode
+
+@section using-property Setting & Getting Registered Properties
+
+Like other properties, type registered properties can also be set and their values can be retrieved
+in a similar manner. The code below shows how this can be done.
+
+@code
+Dali::TypeInfo type = Dali::TypeRegistry::Get().GetTypeInfo( "MyControl" );
+
+if ( type )
+{
+ Dali::BaseHandle baseHandle = type.CreateInstance();
+
+ if ( baseHandle )
+ {
+ // Handle deals with properties, so DownCast
+ Dali::Handle handle = Dali::Handle::DownCast( baseHandle );
+
+ if ( handle )
+ {
+ // Setting a property
+ handle.SetProperty( PROPERTY_ONE, true ); // Assume Property indices are publicly accessible
+
+ // Get the property name
+ std::cout << "Property1 name is: " << handle.GetPropertyName( PROPERTY_ONE ) << std::endl;
+
+ // Get the property
+ bool propertyOne = handle.GetProperty< bool >( PROPERTY_ONE );
+
+ // Attempt to write a read-only property...
+ handle.SetProperty( PROPERTY_TWO, 4.0f ); // !!! Will assert as PROPERTY_TWO is read-only !!!
+ }
+ }
+}
+@endcode
+*
+*/
projects / platform / core / uifw / dali-toolkit.git / commitdiff
