forked from enlightenment/efl
parent
09069b6172
commit
5829d373c9
|
@ -1,519 +0,0 @@
|
|||
/**
|
||||
@file edje.dox
|
||||
@brief Edje Graphical Design Library
|
||||
|
||||
These routines are used for Edje.
|
||||
*/
|
||||
|
||||
/**
|
||||
|
||||
@mainpage Edje Library Documentation
|
||||
@image html e.png
|
||||
@version @PACKAGE_VERSION@
|
||||
@author Carsten Haitzler <raster@@rasterman.com>
|
||||
@author Tilman Sauerbeck (tilman at code-monkey de)
|
||||
@author ZigsMcKenzie <zigsmckenzie@@gmail.com>
|
||||
@author Cedric BAIL <cedric.bail@@free.fr>
|
||||
@author Brian Mattern <rephorm@@rephorm.com>
|
||||
@author Mathieu Taillefumier <mathieu.taillefumier@@free.fr>
|
||||
@author Tristan <blunderer@@gmail.com>
|
||||
@author Gustavo Lima Chaves <glima@@profusion.mobi>
|
||||
@author Bruno Dilly <bdilly@@profusion.mobi>
|
||||
@author Fabiano Fidêncio <fidencio@@profusion.mobi>
|
||||
@author Jihoon Kim <jihoon48.kim@@samsung.com>
|
||||
@author Tiago Falcão <tiago@@profusion.mobi>
|
||||
@author Davide Andreoli <dave@@gurumeditation.it>
|
||||
@author Sebastian Dransfeld <sd@@tango.flipp.net>
|
||||
@author Tom Hacohen <tom@@stosb.com>
|
||||
@author Aharon Hillel <a.hillel@@partner.samsung.com>
|
||||
@date 2003-2011
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@section intro What is Edje?
|
||||
|
||||
Edje is a complex graphical design & layout library.
|
||||
|
||||
It doesn't pretend to do containing and regular layout like a widget
|
||||
set, but it is the base for such components. Based on the requirements
|
||||
of Enlightenment 0.17, Edje should serve all the purposes of creating
|
||||
visual elements (borders of windows, buttons, scrollbars, etc.) and
|
||||
allow the designer the ability to animate, layout and control the look
|
||||
and feel of any program using Edje as its basic GUI constructor. This
|
||||
library allows for multiple collections of Layouts in one file,
|
||||
sharing the same image and font database and thus allowing a whole
|
||||
theme to be conveniently packaged into 1 file and shipped around.
|
||||
|
||||
Edje separates the layout and behavior logic. Edje files ship with an
|
||||
image and font database, used by all the parts in all the collections
|
||||
to source graphical data. It has a directory of logical part names
|
||||
pointing to the part collection entry ID in the file (thus allowing
|
||||
for multiple logical names to point to the same part collection,
|
||||
allowing for the sharing of data between display elements). Each part
|
||||
collection consists of a list of visual parts, as well as a list of
|
||||
programs. A program is a conditionally run program that if a
|
||||
particular event occurs (a button is pressed, a mouse enters or leaves
|
||||
a part) will trigger an action that may affect other parts. In this
|
||||
way a part collection can be "programmed" via its file as to hilight
|
||||
buttons when the mouse passes over them or show hidden parts when a
|
||||
button is clicked somewhere etc. The actions performed in changing
|
||||
from one state to another are also allowed to transition over a period
|
||||
of time, allowing animation. Programs and animations can be run in
|
||||
"parallel".
|
||||
|
||||
This separation and simplistic event driven style of programming can produce
|
||||
almost any look and feel one could want for basic visual elements. Anything
|
||||
more complex is likely the domain of an application or widget set that may
|
||||
use Edje as a convenient way of being able to configure parts of the display.
|
||||
|
||||
For details of Edje's history, see the \ref history section.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@section requirements What does Edje require?
|
||||
|
||||
Edje requires fairly little on your system. to use the Edje runtime library
|
||||
you need:
|
||||
|
||||
- Evas (library)
|
||||
- Ecore (library)
|
||||
- Eet (library)
|
||||
- Embryo (library)
|
||||
- Eina (library)
|
||||
|
||||
Evas needs to be build with the JPEG, PNG and EET image loaders enabled at a
|
||||
minimum. Edje uses X for the test program, so you will need the SOFTWARE_X11
|
||||
engine built into Evas as well. A suggested configure list is below in the
|
||||
"cheat sheet" for Evas.
|
||||
|
||||
Ecore needs the ECORE, ECORE_EVAS and ECORE_X modules built at a minimum.
|
||||
It's suggested to build all the Ecore modules, but the ECORE_FB modules is
|
||||
definitely optional.
|
||||
|
||||
Eina, Eet and Embryo have no interesting options so just build and
|
||||
install them.
|
||||
|
||||
It is suggested right now that you get the latest SVN versions of the
|
||||
required libraries. You also need to build them in the right order and make
|
||||
sure the right options are enabled in the required libraries. Here is a
|
||||
quick "cheat sheet" on how to get started.
|
||||
|
||||
@verbatim
|
||||
1. You need Eina from the trunk svn branch.
|
||||
|
||||
svn co http://svn.enlightenment.org/svn/e/trunk/eina/
|
||||
cd eina
|
||||
./autogen.sh
|
||||
./configure
|
||||
make
|
||||
sudo make install
|
||||
cd
|
||||
|
||||
2. You need Eet from the trunk svn branch.
|
||||
|
||||
svn co http://svn.enlightenment.org/svn/e/trunk/eet/
|
||||
cd eet
|
||||
./autogen.sh
|
||||
./configure
|
||||
make
|
||||
sudo make install
|
||||
cd
|
||||
|
||||
3. You need Evas from the trunk svn branch built with eet, png and jpeg loader support.
|
||||
|
||||
svn co http://svn.enlightenment.org/svn/e/trunk/evas/
|
||||
cd evas
|
||||
./autogen.sh
|
||||
./configure --enable-image-loader-eet --enable-font-loader-eet --enable-image-loader-jpeg --enable-image-loader-png --enable-buffer
|
||||
make
|
||||
sudo make install
|
||||
cd
|
||||
|
||||
4. You need Ecore from the trunk svn branch built with ecore-x and ecore-evas.
|
||||
|
||||
svn co http://svn.enlightenment.org/svn/e/trunk/ecore/
|
||||
cd ecore
|
||||
./autogen.sh
|
||||
./configure --enable-ecore-x --enable-ecore-evas --enable-ecore-evas-software-buffer --enable-ecore-evas-software-x11 --enable-ecore-evas-software-buffer
|
||||
make
|
||||
sudo make install
|
||||
cd
|
||||
|
||||
5. You need embryo from the trunk svn branch
|
||||
|
||||
svn co http://svn.enlightenment.org/svn/e/trunk/embryo/
|
||||
cd embryo
|
||||
./autogen.sh
|
||||
./configure
|
||||
make
|
||||
sudo make install
|
||||
cd
|
||||
|
||||
@endverbatim
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@section compiling How to compile and test Edje
|
||||
|
||||
Now you need to compile and install Edje.
|
||||
|
||||
@verbatim
|
||||
./configure
|
||||
make
|
||||
sudo make install
|
||||
@endverbatim
|
||||
|
||||
You now have it installed and ready to go, but you need input
|
||||
data. There are lots of examples in SVN, the best one is
|
||||
Enlightenment's own theme file.
|
||||
|
||||
You may use different tools to edit and view the generated ".edj"
|
||||
files, for instance:
|
||||
|
||||
- editje (http://trac.enlightenment.org/e/wiki/Editje)
|
||||
- edje_viewer (http://trac.enlightenment.org/e/wiki/Edje_Viewer)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@section details So how does this all work?
|
||||
|
||||
Edje internally holds a geometry state machine and state graph of what is
|
||||
visible, not, where, at what size, with what colors etc. This is described
|
||||
to Edje from an Edje .edj file containing this information. These files can
|
||||
be produced by using edje_cc to take a text file (a .edc file) and "compile"
|
||||
an output .edj file that contains this information, images and any other
|
||||
data needed.
|
||||
|
||||
The application using Edje will then create an object in its Evas
|
||||
canvas and set the bundle file to use, specifying the @b group name to
|
||||
use. Edje will load such information and create all the required
|
||||
children objects with the specified properties as defined in each @b
|
||||
part of the given group. See the following annotated example:
|
||||
|
||||
@code
|
||||
/*
|
||||
* edje_example.c:
|
||||
*
|
||||
* Creates a window using Ecore_Evas and inside it an object with
|
||||
* the edje group "my_group" from file "edje_example.edj".
|
||||
*
|
||||
* Requires edje_example.edj in the current folder.
|
||||
*
|
||||
* Compile:
|
||||
* gcc -o edje_example edje_example.c `pkg-config --cflags --libs eina evas ecore ecore-evas edje`
|
||||
*/
|
||||
|
||||
#include <Eina.h>
|
||||
#include <Evas.h>
|
||||
#include <Ecore.h>
|
||||
#include <Ecore_Evas.h>
|
||||
#include <Edje.h>
|
||||
|
||||
#define WIDTH 320
|
||||
#define HEIGHT 240
|
||||
|
||||
static Evas_Object *create_my_group(Evas *canvas, const char *text)
|
||||
{
|
||||
Evas_Object *edje;
|
||||
|
||||
/* create the edje object where we'll load our file */
|
||||
edje = edje_object_add(canvas);
|
||||
if (!edje)
|
||||
{
|
||||
EINA_LOG_CRIT("could not create edje object!");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* load our desired file */
|
||||
if (!edje_object_file_set(edje, "edje_example.edj", "my_group"))
|
||||
{
|
||||
int err = edje_object_load_error_get(edje);
|
||||
const char *errmsg = edje_load_error_str(err);
|
||||
EINA_LOG_ERR("could not load 'my_group' from edje_example.edj: %s",
|
||||
errmsg);
|
||||
|
||||
evas_object_del(edje);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (text)
|
||||
{
|
||||
/* this is will replace the string used by "text" part in "my_group" */
|
||||
if (!edje_object_part_text_set(edje, "text", text))
|
||||
{
|
||||
EINA_LOG_WARN("could not set the text. "
|
||||
"Maybe part 'text' does not exist?");
|
||||
}
|
||||
}
|
||||
|
||||
/* operate on edje as any other object */
|
||||
evas_object_move(edje, 0, 0);
|
||||
evas_object_resize(edje, WIDTH, HEIGHT);
|
||||
evas_object_show(edje);
|
||||
return edje;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
Ecore_Evas *window;
|
||||
Evas *canvas;
|
||||
Evas_Object *edje;
|
||||
const char *text;
|
||||
|
||||
eina_init();
|
||||
evas_init();
|
||||
ecore_init();
|
||||
ecore_evas_init();
|
||||
edje_init();
|
||||
|
||||
window = ecore_evas_new(NULL, 0, 0, WIDTH, HEIGHT, NULL);
|
||||
if (!window)
|
||||
{
|
||||
EINA_LOG_CRIT("could not create window.");
|
||||
return -1;
|
||||
}
|
||||
canvas = ecore_evas_get(window);
|
||||
|
||||
text = (argc > 1) ? argv[1] : NULL;
|
||||
|
||||
edje = create_my_group(canvas, text);
|
||||
if (!edje)
|
||||
return -2;
|
||||
|
||||
ecore_evas_show(window);
|
||||
ecore_main_loop_begin();
|
||||
|
||||
evas_object_del(edje);
|
||||
ecore_evas_free(window);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@endcode
|
||||
|
||||
It requires the following source Edje file:
|
||||
@code
|
||||
// compile: edje_cc edje_example.edc
|
||||
collections {
|
||||
group {
|
||||
name: "my_group"; // must be the same as in edje_example.c
|
||||
|
||||
parts {
|
||||
part {
|
||||
name: "background";
|
||||
type: RECT; // plain boring rectangle
|
||||
mouse_events: 0; // we don't need any mouse event on the background
|
||||
|
||||
// just one state "default"
|
||||
description {
|
||||
state: "default" 0.0; // must always exist
|
||||
color: 255 255 255 255; // white
|
||||
|
||||
// define part coordinates:
|
||||
|
||||
rel1 { // top-left point at (0, 0) [WIDTH * 0 + 0, HEIGHT * 0 + 0]
|
||||
relative: 0.0 0.0;
|
||||
offset: 0 0;
|
||||
}
|
||||
rel2 { // bottom-right point at (WIDTH * 1.0 - 1, HEIGHT * 1.0 - 1)
|
||||
relative: 1.0 1.0;
|
||||
offset: -1 -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
part {
|
||||
name: "text";
|
||||
type: TEXT;
|
||||
mouse_events: 1; // we want to change the color on mouse-over
|
||||
|
||||
// 2 states, one "default" and another "over" to be used
|
||||
// on mouse over effect
|
||||
|
||||
description {
|
||||
state: "default" 0.0;
|
||||
color: 255 0 0 255; // red
|
||||
|
||||
// define part coordinates:
|
||||
|
||||
rel1 { // top-left at (WIDTH * 0.1 + 5, HEIGHT * 0.2 + 10)
|
||||
relative: 0.1 0.2;
|
||||
offset: 5 10;
|
||||
}
|
||||
rel2 { // bottom-right at (WIDTH * 0.9 - 6, HEIGHT * 0.8 - 11)
|
||||
relative: 0.9 0.8;
|
||||
offset: -6 -11;
|
||||
}
|
||||
|
||||
// define text specific state details
|
||||
text {
|
||||
font: "Sans"; /* using fontconfig name! */
|
||||
size: 10;
|
||||
text: "hello world";
|
||||
}
|
||||
}
|
||||
|
||||
description {
|
||||
state: "over" 0.0;
|
||||
inherit: "default" 0.0; // copy everything from "default" at this point
|
||||
|
||||
color: 0 255 0 255; // override color, now it is green
|
||||
}
|
||||
}
|
||||
|
||||
// do programs to change color on text mouse in/out (over)
|
||||
programs {
|
||||
program {
|
||||
// what triggers this program:
|
||||
signal: "mouse,in";
|
||||
source: "text";
|
||||
|
||||
// what this program does:
|
||||
action: STATE_SET "over" 0.0;
|
||||
target: "text";
|
||||
|
||||
// do the state-set in a nice interpolation animation
|
||||
// using linear time in 0.1 second
|
||||
transition: LINEAR 0.1;
|
||||
}
|
||||
|
||||
program {
|
||||
// what triggers this program:
|
||||
signal: "mouse,out";
|
||||
source: "text";
|
||||
|
||||
// what this program does:
|
||||
action: STATE_SET "default" 0.0;
|
||||
target: "text";
|
||||
|
||||
// do the state-set in a nice interpolation animation
|
||||
// using linear time in 0.1 second
|
||||
transition: LINEAR 0.1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@endcode
|
||||
|
||||
|
||||
One should save these files as edje_example.c and edje_example.edc then:
|
||||
@verbatim
|
||||
gcc -o edje_example edje_example.c `pkg-config --cflags --libs eina evas ecore ecore-evas edje`
|
||||
edje_cc edje_example.edc
|
||||
|
||||
./edje_example "some text"
|
||||
@endverbatim
|
||||
|
||||
Although simple, this example illustrates that animations and state
|
||||
changes can be done from the Edje file itself without any requirement
|
||||
in the C application.
|
||||
|
||||
Before digging into changing or creating your own Edje source (edc)
|
||||
files, read the \ref edcref.
|
||||
|
||||
|
||||
|
||||
@section history Edje History
|
||||
|
||||
It's a sequel to "Ebits" which has serviced the needs of Enlightenment
|
||||
development for early version 0.17. The original design parameters under
|
||||
which Ebits came about were a lot more restricted than the resulting
|
||||
use of them, thus Edje was born.
|
||||
|
||||
Edje is a more complex layout engine compared to Ebits. It doesn't
|
||||
pretend to do containing and regular layout like a widget set. It
|
||||
still inherits the more simplistic layout ideas behind Ebits, but it
|
||||
now does them a lot more cleanly, allowing for easy expansion, and the
|
||||
ability to cover much more ground than Ebits ever could. For the
|
||||
purposes of Enlightenment 0.17, Edje was conceived to serve all the
|
||||
purposes of creating visual elements (borders of windows, buttons,
|
||||
scrollbars, etc.) and allow the designer the ability to animate,
|
||||
layout and control the look and feel of any program using Edje as its
|
||||
basic GUI constructor.
|
||||
|
||||
Unlike Ebits, Edje separates the layout and behavior logic.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@todo Complete documentation of API
|
||||
@todo Bytecode language for extending programs... but what/how?
|
||||
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
|
||||
@example embryo_custom_state.edc
|
||||
This example show how to create a custom state from embryo. Clicking on the
|
||||
3 labels will rotate the object in the given direction.
|
||||
|
||||
@example embryo_pong.edc
|
||||
Super-simple Pong implementation in pure embryo.
|
||||
|
||||
@example embryo_run_program.edc
|
||||
This example show how to run an edje program from embryo code.
|
||||
|
||||
@example embryo_set_state.edc
|
||||
This example show how to change the state of a part from embryo code.
|
||||
|
||||
@example embryo_set_text.edc
|
||||
This example show how to set the text in TEXT part from embryo code.
|
||||
|
||||
@example embryo_timer.edc
|
||||
This example show the usage of timers in embryo.
|
||||
|
||||
@example external_elm_anchorblock.edc
|
||||
This example use an elementary anchorblock and a button to animate the text.
|
||||
|
||||
@example external_elm_button.edc
|
||||
This example create some elementary buttons and do some actions on user click.
|
||||
|
||||
@example external_elm_check.edc
|
||||
This example show EXTERNAL checkbox in action.
|
||||
|
||||
@example external_elm_panes.edc
|
||||
This example show EXTERNAL elementary panes in action.
|
||||
|
||||
@example external_emotion_elm.edc
|
||||
Super-concise video player example using Edje/Emotion/Elementary.
|
||||
|
||||
@example lua_script.edc
|
||||
This example show the usage of lua scripting to create and animate some
|
||||
objects in the canvas.
|
||||
|
||||
@example toggle_using_filter.edc
|
||||
This example show how to toggle the state of a part using the 'filter'
|
||||
param in edje programs
|
||||
|
||||
*/
|
File diff suppressed because it is too large
Load Diff
|
@ -191,6 +191,24 @@ EAPI void edje_edit_print_internal_status(Evas_Object *obj);
|
|||
* @return EINA_TRUE if successfully added the group, EINA_FALSE if an error
|
||||
* occurred or if a group with the same name exists.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Add an edje (empty) group to an edje object's group set.
|
||||
*
|
||||
* @param obj The pointer to edje object.
|
||||
* @param name The name of the group.
|
||||
*
|
||||
* @return 1 If it could allocate memory to the part group added
|
||||
* or zero if not.
|
||||
*
|
||||
* This function adds, at run time, one more group, which will reside
|
||||
* in memory, to the group set found in the .edj file which @a obj was
|
||||
* loaded with. This group can be manipulated by other API functions,
|
||||
* like @c edje_edit_part_add(), for example. If desired, the new
|
||||
* group can be actually committed the respective .edj by use of @c
|
||||
* edje_edit_save().
|
||||
*
|
||||
*/
|
||||
EAPI Eina_Bool edje_edit_group_add(Evas_Object *obj, const char *name);
|
||||
|
||||
/** Delete the specified group from the given edje.
|
||||
|
@ -204,6 +222,21 @@ EAPI Eina_Bool edje_edit_group_add(Evas_Object *obj, const char *name);
|
|||
*
|
||||
* @return EINA_TRUE if successful, EINA_FALSE otherwise.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Delete the specified group from the edje file.
|
||||
*
|
||||
* @param obj The pointer to the edje object.
|
||||
* @param group_name Group to delete.
|
||||
*
|
||||
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
|
||||
*
|
||||
* This function deletes the given group from the file @a obj is set to. This
|
||||
* operation can't be undone as all references to the group are removed from
|
||||
* the file.
|
||||
* This function may fail if the group to be deleted is currently in use.
|
||||
*
|
||||
*/
|
||||
EAPI Eina_Bool edje_edit_group_del(Evas_Object *obj, const char *group_name);
|
||||
|
||||
/** Check if a group with the given name exist in the edje.
|
||||
|
@ -2027,6 +2060,18 @@ EAPI Eina_Bool edje_edit_state_external_param_choice_get(Evas_Object *obj, const
|
|||
*
|
||||
* @return EINA_TRUE if it was set, EINA_FALSE otherwise.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Arguments should have proper sized values matching their types:
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_INT: int
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_BOOL: int
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_DOUBLE: double
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_STRING: char*
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_CHOICE: char*
|
||||
*
|
||||
* @note: The validation of the parameter will occur only if the part
|
||||
* is in the same state as the one being modified.
|
||||
*/
|
||||
EAPI Eina_Bool edje_edit_state_external_param_set(Evas_Object *obj, const char *part, const char *state, double value, const char *param, Edje_External_Param_Type type, ...);
|
||||
|
||||
/** Set external parameter of type INT.
|
||||
|
|
|
@ -504,29 +504,6 @@ _edje_file_cache_shutdown(void)
|
|||
* API *
|
||||
*============================================================================*/
|
||||
|
||||
/**
|
||||
* @addtogroup Edje_cache_Group Cache
|
||||
*
|
||||
* @brief These functions provide an abstraction layer between the
|
||||
* application code and the interface, while allowing extremely
|
||||
* flexible dynamic layouts and animations.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Set the file cache size.
|
||||
*
|
||||
* @param count The file cache size in edje file units. Default is 16.
|
||||
*
|
||||
* This function sets the file cache size. Edje keeps this cache in
|
||||
* order to prevent duplicates of edje file entries in memory. The
|
||||
* file cache size can be retrieved with edje_file_cache_get().
|
||||
*
|
||||
* @see edje_file_cache_get()
|
||||
* @see edje_file_cache_flush()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_file_cache_set(int count)
|
||||
|
@ -536,18 +513,6 @@ edje_file_cache_set(int count)
|
|||
_edje_cache_file_clean();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return the file cache size.
|
||||
*
|
||||
* @return The file cache size in edje file units. Default is 16.
|
||||
*
|
||||
* This function returns the file cache size set by
|
||||
* edje_file_cache_set().
|
||||
*
|
||||
* @see edje_file_cache_set()
|
||||
* @see edje_file_cache_flush()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI int
|
||||
edje_file_cache_get(void)
|
||||
|
@ -555,16 +520,6 @@ edje_file_cache_get(void)
|
|||
return _edje_file_cache_size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Clean the file cache.
|
||||
*
|
||||
* This function cleans the file cache entries, but keeps this cache's
|
||||
* size to the last value set.
|
||||
*
|
||||
* @see edje_file_cache_set()
|
||||
* @see edje_file_cache_get()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_file_cache_flush(void)
|
||||
|
@ -577,20 +532,6 @@ edje_file_cache_flush(void)
|
|||
_edje_file_cache_size = ps;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the collection cache size.
|
||||
*
|
||||
* @param count The collection cache size, in edje object units. Default is 16.
|
||||
*
|
||||
* This function sets the collection cache size. Edje keeps this cache
|
||||
* in order to prevent duplicates of edje {collection,group,part}
|
||||
* entries in memory. The collection cache size can be retrieved with
|
||||
* edje_collection_cache_get().
|
||||
*
|
||||
* @see edje_collection_cache_get()
|
||||
* @see edje_collection_cache_flush()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_collection_cache_set(int count)
|
||||
|
@ -605,18 +546,6 @@ edje_collection_cache_set(int count)
|
|||
/* FIXME: freach in file hash too! */
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return the collection cache size.
|
||||
*
|
||||
* @return The collection cache size, in edje object units. Default is 16.
|
||||
*
|
||||
* This function returns the collection cache size set by
|
||||
* edje_collection_cache_set().
|
||||
*
|
||||
* @see edje_collection_cache_set()
|
||||
* @see edje_collection_cache_flush()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI int
|
||||
edje_collection_cache_get(void)
|
||||
|
@ -624,16 +553,6 @@ edje_collection_cache_get(void)
|
|||
return _edje_collection_cache_size;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Clean the collection cache.
|
||||
*
|
||||
* This function cleans the collection cache, but keeps this cache's
|
||||
* size to the last value set.
|
||||
*
|
||||
* @see edje_collection_cache_set()
|
||||
* @see edje_collection_cache_get()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_collection_cache_flush(void)
|
||||
|
@ -649,8 +568,3 @@ edje_collection_cache_flush(void)
|
|||
/* FIXME: freach in file hash too! */
|
||||
_edje_collection_cache_size = ps;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -955,23 +955,6 @@ edje_edit_compiler_get(Evas_Object *obj)
|
|||
/* GROUPS API */
|
||||
/****************/
|
||||
|
||||
/**
|
||||
* @brief Add an edje (empty) group to an edje object's group set.
|
||||
*
|
||||
* @param obj The pointer to edje object.
|
||||
* @param name The name of the group.
|
||||
*
|
||||
* @return 1 If it could allocate memory to the part group added
|
||||
* or zero if not.
|
||||
*
|
||||
* This function adds, at run time, one more group, which will reside
|
||||
* in memory, to the group set found in the .edj file which @a obj was
|
||||
* loaded with. This group can be manipulated by other API functions,
|
||||
* like @c edje_edit_part_add(), for example. If desired, the new
|
||||
* group can be actually committed the respective .edj by use of @c
|
||||
* edje_edit_save().
|
||||
*
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_edit_group_add(Evas_Object *obj, const char *name)
|
||||
{
|
||||
|
@ -1066,20 +1049,6 @@ edje_edit_group_add(Evas_Object *obj, const char *name)
|
|||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Delete the specified group from the edje file.
|
||||
*
|
||||
* @param obj The pointer to the edje object.
|
||||
* @param group_name Group to delete.
|
||||
*
|
||||
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure.
|
||||
*
|
||||
* This function deletes the given group from the file @a obj is set to. This
|
||||
* operation can't be undone as all references to the group are removed from
|
||||
* the file.
|
||||
* This function may fail if the group to be deleted is currently in use.
|
||||
*
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_edit_group_del(Evas_Object *obj, const char *group_name)
|
||||
{
|
||||
|
@ -4067,17 +4036,6 @@ edje_edit_state_external_param_choice_get(Evas_Object *obj, const char *part, co
|
|||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Arguments should have proper sized values matching their types:
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_INT: int
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_BOOL: int
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_DOUBLE: double
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_STRING: char*
|
||||
* - EDJE_EXTERNAL_PARAM_TYPE_CHOICE: char*
|
||||
*
|
||||
* @note: The validation of the parameter will occur only if the part
|
||||
* is in the same state as the one being modified.
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_edit_state_external_param_set(Evas_Object *obj, const char *part, const char *state, double value, const char *param, Edje_External_Param_Type type, ...)
|
||||
{
|
||||
|
|
|
@ -3,14 +3,6 @@
|
|||
static Eina_Hash *type_registry = NULL;
|
||||
static int init_count = 0;
|
||||
|
||||
/**
|
||||
* @brief Converts type identifier to string nicer representation.
|
||||
*
|
||||
* This may be used to debug or other informational purposes.
|
||||
*
|
||||
* @param type the identifier to convert.
|
||||
* @return the string with the string representation, or @c "(unknown)".
|
||||
*/
|
||||
EAPI const char *
|
||||
edje_external_param_type_str(Edje_External_Param_Type type)
|
||||
{
|
||||
|
@ -31,25 +23,6 @@ edje_external_param_type_str(Edje_External_Param_Type type)
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the object created by this external part.
|
||||
*
|
||||
* Parts of type external creates the part object using information
|
||||
* provided by external plugins. It's somehow like "swallow"
|
||||
* (edje_object_part_swallow()), but it's all set automatically.
|
||||
*
|
||||
* This function returns the part created by such external plugins and
|
||||
* being currently managed by this Edje.
|
||||
*
|
||||
* @note Almost all swallow rules apply: you should not move, resize,
|
||||
* hide, show, set the color or clipper of such part. It's a bit
|
||||
* more restrictive as one must @b never delete this object!
|
||||
*
|
||||
* @param obj A valid Evas_Object handle
|
||||
* @param part The part name
|
||||
* @return The externally created object, or NULL if there is none or
|
||||
* part is not an external.
|
||||
*/
|
||||
EAPI Evas_Object *
|
||||
edje_object_part_external_object_get(const Evas_Object *obj, const char *part)
|
||||
{
|
||||
|
@ -77,36 +50,6 @@ edje_object_part_external_object_get(const Evas_Object *obj, const char *part)
|
|||
return rp->swallowed_object;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the parameter for the external part.
|
||||
*
|
||||
* Parts of type external may carry extra properties that have
|
||||
* meanings defined by the external plugin. For instance, it may be a
|
||||
* string that defines a button label and setting this property will
|
||||
* change that label on the fly.
|
||||
*
|
||||
* @note external parts have parameters set when they change
|
||||
* states. Those parameters will never be changed by this
|
||||
* function. The interpretation of how state_set parameters and
|
||||
* param_set will interact is up to the external plugin.
|
||||
*
|
||||
* @note this function will not check if parameter value is valid
|
||||
* using #Edje_External_Param_Info minimum, maximum, valid
|
||||
* choices and others. However these should be checked by the
|
||||
* underlying implementation provided by the external
|
||||
* plugin. This is done for performance reasons.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle
|
||||
* @param part The part name
|
||||
* @param param the parameter details, including its name, type and
|
||||
* actual value. This pointer should be valid, and the
|
||||
* parameter must exist in
|
||||
* #Edje_External_Type::parameters_info, with the exact type,
|
||||
* otherwise the operation will fail and @c EINA_FALSE will be
|
||||
* returned.
|
||||
*
|
||||
* @return @c EINA_TRUE if everything went fine, @c EINA_FALSE on errors.
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_object_part_external_param_set(Evas_Object *obj, const char *part, const Edje_External_Param *param)
|
||||
{
|
||||
|
@ -128,34 +71,6 @@ edje_object_part_external_param_set(Evas_Object *obj, const char *part, const Ed
|
|||
return _edje_external_param_set(obj, rp, param);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the parameter for the external part.
|
||||
*
|
||||
* Parts of type external may carry extra properties that have
|
||||
* meanings defined by the external plugin. For instance, it may be a
|
||||
* string that defines a button label. This property can be modifed by
|
||||
* state parameters, by explicit calls to
|
||||
* edje_object_part_external_param_set() or getting the actual object
|
||||
* with edje_object_part_external_object_get() and calling native
|
||||
* functions.
|
||||
*
|
||||
* This function asks the external plugin what is the current value,
|
||||
* independent on how it was set.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle
|
||||
* @param part The part name
|
||||
|
||||
* @param param the parameter details. It is used as both input and
|
||||
* output variable. This pointer should be valid, and the
|
||||
* parameter must exist in
|
||||
* #Edje_External_Type::parameters_info, with the exact type,
|
||||
* otherwise the operation will fail and @c EINA_FALSE will be
|
||||
* returned.
|
||||
*
|
||||
* @return @c EINA_TRUE if everything went fine and @p param members
|
||||
* are filled with information, @c EINA_FALSE on errors and @p
|
||||
* param member values are not set or valid.
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_object_part_external_param_get(const Evas_Object *obj, const char *part, Edje_External_Param *param)
|
||||
{
|
||||
|
@ -179,7 +94,7 @@ edje_object_part_external_param_get(const Evas_Object *obj, const char *part, Ed
|
|||
|
||||
|
||||
|
||||
EAPI Evas_Object*
|
||||
EAPI Evas_Object *
|
||||
edje_object_part_external_content_get(const Evas_Object *obj, const char *part, const char *content)
|
||||
{
|
||||
Edje *ed;
|
||||
|
@ -200,16 +115,6 @@ edje_object_part_external_content_get(const Evas_Object *obj, const char *part,
|
|||
return _edje_external_content_get(rp->swallowed_object, content);
|
||||
}
|
||||
|
||||
/**
|
||||
* Facility to query the type of the given parameter of the given part.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle
|
||||
* @param part The part name
|
||||
* @param param the parameter name to use.
|
||||
*
|
||||
* @return @c EDJE_EXTERNAL_PARAM_TYPE_MAX on errors, or another value
|
||||
* from #Edje_External_Param_Type on success.
|
||||
*/
|
||||
EAPI Edje_External_Param_Type
|
||||
edje_object_part_external_param_type_get(const Evas_Object *obj, const char *part, const char *param)
|
||||
{
|
||||
|
@ -248,18 +153,6 @@ edje_object_part_external_param_type_get(const Evas_Object *obj, const char *par
|
|||
}
|
||||
|
||||
|
||||
/**
|
||||
* Register given type name to return the given information.
|
||||
*
|
||||
* @param type_name name to register and be known by edje's "source:"
|
||||
* parameter of "type: EXTERNAL" parts.
|
||||
* @param type_info meta-information describing how to interact with it.
|
||||
*
|
||||
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure (like
|
||||
* type already registered).
|
||||
*
|
||||
* @see edje_external_type_array_register()
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_external_type_register(const char *type_name, const Edje_External_Type *type_info)
|
||||
{
|
||||
|
@ -285,17 +178,6 @@ edje_external_type_register(const char *type_name, const Edje_External_Type *typ
|
|||
return eina_hash_add(type_registry, type_name, type_info);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister given type name previously registered.
|
||||
*
|
||||
* @param type_name name to unregister. It should be registered with
|
||||
* edje_external_type_register() before.
|
||||
*
|
||||
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure (like
|
||||
* type_name did not exist).
|
||||
*
|
||||
* @see edje_external_type_array_unregister()
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_external_type_unregister(const char *type_name)
|
||||
{
|
||||
|
@ -304,28 +186,6 @@ edje_external_type_unregister(const char *type_name)
|
|||
return eina_hash_del_by_key(type_registry, type_name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Register a batch of types and their information.
|
||||
*
|
||||
* This is the recommended function to add information as it's faster
|
||||
* than the single version edje_external_type_register().
|
||||
*
|
||||
* @note the given array is not modified, but the type name strings
|
||||
* are @b not duplicated! That is, all type names must be @b
|
||||
* live until they are unregistered! This was chosen to save
|
||||
* some memory and most people will just define the array as a
|
||||
* global static const type anyway.
|
||||
*
|
||||
* @param array @c NULL terminated array with type name and
|
||||
* information. Note that type name or information are not
|
||||
* modified by are @b referenced, so they must keep alive after
|
||||
* this function returns!
|
||||
*
|
||||
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure (like
|
||||
* type already registered).
|
||||
*
|
||||
* @see edje_external_type_register()
|
||||
*/
|
||||
EAPI void
|
||||
edje_external_type_array_register(const Edje_External_Type_Info *array)
|
||||
{
|
||||
|
@ -349,14 +209,6 @@ edje_external_type_array_register(const Edje_External_Type_Info *array)
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister a batch of given external type previously registered.
|
||||
*
|
||||
* @param array @c NULL terminated array, should be the same as the
|
||||
* one used to register with edje_external_type_array_register()
|
||||
*
|
||||
* @see edje_external_type_unregister()
|
||||
*/
|
||||
EAPI void
|
||||
edje_external_type_array_unregister(const Edje_External_Type_Info *array)
|
||||
{
|
||||
|
@ -369,70 +221,12 @@ edje_external_type_array_unregister(const Edje_External_Type_Info *array)
|
|||
eina_hash_del(type_registry, itr->name, itr->info);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the current ABI version for Edje_External_Type structure.
|
||||
*
|
||||
* Always check this number before accessing Edje_External_Type in
|
||||
* your own software. If the number is not the same, your software may
|
||||
* access invalid memory and crash, or just get garbage values.
|
||||
*
|
||||
* @warning @b NEVER, EVER define your own Edje_External_Type using the
|
||||
* return of this function as it will change as Edje library
|
||||
* (libedje.so) changes, but your type definition will
|
||||
* not. Instead, use #EDJE_EXTERNAL_TYPE_ABI_VERSION.
|
||||
*
|
||||
* Summary:
|
||||
* - use edje_external_type_abi_version_get() to check.
|
||||
* - use #EDJE_EXTERNAL_TYPE_ABI_VERSION to define/declare.
|
||||
*
|
||||
* @return version this edje library was compiled.
|
||||
*/
|
||||
EAPI unsigned int
|
||||
edje_external_type_abi_version_get(void)
|
||||
{
|
||||
return EDJE_EXTERNAL_TYPE_ABI_VERSION;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an iterator that emits Eina_Hash_Tuple pointers with key
|
||||
* being the name and data being the Edje_External_Type pointer.
|
||||
*
|
||||
* @code
|
||||
* const Eina_Hash_Tuple *tuple;
|
||||
* Eina_Iterator *itr;
|
||||
* const Eina_List *l, *modules;
|
||||
* const char *s;
|
||||
*
|
||||
* modules = edje_available_modules_get();
|
||||
* EINA_LIST_FOREACH(modules, l, s)
|
||||
* {
|
||||
* if (!edje_module_load(s))
|
||||
* printf("Error loading edje module: %s\n", s);
|
||||
* }
|
||||
*
|
||||
* itr = edje_external_iterator_get();
|
||||
* EINA_ITERATOR_FOREACH(itr, tuple)
|
||||
* {
|
||||
* const char *name = tuple->key;
|
||||
* const Edje_External_Type *type = tuple->data;
|
||||
*
|
||||
* if ((!type) ||
|
||||
* (type->abi_version != edje_external_type_abi_version_get()))
|
||||
* {
|
||||
* printf("Error: invalid type %p (abi: %d, expected: %d)\n",
|
||||
* type, type ? type->abi_version : 0,
|
||||
* edje_external_type_abi_version_get());
|
||||
* continue;
|
||||
* }
|
||||
*
|
||||
* printf("%s: %s (%s) label='%s' desc='%s'\n",
|
||||
* name, type->module, type->module_name,
|
||||
* type->label_get ? type->label_get(type->data) : "",
|
||||
* type->description_get ? type->description_get(type->data) : "");
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
*/
|
||||
EAPI Eina_Iterator *
|
||||
edje_external_iterator_get(void)
|
||||
{
|
||||
|
@ -536,18 +330,6 @@ edje_external_param_choice_get(const Eina_List *params, const char *key, const c
|
|||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the array of parameters information about a type given its name.
|
||||
*
|
||||
* @note the type names and other strings are static, that means they
|
||||
* @b NOT translated. One must use
|
||||
* Edje_External_Type::translate() to translate those.
|
||||
*
|
||||
* @return the NULL terminated array, or @c NULL if type is unknown or
|
||||
* it does not have any parameter information.
|
||||
*
|
||||
* @see edje_external_type_get()
|
||||
*/
|
||||
EAPI const Edje_External_Param_Info *
|
||||
edje_external_param_info_get(const char *type_name)
|
||||
{
|
||||
|
|
|
@ -10,18 +10,6 @@ static Eina_List *_edje_swallows_collect(Edje *ed);
|
|||
|
||||
/************************** API Routines **************************/
|
||||
|
||||
/* FIXDOC: Verify/expand doc */
|
||||
/** Sets the EET file and group to load @a obj from
|
||||
* @param obj A valid Evas_Object handle
|
||||
* @param file The path to the EET file
|
||||
* @param group The group name in the Edje
|
||||
* @return 0 on Error\n
|
||||
* 1 on Success and sets EDJE_LOAD_ERROR_NONE
|
||||
*
|
||||
* Edje uses EET files, conventionally ending in .edj, to store object
|
||||
* descriptions. A single file contains multiple named groups. This function
|
||||
* specifies the file and group name to load @a obj from.
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_object_file_set(Evas_Object *obj, const char *file, const char *group)
|
||||
{
|
||||
|
@ -36,20 +24,6 @@ edje_object_file_set(Evas_Object *obj, const char *file, const char *group)
|
|||
return ret;
|
||||
}
|
||||
|
||||
/* FIXDOC: Verify/expand doc. */
|
||||
/** Get the file and group name that @a obj was loaded from
|
||||
* @param obj A valid Evas_Object handle
|
||||
* @param file A pointer to store a pointer to the filename in
|
||||
* @param group A pointer to store a pointer to the group name in
|
||||
*
|
||||
* This gets the EET file location and group for the given Evas_Object.
|
||||
* If @a obj is either not an edje file, or has not had its file/group set
|
||||
* using edje_object_file_set(), then both @a file and @a group will be set
|
||||
* to NULL.
|
||||
*
|
||||
* It is valid to pass in NULL for either @a file or @a group if you are not
|
||||
* interested in one of the values.
|
||||
*/
|
||||
EAPI void
|
||||
edje_object_file_get(const Evas_Object *obj, const char **file, const char **group)
|
||||
{
|
||||
|
@ -66,22 +40,6 @@ edje_object_file_get(const Evas_Object *obj, const char **file, const char **gro
|
|||
if (group) *group = ed->group;
|
||||
}
|
||||
|
||||
/* FIXDOC: Verify. return error? */
|
||||
/** Gets the Edje load error
|
||||
* @param obj A valid Evas_Object handle
|
||||
*
|
||||
* @return The Edje load error:\n
|
||||
* EDJE_LOAD_ERROR_NONE: No Error\n
|
||||
* EDJE_LOAD_ERROR_GENERIC: Generic Error\n
|
||||
* EDJE_LOAD_ERROR_DOES_NOT_EXIST: Does not Exist\n
|
||||
* EDJE_LOAD_ERROR_PERMISSION_DENIED: Permission Denied\n
|
||||
* EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED: Resource Allocation Failed\n
|
||||
* EDJE_LOAD_ERROR_CORRUPT_FILE: Corrupt File\n
|
||||
* EDJE_LOAD_ERROR_UNKNOWN_FORMAT: Unknown Format\n
|
||||
* EDJE_LOAD_ERROR_INCOMPATIBLE_FILE: Incompatible File\n
|
||||
* EDJE_LOAD_ERROR_UNKNOWN_COLLECTION: Unknown Collection\n
|
||||
* EDJE_LOAD_ERROR_RECURSIVE_REFERENCE: Recursive Reference\n
|
||||
*/
|
||||
EAPI Edje_Load_Error
|
||||
edje_object_load_error_get(const Evas_Object *obj)
|
||||
{
|
||||
|
@ -123,14 +81,6 @@ edje_load_error_str(Edje_Load_Error error)
|
|||
}
|
||||
|
||||
|
||||
/** Get a list of groups in an edje file
|
||||
* @param file The path to the edje file
|
||||
*
|
||||
* @return The Eina_List of group names (char *)
|
||||
*
|
||||
* Note: the list must be freed using edje_file_collection_list_free()
|
||||
* when you are done with it.
|
||||
*/
|
||||
EAPI Eina_List *
|
||||
edje_file_collection_list(const char *file)
|
||||
{
|
||||
|
@ -157,11 +107,6 @@ edje_file_collection_list(const char *file)
|
|||
return lst;
|
||||
}
|
||||
|
||||
/** Free file collection list
|
||||
* @param lst The Eina_List of groups
|
||||
*
|
||||
* Frees the list returned by edje_file_collection_list().
|
||||
*/
|
||||
EAPI void
|
||||
edje_file_collection_list_free(Eina_List *lst)
|
||||
{
|
||||
|
@ -172,12 +117,6 @@ edje_file_collection_list_free(Eina_List *lst)
|
|||
}
|
||||
}
|
||||
|
||||
/** Determine whether a group matching glob exists in an edje file.
|
||||
* @param file The file path
|
||||
* @param glob A glob to match on
|
||||
*
|
||||
* @return 1 if a match is found, 0 otherwise
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_file_group_exists(const char *file, const char *glob)
|
||||
{
|
||||
|
@ -238,21 +177,6 @@ edje_file_group_exists(const char *file, const char *glob)
|
|||
}
|
||||
|
||||
|
||||
/** Get data from the file level data block of an edje file
|
||||
* @param file The path to the .edj file
|
||||
* @param key The data key
|
||||
* @return The string value of the data
|
||||
*
|
||||
* If an edje file is built from the following edc:
|
||||
*
|
||||
* data {
|
||||
* item: "key1" "value1";
|
||||
* item: "key2" "value2";
|
||||
* }
|
||||
* collections { ... }
|
||||
*
|
||||
* Then, edje_file_data_get("key1") will return "value1"
|
||||
*/
|
||||
EAPI char *
|
||||
edje_file_data_get(const char *file, const char *key)
|
||||
{
|
||||
|
|
|
@ -1,19 +1,3 @@
|
|||
/**
|
||||
* @page luaref Edje Lua scripting
|
||||
*
|
||||
* @section intro Introduction
|
||||
*
|
||||
* Lua is intended for script-only objects at this point (with embryo left
|
||||
* for augmenting standard programs). Since script-only objects effectively
|
||||
* define objects entirely via Lua script (resize handling, event handling
|
||||
* etc. etc.) this places many more demands on them, and thus a more powerful
|
||||
* language is in order. Lua is that language.
|
||||
*
|
||||
* To get you started, here's an example:
|
||||
* @include lua_script.edc
|
||||
*
|
||||
*/
|
||||
|
||||
#include "edje_private.h"
|
||||
|
||||
//--------------------------------------------------------------------------//
|
||||
|
|
|
@ -12,34 +12,6 @@ Eina_Mempool *_edje_real_part_state_mp = NULL;
|
|||
* API *
|
||||
*============================================================================*/
|
||||
|
||||
/**
|
||||
* @addtogroup Edje_main_Group Main
|
||||
*
|
||||
* @brief These functions provide an abstraction layer between the
|
||||
* application code and the interface, while allowing extremely
|
||||
* flexible dynamic layouts and animations.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Initialize the edje library.
|
||||
*
|
||||
* @return The new init count. The initial value is zero.
|
||||
*
|
||||
* This function initializes the ejde library, making the propers
|
||||
* calls to initialization functions. It makes calls to functions
|
||||
* eina_init(), ecore_init(), embryo_init() and eet_init() so
|
||||
* there is no need to call those functions again in your code. To
|
||||
* shutdown edje there is a function edje_shutdown().
|
||||
*
|
||||
* @see edje_shutdown()
|
||||
* @see eina_init()
|
||||
* @see ecore_init()
|
||||
* @see embryo_init()
|
||||
* @see eet_init()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI int
|
||||
edje_init(void)
|
||||
|
@ -135,24 +107,6 @@ edje_init(void)
|
|||
return --_edje_init_count;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Shutdown the edje library.
|
||||
*
|
||||
* @return The number of times the library has been initialised without being
|
||||
* shutdown.
|
||||
*
|
||||
* This function shuts down the edje library. It calls the functions
|
||||
* eina_shutdown(), ecore_shutdown(), embryo_shutdown() and
|
||||
* eet_shutdown(), so there is no need to call these functions again
|
||||
* in your code.
|
||||
*
|
||||
* @see edje_init()
|
||||
* @see eina_shutdown()
|
||||
* @see ecore_shutdown()
|
||||
* @see embryo_shutdown()
|
||||
* @see eet_shutdown()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI int
|
||||
edje_shutdown(void)
|
||||
|
@ -292,8 +246,3 @@ _edje_unref(Edje *ed)
|
|||
ed->references--;
|
||||
if (ed->references == 0) _edje_del(ed);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -13,34 +13,6 @@ static int tmp_msgq_restart = 0;
|
|||
* API *
|
||||
*============================================================================*/
|
||||
|
||||
/**
|
||||
* @addtogroup Edje_message_queue_Group Message_Queue
|
||||
*
|
||||
* @brief These functions provide an abstraction layer between the
|
||||
* application code and the interface, while allowing extremely
|
||||
* flexible dynamic layouts and animations.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Send message to object.
|
||||
*
|
||||
* @param obj The edje object reference.
|
||||
* @param type The type of message to send.
|
||||
* @param id A identification number for the message.
|
||||
* @param msg The message to be send.
|
||||
*
|
||||
*
|
||||
* This function sends messages to this object and to all of its child
|
||||
* objects, if applicable. The function that handles messages arriving
|
||||
* at this edje object is is set with
|
||||
* edje_object_message_handler_set().
|
||||
*
|
||||
* @see edje_object_message_handler_set()
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_object_message_send(Evas_Object *obj, Edje_Message_Type type, int id, void *msg)
|
||||
{
|
||||
|
@ -59,18 +31,6 @@ edje_object_message_send(Evas_Object *obj, Edje_Message_Type type, int id, void
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the message handler function for this an object.
|
||||
*
|
||||
* @param obj The edje object reference.
|
||||
* @param func The function to handle messages.
|
||||
* @param data The data to be associated to the message handler.
|
||||
*
|
||||
*
|
||||
* This function associates a message handler function and data to the
|
||||
* edje object.
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_object_message_handler_set(Evas_Object *obj, Edje_Message_Handler_Cb func, void *data)
|
||||
|
@ -82,16 +42,6 @@ edje_object_message_handler_set(Evas_Object *obj, Edje_Message_Handler_Cb func,
|
|||
_edje_message_cb_set(ed, func, data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Process an object's message queue.
|
||||
*
|
||||
* @param obj The edje object reference.
|
||||
*
|
||||
* This function goes through the object message queue processing the
|
||||
* pending messages for *this* specific edje object. Normally they'd
|
||||
* be processed only at idle time.
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_object_message_signal_process(Evas_Object *obj)
|
||||
|
@ -196,13 +146,6 @@ end:
|
|||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Process all queued up edje messages.
|
||||
*
|
||||
* This function triggers the processing of messages addressed to any
|
||||
* (alive) edje objects.
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
edje_message_signal_process(void)
|
||||
|
@ -912,8 +855,3 @@ _edje_message_del(Edje *ed)
|
|||
if (ed->message.num <= 0) return;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -13,100 +13,18 @@ Eina_List *_edje_animators = NULL;
|
|||
* API *
|
||||
*============================================================================*/
|
||||
|
||||
/**
|
||||
* @addtogroup Edje_program_Group Program
|
||||
*
|
||||
* @brief These functions provide an abstraction layer between the
|
||||
* application code and the interface, while allowing extremely
|
||||
* flexible dynamic layouts and animations.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Set edje trasitions' frame time.
|
||||
*
|
||||
* @param t The frame time, in seconds. Default value is 1/30.
|
||||
*
|
||||
* This function sets the edje built-in animations' frame time (thus,
|
||||
* affecting their resolution) by calling
|
||||
* ecore_animator_frametime_set(). This frame time can be retrieved
|
||||
* with edje_frametime_get().
|
||||
*
|
||||
* @see edje_frametime_get()
|
||||
*
|
||||
*/
|
||||
EAPI void
|
||||
edje_frametime_set(double t)
|
||||
{
|
||||
ecore_animator_frametime_set(t);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get edje trasitions' frame time.
|
||||
*
|
||||
* @return The frame time, in seconds.
|
||||
*
|
||||
* This function returns the edje frame time set by
|
||||
* edje_frametime_set().
|
||||
*
|
||||
* @see edje_frametime_set()
|
||||
*
|
||||
*/
|
||||
EAPI double
|
||||
edje_frametime_get(void)
|
||||
{
|
||||
return ecore_animator_frametime_get();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Add a callback for a signal emitted by @a obj.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @param emission The signal's name.
|
||||
* @param source The signal's source.
|
||||
* @param func The callback function to be executed when the signal is
|
||||
* emitted.
|
||||
* @param data A pointer to data to pass in to the callback function.
|
||||
*
|
||||
* Connects a callback function to a signal emitted by @a obj.
|
||||
* In EDC, a program can emit a signal as follows:
|
||||
*
|
||||
* @code
|
||||
* program {
|
||||
* name: "emit_example";
|
||||
* action: SIGNAL_EMIT "a_signal" "a_source";
|
||||
* }
|
||||
* @endcode
|
||||
*
|
||||
* Assuming a function with the following declaration is definded:
|
||||
*
|
||||
* @code
|
||||
* void cb_signal(void *data, Evas_Object *o, const char *emission, const char *source);
|
||||
* @endcode
|
||||
*
|
||||
* a callback is attached using:
|
||||
*
|
||||
* @code
|
||||
* edje_object_signal_callback_add(obj, "a_signal", "a_source", cb_signal, data);
|
||||
* @endcode
|
||||
*
|
||||
* Here, @a data is an arbitrary pointer to be used as desired. Note
|
||||
* that @a emission and @a source correspond respectively to the first
|
||||
* and the second parameters at the SIGNAL_EMIT action.
|
||||
*
|
||||
* Internal edje signals can also be attached to, and globs can occur
|
||||
* in either the emission or source name, e.g.
|
||||
*
|
||||
* @code
|
||||
* edje_object_signal_callback_add(obj, "mouse,down,*", "button.*", NULL);
|
||||
* @endcode
|
||||
*
|
||||
* Here, any mouse down events on an edje part whose name begins with
|
||||
* "button." will trigger the callback. The actual signal and source
|
||||
* names will be passed in to the @a emission and @a source parameters
|
||||
* of the callback function (e.g. "mouse,down,2" and "button.close").
|
||||
*/
|
||||
EAPI void
|
||||
edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
|
||||
{
|
||||
|
@ -134,25 +52,6 @@ edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const ch
|
|||
_edje_callbacks_patterns_clean(ed);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove a signal-triggered callback from an object.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @param emission The emission string.
|
||||
* @param source The source string.
|
||||
* @param func The callback function.
|
||||
* @return The data pointer
|
||||
*
|
||||
* This function removes a callback, previously attached to the
|
||||
* emittion of a signal, from the object @a obj. The parameters @a
|
||||
* emission, @a source and @a func must match exactly those passed to
|
||||
* a previous call to edje_object_signal_callback_add(). The data
|
||||
* pointer that was passed to this call will be returned.
|
||||
*
|
||||
* @see edje_object_signal_callback_add().
|
||||
* @see edje_object_signal_callback_del_full().
|
||||
*
|
||||
*/
|
||||
EAPI void *
|
||||
edje_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, void (*func) (void *data, Evas_Object *o, const char *emission, const char *source))
|
||||
{
|
||||
|
@ -195,26 +94,6 @@ edje_object_signal_callback_del(Evas_Object *obj, const char *emission, const ch
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Remove a signal-triggered callback from an object.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @param emission The emission string.
|
||||
* @param source The source string.
|
||||
* @param func The callback function.
|
||||
* @param data The user data passed to the callback.
|
||||
* @return The data pointer
|
||||
*
|
||||
* This function removes a callback, previously attached to the
|
||||
* emittion of a signal, from the object @a obj. The parameters @a
|
||||
* emission, @a sourcei, @a func and @a data must match exactly those
|
||||
* passed to a previous call to edje_object_signal_callback_add(). The data
|
||||
* pointer that was passed to this call will be returned.
|
||||
*
|
||||
* @see edje_object_signal_callback_add().
|
||||
* @see edje_object_signal_callback_del().
|
||||
*
|
||||
*/
|
||||
EAPI void *
|
||||
edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
||||
{
|
||||
|
@ -257,34 +136,6 @@ edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, con
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Send a signal to an edje object.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @param emission The signal's name.
|
||||
* @param source The signal's source.
|
||||
*
|
||||
* This function sends a signal to the object @a obj. An edje program
|
||||
* can respond to a signal by specifying matching 'signal' and
|
||||
* 'source' fields.
|
||||
*
|
||||
* @code
|
||||
* edje_object_signal_emit(obj, "a_signal", "");
|
||||
* @endcode
|
||||
*
|
||||
* will trigger a program whose EDC block is:
|
||||
*
|
||||
* @code
|
||||
* program {
|
||||
* name: "a_program";
|
||||
* signal: "a_signal";
|
||||
* source: "";
|
||||
* action: ...
|
||||
* }
|
||||
* @endcode
|
||||
*
|
||||
* FIXME: should this signal be sent to children also?
|
||||
*/
|
||||
EAPI void
|
||||
edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source)
|
||||
{
|
||||
|
@ -298,19 +149,6 @@ edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *sour
|
|||
}
|
||||
|
||||
/* FIXDOC: Verify/Expand */
|
||||
/**
|
||||
* @brief Set the edje object to playing or paused states.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @param play Object state (1 to playing, 0 to pauseed).
|
||||
*
|
||||
* This function sets the edje object @a obj to playing or paused
|
||||
* states, depending on the parameter @a play. This has no effect if
|
||||
* the object was already at that state.
|
||||
*
|
||||
* @see edje_object_play_get().
|
||||
*
|
||||
*/
|
||||
EAPI void
|
||||
edje_object_play_set(Evas_Object *obj, Eina_Bool play)
|
||||
{
|
||||
|
@ -347,20 +185,6 @@ edje_object_play_set(Evas_Object *obj, Eina_Bool play)
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the edje object's play/pause state.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @return @c EINA_FALSE if the object is not connected, its @c delete_me flag
|
||||
* is set, or it is at paused state; @c EINA_TRUE if the object is at playing
|
||||
* state.
|
||||
*
|
||||
* This function tells if an edje object is playing or not. This state
|
||||
* is set by edje_object_play_set().
|
||||
*
|
||||
* @see edje_object_play_set().
|
||||
*
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
edje_object_play_get(const Evas_Object *obj)
|
||||
{
|
||||
|
@ -374,19 +198,6 @@ edje_object_play_get(const Evas_Object *obj)
|
|||
}
|
||||
|
||||
/* FIXDOC: Verify/Expand */
|
||||
/**
|
||||
* @brief Set the object's animation state.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @param on Animation State.
|
||||
*
|
||||
* This function starts or stops an edje object's animation. The
|
||||
* information if it's runnig can be retrieved by
|
||||
* edje_object_animation_get().
|
||||
*
|
||||
* @see edje_object_animation_get()
|
||||
*
|
||||
*/
|
||||
EAPI void
|
||||
edje_object_animation_set(Evas_Object *obj, Eina_Bool on)
|
||||
{
|
||||
|
@ -444,19 +255,6 @@ edje_object_animation_set(Evas_Object *obj, Eina_Bool on)
|
|||
_edje_unblock(ed);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the edje object's animation state.
|
||||
*
|
||||
* @param obj A valid Evas_Object handle.
|
||||
* @return @c EINA_FALSE on error or if object is not animated;
|
||||
* @c EINA_TRUE if animated.
|
||||
*
|
||||
* This function returns if the animation is playing or not. The
|
||||
* animation state is set by edje_object_play_set().
|
||||
*
|
||||
* @see edje_object_animation_set().
|
||||
*
|
||||
*/
|
||||
|
||||
EAPI Eina_Bool
|
||||
edje_object_animation_get(const Evas_Object *obj)
|
||||
|
@ -2160,8 +1958,3 @@ _edje_param_set(Edje_Real_Part *part, const char *param, const char *value)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -18,13 +18,6 @@ Eina_List *_edje_edjes = NULL;
|
|||
|
||||
/************************** API Routines **************************/
|
||||
|
||||
/* FIXDOC: Verify/Expand */
|
||||
/** Constructs the Edje object
|
||||
* @param evas A valid Evas handle
|
||||
* @return The Evas_Object pointer.
|
||||
*
|
||||
* Creates the Edje smart object, returning the Evas_Object handle.
|
||||
*/
|
||||
EAPI Evas_Object *
|
||||
edje_object_add(Evas *evas)
|
||||
{
|
||||
|
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue