forked from enlightenment/efl
edje: Move signal APIs to an interface
This interface will be used by elm_layout as well. Ref T5315
This commit is contained in:
parent
ad7e16bcf4
commit
efac7d523a
|
@ -3,6 +3,7 @@
|
|||
|
||||
edje_eolian_files = \
|
||||
lib/edje/efl_canvas_layout_calc.eo \
|
||||
lib/edje/efl_canvas_layout_signal.eo \
|
||||
lib/edje/edje_object.eo \
|
||||
lib/edje/efl_canvas_layout_internal.eo \
|
||||
lib/edje/efl_canvas_layout_internal_box.eo \
|
||||
|
|
|
@ -146,7 +146,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
|
|||
elm_box_pack_end(bxr, priv->bt);
|
||||
elm_object_text_set(priv->bt, "update model");
|
||||
evas_object_smart_callback_add(priv->bt, "clicked", _update_cb, priv);
|
||||
edje_obj_signal_callback_add(priv->bt, "test*" , "*", _signal_cb, priv);
|
||||
edje_object_signal_callback_add(priv->bt, "test*" , "*", _signal_cb, priv);
|
||||
efl_ui_model_connect(priv->bt, "signal/test-%v", "size");
|
||||
evas_object_show(priv->bt);
|
||||
|
||||
|
|
|
@ -89,7 +89,8 @@ struct _Edje_Size_Class
|
|||
* @{
|
||||
*/
|
||||
|
||||
typedef void (*Edje_Signal_Cb) (void *data, Evas_Object *obj, const char *emission, const char *source); /**< Edje signal callback functions's prototype definition. @c data will have the auxiliary data pointer set at the time the callback registration. @c obj will be a pointer the Edje object where the signal comes from. @c emission will identify the exact signal's emission string and @c source the exact signal's source one. */
|
||||
typedef void (*Efl_Signal_Cb) (void *data, Evas_Object *obj, const char *emission, const char *source); /**< Edje signal callback functions's prototype definition. @c data will have the auxiliary data pointer set at the time the callback registration. @c obj will be a pointer the Edje object where the signal comes from. @c emission will identify the exact signal's emission string and @c source the exact signal's source one. */
|
||||
typedef Efl_Signal_Cb Edje_Signal_Cb;
|
||||
|
||||
/**
|
||||
* @brief Gets extra data passed to callbacks.
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
#include <Efl.h>
|
||||
|
||||
#include "efl_canvas_layout_calc.eo.h"
|
||||
#include "efl_canvas_layout_signal.eo.h"
|
||||
#include "edje_object.eo.h"
|
||||
#include "edje_edit.eo.h"
|
||||
|
||||
|
|
|
@ -51,6 +51,64 @@
|
|||
*/
|
||||
EAPI Evas_Object *edje_object_add (Evas *evas);
|
||||
|
||||
/**
|
||||
* @brief Adds a callback for an arriving Edje signal, emitted by a given Edje
|
||||
* object.
|
||||
*
|
||||
* Edje signals are one of the communication interfaces between code and a
|
||||
* given Edje object's theme. With signals, one can communicate two string
|
||||
* values at a time, which are: - "emission" value: the name of the signal, in
|
||||
* general - "source" value: a name for the signal's context, in general
|
||||
*
|
||||
* Though there are those common uses for the two strings, one is free to use
|
||||
* them however they like.
|
||||
*
|
||||
* Signal callback registration is powerful, in the way that blobs may be used
|
||||
* to match multiple signals at once. All the "*?[\" set of @c fnmatch()
|
||||
* operators can be used, both for emission and source.
|
||||
*
|
||||
* Edje has internal signals it will emit, automatically, on various actions
|
||||
* taking place on group parts. For example, the mouse cursor being moved,
|
||||
* pressed, released, etc., over a given part's area, all generate individual
|
||||
* signals.
|
||||
*
|
||||
* By using something like edje_object_signal_callback_add(obj, "mouse,down,*",
|
||||
* "button.*", signal_cb, NULL); being @ref "button.*" the pattern for the
|
||||
* names of parts implementing buttons on an interface, you'd be registering
|
||||
* for notifications on events of mouse buttons being pressed down on either of
|
||||
* those parts (those events all have the @"mouse,down," common prefix on their
|
||||
* names, with a suffix giving the button number). The actual emission and
|
||||
* source strings of an event will be passed in as the emission and source
|
||||
* parameters of the callback function (e.g. "mouse,down,2" and
|
||||
* @"button.close"), for each of those events.
|
||||
*
|
||||
* @note See @ref edcref "the syntax" for EDC files See also
|
||||
* @ref edje_object_signal_emit() on how to emits Edje signals from code to a
|
||||
* an object @ref edje_object_signal_callback_del_full()
|
||||
*
|
||||
* @param[in] emission The signal's "emission" string
|
||||
* @param[in] source The signal's "source" string
|
||||
* @param[in] func The callback function to be executed when the signal is
|
||||
* emitted.
|
||||
* @param[in] data A pointer to data to pass in to func.
|
||||
*/
|
||||
EAPI void edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data);
|
||||
|
||||
/**
|
||||
* @brief Sends/emits an Edje signal to a given Edje object
|
||||
*
|
||||
* This function sends a signal to the object obj. An Edje program, at obj's
|
||||
* EDC specification level, can respond to a signal by having declared matching
|
||||
* @'signal' and @'source' fields on its block (see @ref edcref "the syntax"
|
||||
* for EDC files).
|
||||
*
|
||||
* See also @ref edje_object_signal_callback_add() for more on Edje signals.
|
||||
*
|
||||
* @param[in] emission The signal's "emission" string
|
||||
* @param[in] source The signal's "source" string
|
||||
*/
|
||||
EAPI void edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source);
|
||||
|
||||
/**
|
||||
* @brief Removes a signal-triggered callback from an object.
|
||||
*
|
||||
|
|
|
@ -51,14 +51,76 @@ edje_object_part_state_get(const Edje_Object *obj, const char * part, double *va
|
|||
EAPI void
|
||||
edje_object_message_signal_process(Edje_Object *obj)
|
||||
{
|
||||
edje_obj_message_signal_process(obj, EINA_FALSE);
|
||||
efl_canvas_layout_signal_process(obj, EINA_FALSE);
|
||||
}
|
||||
|
||||
/* since 1.20 */
|
||||
EAPI void
|
||||
edje_object_message_signal_recursive_process(Edje_Object *obj)
|
||||
{
|
||||
edje_obj_message_signal_process(obj, EINA_TRUE);
|
||||
efl_canvas_layout_signal_process(obj, EINA_TRUE);
|
||||
}
|
||||
|
||||
EAPI void
|
||||
edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
||||
{
|
||||
efl_canvas_layout_signal_callback_add(obj, emission, source, (Efl_Signal_Cb) func, data);
|
||||
}
|
||||
|
||||
EAPI void *
|
||||
edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
||||
{
|
||||
Edje_Signal_Callback_Group *gp;
|
||||
Edje *ed = _edje_fetch(obj);
|
||||
Eina_Bool ok;
|
||||
|
||||
if (!ed || ed->delete_me) return NULL;
|
||||
|
||||
gp = (Edje_Signal_Callback_Group *) ed->callbacks;
|
||||
if (!gp) return NULL;
|
||||
|
||||
emission = eina_stringshare_add(emission);
|
||||
source = eina_stringshare_add(source);
|
||||
|
||||
ok = _edje_signal_callback_disable(gp, emission, source, func, data);
|
||||
|
||||
// Legacy only
|
||||
if (!ok && !data)
|
||||
{
|
||||
for (unsigned i = 0; i < gp->matches->matches_count; ++i)
|
||||
{
|
||||
if (emission == gp->matches->matches[i].signal &&
|
||||
source == gp->matches->matches[i].source &&
|
||||
func == gp->matches->matches[i].func &&
|
||||
!gp->flags[i].delete_me)
|
||||
{
|
||||
gp->flags[i].delete_me = EINA_TRUE;
|
||||
//return gp->custom_data[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
eina_stringshare_del(emission);
|
||||
eina_stringshare_del(source);
|
||||
|
||||
// Note: This function seems to have returned NULL since ~2013, despite
|
||||
// what the documentation says.
|
||||
return NULL;
|
||||
}
|
||||
|
||||
EAPI void *
|
||||
edje_object_signal_callback_del(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func)
|
||||
{
|
||||
// Legacy del_full seems to have been sloppy with NULL data, as that would
|
||||
// match the first callback found. Keeping this legacy behaviour unchanged.
|
||||
return edje_object_signal_callback_del_full(obj, emission, source, func, NULL);
|
||||
}
|
||||
|
||||
EAPI void
|
||||
edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source)
|
||||
{
|
||||
efl_canvas_layout_signal_emit(obj, emission, source);
|
||||
}
|
||||
|
||||
EAPI Eina_Bool
|
||||
|
|
|
@ -32,7 +32,7 @@ _edje_object_message_propagate_send(Evas_Object *obj, Edje_Message_Type type, in
|
|||
}
|
||||
|
||||
EOLIAN void
|
||||
_edje_object_message_send(Eo *obj, Edje *pd EINA_UNUSED, int id, const Eina_Value val)
|
||||
_edje_object_efl_canvas_layout_signal_message_send(Eo *obj, Edje *pd EINA_UNUSED, int id, const Eina_Value val)
|
||||
{
|
||||
const Eina_Value_Type *valtype;
|
||||
Edje_Message_Type msgtype;
|
||||
|
@ -228,22 +228,17 @@ end:
|
|||
}
|
||||
|
||||
EOLIAN void
|
||||
_edje_object_message_signal_process(Eo *obj, Edje *ed, Eina_Bool recurse)
|
||||
_edje_object_efl_canvas_layout_signal_signal_process(Eo *obj, Edje *ed, Eina_Bool recurse)
|
||||
{
|
||||
Edje *sub_ed;
|
||||
Eina_List *l;
|
||||
Evas_Object *o;
|
||||
|
||||
if (ed->delete_me) return;
|
||||
_edje_object_message_signal_process_do(obj, ed);
|
||||
if (!recurse) return;
|
||||
|
||||
EINA_LIST_FOREACH(ed->subobjs, l, o)
|
||||
{
|
||||
sub_ed = _edje_fetch(o);
|
||||
if (!sub_ed) continue;
|
||||
|
||||
_edje_object_message_signal_process(o, sub_ed, EINA_TRUE);
|
||||
}
|
||||
efl_canvas_layout_signal_process(o, EINA_TRUE);
|
||||
}
|
||||
|
||||
static Eina_Bool
|
||||
|
|
|
@ -3,7 +3,8 @@ import edje_types;
|
|||
// FIXME: This EO doc needs a direct link to the "edcref" doc
|
||||
|
||||
class Edje.Object (Efl.Canvas.Group.Clipped, Efl.File, Efl.Container, Efl.Part,
|
||||
Efl.Observer, Efl.Ui.Base, Efl.Canvas.Layout_Calc)
|
||||
Efl.Observer, Efl.Ui.Base, Efl.Canvas.Layout_Calc,
|
||||
Efl.Canvas.Layout_Signal)
|
||||
{
|
||||
[[Edje object class]]
|
||||
legacy_prefix: edje_object;
|
||||
|
@ -238,154 +239,6 @@ class Edje.Object (Efl.Canvas.Group.Clipped, Efl.File, Efl.Container, Efl.Part,
|
|||
}
|
||||
/* EDJE GROUP DATA APIS END ------------------------------------------ */
|
||||
|
||||
/* MESSAGE & SIGNAL APIS BEGIN --------------------------------------- */
|
||||
message_send {
|
||||
[[Sends an (Edje) message to a given Edje object
|
||||
|
||||
This function sends an Edje message to obj and to all of its
|
||||
child objects, if it has any (swallowed objects are one kind of
|
||||
child object). Only a few types are supported:
|
||||
- int,
|
||||
- float/double,
|
||||
- string/stringshare,
|
||||
- arrays of int, float, double or strings.
|
||||
|
||||
The id argument as a form of code and theme defining a common
|
||||
interface on message communication. One should define the same IDs
|
||||
on both code and EDC declaration, to individualize messages
|
||||
(binding them to a given context).
|
||||
]]
|
||||
params {
|
||||
@in id: int; [[A identification number for the message to be sent]]
|
||||
@in msg: const(generic_value); [[The message's payload]]
|
||||
}
|
||||
legacy: null;
|
||||
}
|
||||
signal_callback_add {
|
||||
[[Adds a callback for an arriving Edje signal, emitted by
|
||||
a given Edje object.
|
||||
|
||||
Edje signals are one of the communication interfaces between
|
||||
code and a given Edje object's theme. With signals, one can
|
||||
communicate two string values at a time, which are:
|
||||
- "emission" value: the name of the signal, in general
|
||||
- "source" value: a name for the signal's context, in general
|
||||
|
||||
Though there are those common uses for the two strings, one is free
|
||||
to use them however they like.
|
||||
|
||||
Signal callback registration is powerful, in the way that blobs
|
||||
may be used to match multiple signals at once. All the
|
||||
"*?[\" set of $fnmatch() operators can be used, both for
|
||||
emission and source.
|
||||
|
||||
Edje has internal signals it will emit, automatically, on
|
||||
various actions taking place on group parts. For example, the mouse
|
||||
cursor being moved, pressed, released, etc., over a given part's
|
||||
area, all generate individual signals.
|
||||
|
||||
By using something like
|
||||
edje_object_signal_callback_add(obj, "mouse,down,*", "button.*",
|
||||
signal_cb, NULL);
|
||||
being \@ref "button.*" the pattern for the names of parts implementing
|
||||
buttons on an interface, you'd be registering for notifications on
|
||||
events of mouse buttons being pressed down on either of those parts
|
||||
(those events all have the @"mouse,down," common prefix on their
|
||||
names, with a suffix giving the button number). The actual emission
|
||||
and source strings of an event will be passed in as the emission
|
||||
and source parameters of the callback function (e.g.
|
||||
"mouse,down,2" and @"button.close"), for each of those events.
|
||||
|
||||
Note: See \@ref edcref "the syntax" for EDC files
|
||||
See also @.signal_emit() on how to emits Edje signals from
|
||||
code to a an object
|
||||
\@ref edje_object_signal_callback_del_full()]]
|
||||
/* FIXME-doc
|
||||
* This function adds a callback function to a signal emitted by obj, to
|
||||
* be issued every time an EDC program like the following
|
||||
* @code
|
||||
* program
|
||||
* {
|
||||
* name: "emit_example";
|
||||
* action: SIGNAL_EMIT "a_signal" "a_source";
|
||||
* }
|
||||
* @endcode
|
||||
* is run, if emission and source are given those same values,
|
||||
* here.
|
||||
*/
|
||||
|
||||
params {
|
||||
@in emission: string; [[The signal's "emission" string]]
|
||||
@in source: string; [[The signal's "source" string]]
|
||||
@in func: Edje.Signal_Cb; [[The callback function to be executed when the signal is
|
||||
emitted.]]
|
||||
@in data: void_ptr; [[A pointer to data to pass in to func.]]
|
||||
}
|
||||
}
|
||||
signal_callback_del {
|
||||
[[Removes a signal-triggered callback from an object.
|
||||
|
||||
This function removes a callback, previously attached to the
|
||||
emission of a signal, from the object obj. The parameters
|
||||
emission, source and 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 also @.signal_callback_add().
|
||||
\@ref edje_object_signal_callback_del_full().]]
|
||||
|
||||
legacy: null;
|
||||
return: void_ptr; [[The data pointer]]
|
||||
params {
|
||||
@in emission: string; [[The emission string.]]
|
||||
@in source: string; [[The source string.]]
|
||||
@in func: Edje.Signal_Cb; [[The callback function.]]
|
||||
@in data: void_ptr; [[The callback function.]]
|
||||
}
|
||||
}
|
||||
signal_emit {
|
||||
[[Sends/emits an Edje signal to a given Edje object
|
||||
|
||||
This function sends a signal to the object obj. An Edje program,
|
||||
at obj's EDC specification level, can respond to a signal by
|
||||
having declared matching @'signal' and @'source' fields on its
|
||||
block (see \@ref edcref "the syntax" for EDC files).
|
||||
|
||||
See also @.signal_callback_add() for more on Edje signals.]]
|
||||
/* FIXME-doc
|
||||
* @code
|
||||
* program
|
||||
* {
|
||||
* name: "a_program";
|
||||
* signal: "a_signal";
|
||||
* source: "";
|
||||
* action: ...
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
params {
|
||||
@in emission: string; [[The signal's "emission" string]]
|
||||
@in source: string; [[The signal's "source" string]]
|
||||
}
|
||||
}
|
||||
message_signal_process {
|
||||
[[Processes an object's message queue.
|
||||
|
||||
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.
|
||||
|
||||
If $recurse is $true, this function will be called recursively
|
||||
on all subobjects.
|
||||
]]
|
||||
params {
|
||||
recurse: bool @optional; [[Whether to process messages on children
|
||||
objects.]]
|
||||
}
|
||||
legacy: null;
|
||||
}
|
||||
/* MESSAGE & SIGNAL APIS END ----------------------------------------- */
|
||||
|
||||
/* CLASS APIS BEGIN -------------------------------------------------- */
|
||||
@property global_color_class @class {
|
||||
set {
|
||||
|
@ -1060,6 +913,11 @@ class Edje.Object (Efl.Canvas.Group.Clipped, Efl.File, Efl.Container, Efl.Part,
|
|||
Efl.Canvas.Layout_Calc.calc_freeze;
|
||||
Efl.Canvas.Layout_Calc.calc_thaw;
|
||||
Efl.Canvas.Layout_Calc.calc_force;
|
||||
Efl.Canvas.Layout_Signal.message_send;
|
||||
Efl.Canvas.Layout_Signal.signal_callback_add;
|
||||
Efl.Canvas.Layout_Signal.signal_callback_del;
|
||||
Efl.Canvas.Layout_Signal.signal_emit;
|
||||
Efl.Canvas.Layout_Signal.signal_process;
|
||||
Efl.Ui.Base.mirrored { set; get; }
|
||||
Efl.Ui.Base.language { set; get; }
|
||||
Efl.Ui.Base.scale { set; get; }
|
||||
|
|
|
@ -2469,13 +2469,13 @@ void _edje_callbacks_focus_del(Evas_Object *obj, Edje *ed);
|
|||
|
||||
const Edje_Signal_Callback_Group *_edje_signal_callback_alloc(void);
|
||||
void _edje_signal_callback_free(const Edje_Signal_Callback_Group *cgp);
|
||||
void _edje_signal_callback_push(const Edje_Signal_Callback_Group *cgp,
|
||||
const char *signal, const char *source,
|
||||
Edje_Signal_Cb func, void *data,
|
||||
Eina_Bool propagate);
|
||||
void *_edje_signal_callback_disable(const Edje_Signal_Callback_Group *cgp,
|
||||
const char *signal, const char *source,
|
||||
Edje_Signal_Cb func, void *data);
|
||||
Eina_Bool _edje_signal_callback_push(Edje_Signal_Callback_Group *cgp,
|
||||
const char *signal, const char *source,
|
||||
Edje_Signal_Cb func, void *data,
|
||||
Eina_Bool propagate);
|
||||
Eina_Bool _edje_signal_callback_disable(Edje_Signal_Callback_Group *cgp,
|
||||
const char *signal, const char *source,
|
||||
Edje_Signal_Cb func, void *data);
|
||||
|
||||
EAPI void _edje_edd_init(void);
|
||||
EAPI void _edje_edd_shutdown(void);
|
||||
|
|
|
@ -226,102 +226,75 @@ _edje_object_transition_duration_factor_get(Eo *obj EINA_UNUSED, Edje *pd)
|
|||
return pd->duration_scale;
|
||||
}
|
||||
|
||||
void
|
||||
edje_object_propagate_callback_add(Evas_Object *obj, void (*func)(void *data, Evas_Object *o, const char *emission, const char *source), void *data)
|
||||
static inline Eina_Bool
|
||||
_edje_object_signal_callback_add(Edje *ed, const char *emission, const char *source, Efl_Signal_Cb func, void *data)
|
||||
{
|
||||
Edje_Signal_Callback_Group *gp;
|
||||
const char *sig;
|
||||
const char *src;
|
||||
Edje *ed;
|
||||
|
||||
ed = _edje_fetch(obj);
|
||||
if (!ed) return;
|
||||
if (ed->delete_me) return;
|
||||
Eina_Bool ok;
|
||||
|
||||
if (!ed->callbacks)
|
||||
ed->callbacks = _edje_signal_callback_alloc();
|
||||
if (!ed->callbacks) return;
|
||||
if (!ed->callbacks) return EINA_FALSE;
|
||||
|
||||
sig = eina_stringshare_add("*");
|
||||
src = eina_stringshare_add("*");
|
||||
sig = eina_stringshare_add(emission);
|
||||
src = eina_stringshare_add(source);
|
||||
|
||||
if (ed->callbacks)
|
||||
_edje_signal_callback_push(ed->callbacks,
|
||||
sig, src,
|
||||
func, data,
|
||||
EINA_TRUE);
|
||||
gp = (Edje_Signal_Callback_Group *) ed->callbacks;
|
||||
ok = _edje_signal_callback_push(gp, sig, src, func, data, EINA_TRUE);
|
||||
|
||||
eina_stringshare_del(sig);
|
||||
eina_stringshare_del(src);
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
void
|
||||
edje_object_propagate_callback_add(Evas_Object *obj, Efl_Signal_Cb func, void *data)
|
||||
{
|
||||
Edje *ed;
|
||||
|
||||
ed = _edje_fetch(obj);
|
||||
if (!ed || ed->delete_me) return;
|
||||
_edje_object_signal_callback_add(ed, "*", "*", func, data);
|
||||
}
|
||||
|
||||
EOLIAN Eina_Bool
|
||||
_edje_object_efl_canvas_layout_signal_signal_callback_add(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source, Efl_Signal_Cb func, void *data)
|
||||
{
|
||||
return _edje_object_signal_callback_add(ed, emission, source, func, data);
|
||||
}
|
||||
|
||||
EOLIAN Eina_Bool
|
||||
_edje_object_efl_canvas_layout_signal_signal_callback_del(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source, Efl_Signal_Cb func, void *data)
|
||||
{
|
||||
Edje_Signal_Callback_Group *gp;
|
||||
Eina_Bool ok;
|
||||
|
||||
if (ed->delete_me) return EINA_FALSE;
|
||||
if ((!emission) || (!source) || (!func)) return EINA_FALSE;
|
||||
|
||||
gp = (Edje_Signal_Callback_Group *) ed->callbacks;
|
||||
if (!gp) return EINA_FALSE;
|
||||
|
||||
emission = eina_stringshare_add(emission);
|
||||
source = eina_stringshare_add(source);
|
||||
|
||||
ok = _edje_signal_callback_disable(gp, emission, source, func, data);
|
||||
|
||||
eina_stringshare_del(emission);
|
||||
eina_stringshare_del(source);
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
EOLIAN void
|
||||
_edje_object_signal_callback_add(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
||||
_edje_object_efl_canvas_layout_signal_signal_emit(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source)
|
||||
{
|
||||
if ((!emission) || (!source) || (!func)) return;
|
||||
|
||||
if (!ed) return;
|
||||
if (ed->delete_me) return;
|
||||
|
||||
emission = eina_stringshare_add(emission);
|
||||
source = eina_stringshare_add(source);
|
||||
|
||||
if (!ed->callbacks)
|
||||
ed->callbacks = _edje_signal_callback_alloc();
|
||||
if (!ed->callbacks) return;
|
||||
|
||||
_edje_signal_callback_push(ed->callbacks,
|
||||
emission, source,
|
||||
func, data, EINA_FALSE);
|
||||
|
||||
eina_stringshare_del(emission);
|
||||
eina_stringshare_del(source);
|
||||
}
|
||||
|
||||
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))
|
||||
{
|
||||
if (!obj) return NULL;
|
||||
void *ret = NULL;
|
||||
ret = edje_obj_signal_callback_del(obj, emission, source, (Edje_Signal_Cb)func, NULL);
|
||||
return ret;
|
||||
}
|
||||
|
||||
EOLIAN void *
|
||||
_edje_object_signal_callback_del(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
||||
{
|
||||
if ((!emission) || (!source) || (!func)) return NULL;
|
||||
if (!ed) return NULL;
|
||||
if (ed->delete_me) return NULL;
|
||||
|
||||
emission = eina_stringshare_add(emission);
|
||||
source = eina_stringshare_add(source);
|
||||
|
||||
_edje_signal_callback_disable(ed->callbacks,
|
||||
emission, source,
|
||||
func, data);
|
||||
|
||||
eina_stringshare_del(emission);
|
||||
eina_stringshare_del(source);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
EAPI void *
|
||||
edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data)
|
||||
{
|
||||
if (!obj) return NULL;
|
||||
void *ret = NULL;
|
||||
ret = edje_obj_signal_callback_del(obj, emission, source, func, data);
|
||||
return ret;
|
||||
}
|
||||
|
||||
EOLIAN void
|
||||
_edje_object_signal_emit(Eo *obj EINA_UNUSED, Edje *ed, const char *emission, const char *source)
|
||||
{
|
||||
if ((!emission) || (!source)) return;
|
||||
if (!ed) return;
|
||||
if (ed->delete_me) return;
|
||||
_edje_emit(ed, (char *)emission, (char *)source);
|
||||
_edje_emit(ed, emission, source);
|
||||
}
|
||||
|
||||
/* FIXDOC: Verify/Expand */
|
||||
|
|
|
@ -169,12 +169,11 @@ _edje_signal_callback_grow(Edje_Signal_Callback_Group *gp)
|
|||
return gp;
|
||||
}
|
||||
|
||||
void
|
||||
_edje_signal_callback_push(const Edje_Signal_Callback_Group *cgp,
|
||||
Eina_Bool
|
||||
_edje_signal_callback_push(Edje_Signal_Callback_Group *gp,
|
||||
const char *sig, const char *src,
|
||||
Edje_Signal_Cb func, void *data, Eina_Bool propagate)
|
||||
{
|
||||
Edje_Signal_Callback_Group *gp = (Edje_Signal_Callback_Group *)cgp;
|
||||
unsigned int i;
|
||||
Edje_Signal_Callback_Flags flags;
|
||||
Edje_Signal_Callback_Matches *tmp;
|
||||
|
@ -195,7 +194,7 @@ _edje_signal_callback_push(const Edje_Signal_Callback_Group *cgp,
|
|||
{
|
||||
_edje_signal_callback_unset(gp, i);
|
||||
_edje_signal_callback_set(gp, i, sig, src, func, data, flags);
|
||||
return;
|
||||
return EINA_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -211,7 +210,7 @@ _edje_signal_callback_push(const Edje_Signal_Callback_Group *cgp,
|
|||
Edje_Signal_Callback_Matches *tmp_dup =
|
||||
(Edje_Signal_Callback_Matches *)
|
||||
_edje_signal_callback_matches_dup(tmp);
|
||||
if (!tmp_dup) return;
|
||||
if (!tmp_dup) return EINA_FALSE;
|
||||
EINA_REFCOUNT_UNREF(tmp)
|
||||
(void) 0; // do nothing because if refcount == 1 handle above.
|
||||
gp->matches = tmp = tmp_dup;
|
||||
|
@ -226,7 +225,7 @@ _edje_signal_callback_push(const Edje_Signal_Callback_Group *cgp,
|
|||
{
|
||||
_edje_signal_callback_unset(gp, i);
|
||||
_edje_signal_callback_set(gp, i, sig, src, func, data, flags);
|
||||
return;
|
||||
return EINA_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -234,6 +233,8 @@ _edje_signal_callback_push(const Edje_Signal_Callback_Group *cgp,
|
|||
// Set propagate and just_added flags
|
||||
_edje_signal_callback_set(gp, tmp->matches_count - 1,
|
||||
sig, src, func, data, flags);
|
||||
|
||||
return EINA_TRUE;
|
||||
}
|
||||
|
||||
const Edje_Signal_Callback_Group *
|
||||
|
@ -300,17 +301,15 @@ _edje_signal_callback_free(const Edje_Signal_Callback_Group *cgp)
|
|||
free(gp);
|
||||
}
|
||||
|
||||
void *
|
||||
_edje_signal_callback_disable(const Edje_Signal_Callback_Group *cgp,
|
||||
Eina_Bool
|
||||
_edje_signal_callback_disable(Edje_Signal_Callback_Group *gp,
|
||||
const char *sig, const char *src,
|
||||
Edje_Signal_Cb func, void *data)
|
||||
{
|
||||
Edje_Signal_Callback_Group *gp = (Edje_Signal_Callback_Group *)cgp;
|
||||
unsigned int i;
|
||||
|
||||
if (!gp || !gp->matches) return NULL;
|
||||
if (!gp || !gp->matches) return EINA_FALSE;
|
||||
|
||||
// FIXME: Shall we check DELETE_ME flags ?
|
||||
for (i = 0; i < gp->matches->matches_count; ++i)
|
||||
{
|
||||
if (sig == gp->matches->matches[i].signal &&
|
||||
|
@ -320,26 +319,12 @@ _edje_signal_callback_disable(const Edje_Signal_Callback_Group *cgp,
|
|||
!gp->flags[i].delete_me)
|
||||
{
|
||||
gp->flags[i].delete_me = EINA_TRUE;
|
||||
return gp->custom_data[i];
|
||||
//return gp->custom_data[i];
|
||||
return EINA_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
if (data == NULL)
|
||||
{
|
||||
for (i = 0; i < gp->matches->matches_count; ++i)
|
||||
{
|
||||
if (sig == gp->matches->matches[i].signal &&
|
||||
src == gp->matches->matches[i].source &&
|
||||
func == gp->matches->matches[i].func &&
|
||||
!gp->flags[i].delete_me)
|
||||
{
|
||||
gp->flags[i].delete_me = EINA_TRUE;
|
||||
return gp->custom_data[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
|
@ -562,3 +562,4 @@ _edje_object_efl_observer_update(Eo *obj EINA_UNUSED, Edje *ed, Efl_Object *obs,
|
|||
|
||||
#include "edje_object.eo.c"
|
||||
#include "efl_canvas_layout_calc.eo.c"
|
||||
#include "efl_canvas_layout_signal.eo.c"
|
||||
|
|
|
@ -0,0 +1,146 @@
|
|||
/*
|
||||
Edje signaling interface.
|
||||
|
||||
Note: This API must be manually bound in other languages as this uses function
|
||||
pointers! This is by design, to keep the API simplhe API simple.
|
||||
|
||||
If function pointers really become allowed in EO this needs to be altered to
|
||||
match that.
|
||||
*/
|
||||
|
||||
//type Edje.Signal_Cb: __undefined_type; [[Edje signal callback type]]
|
||||
|
||||
type Efl.Signal_Cb: __undefined_type; [[Signal callback.]]
|
||||
|
||||
interface Efl.Canvas.Layout_Signal
|
||||
{
|
||||
[[Layouts asynchronous messaging and signaling interface.
|
||||
|
||||
@since 1.21
|
||||
]]
|
||||
methods {
|
||||
// FIXME: There is no message_handler in EO!
|
||||
message_send {
|
||||
[[Sends an (Edje) message to a given Edje object
|
||||
|
||||
This function sends an Edje message to obj and to all of its child
|
||||
objects, if it has any (swallowed objects are one kind of child
|
||||
object). Only a few types are supported:
|
||||
- int,
|
||||
- float/double,
|
||||
- string/stringshare,
|
||||
- arrays of int, float, double or strings.
|
||||
|
||||
Messages can go both ways, from code to theme, or theme to code.
|
||||
|
||||
The id argument as a form of code and theme defining a common
|
||||
interface on message communication. One should define the same IDs on
|
||||
both code and EDC declaration, to individualize messages (binding
|
||||
them to a given context).
|
||||
]]
|
||||
params {
|
||||
@in id: int; [[A identification number for the message to be sent]]
|
||||
@in msg: const(generic_value); [[The message's payload]]
|
||||
}
|
||||
}
|
||||
signal_callback_add {
|
||||
[[Adds a callback for an arriving Edje signal, emitted by
|
||||
a given Edje object.
|
||||
|
||||
Edje signals are one of the communication interfaces between code and
|
||||
a given Edje object's theme. With signals, one can communicate two
|
||||
string values at a time, which are:
|
||||
- "emission" value: the name of the signal, in general
|
||||
- "source" value: a name for the signal's context, in general
|
||||
|
||||
Signals can go both ways, from code to theme, or theme to code.
|
||||
|
||||
Though there are those common uses for the two strings, one is free
|
||||
to use them however they like.
|
||||
|
||||
Signal callback registration is powerful, in the way that blobs may
|
||||
be used to match multiple signals at once. All the "*?[\" set of
|
||||
$fnmatch() operators can be used, both for emission and source.
|
||||
|
||||
Edje has internal signals it will emit, automatically, on various
|
||||
actions taking place on group parts. For example, the mouse cursor
|
||||
being moved, pressed, released, etc., over a given part's area, all
|
||||
generate individual signals.
|
||||
|
||||
With something like emission = "mouse,down,*", source = "button.*"
|
||||
where "button.*" is the pattern for the names of parts implementing
|
||||
buttons on an interface, you'd be registering for notifications on
|
||||
events of mouse buttons being pressed down on either of those parts
|
||||
(those events all have the "mouse,down," common prefix on their
|
||||
names, with a suffix giving the button number). The actual emission
|
||||
and source strings of an event will be passed in as the emission and
|
||||
source parameters of the callback function (e.g. "mouse,down,2" and
|
||||
"button.close"), for each of those events.
|
||||
|
||||
See also the Edje Data Collection Reference for EDC files.
|
||||
|
||||
See @.signal_emit on how to emit signals from code to a an object
|
||||
See @.signal_callback_del.
|
||||
]]
|
||||
params {
|
||||
@in emission: string; [[The signal's "emission" string]]
|
||||
@in source: string; [[The signal's "source" string]]
|
||||
@in func: Efl.Signal_Cb;
|
||||
[[The callback function to be executed when the signal is emitted.]]
|
||||
@in data: void_ptr; [[A pointer to data to pass to $func.]]
|
||||
}
|
||||
return: bool; [[$true in case of success, $false in case of error.]]
|
||||
}
|
||||
signal_callback_del {
|
||||
[[Removes a signal-triggered callback from an object.
|
||||
|
||||
This function removes a callback, previously attached to the emission
|
||||
of a signal, from the object obj. The parameters emission, source
|
||||
and func must match exactly those passed to a previous call to
|
||||
@.signal_callback_add().
|
||||
|
||||
See @.signal_callback_add.
|
||||
]]
|
||||
params {
|
||||
@in emission: string; [[The signal's "emission" string]]
|
||||
@in source: string; [[The signal's "source" string]]
|
||||
@in func: Efl.Signal_Cb;
|
||||
[[The callback function to be executed when the signal is emitted.]]
|
||||
@in data: void_ptr; [[A pointer to data to pass to $func.]]
|
||||
}
|
||||
return: bool; [[$true in case of success, $false in case of error.]]
|
||||
}
|
||||
signal_emit {
|
||||
[[Sends/emits an Edje signal to this layout.
|
||||
|
||||
This function sends a signal to the object. An Edje program, at the
|
||||
EDC specification level, can respond to a signal by having declared
|
||||
matching "signal" and "source" fields on its block.
|
||||
|
||||
See also the Edje Data Collection Reference for EDC files.
|
||||
|
||||
See @.signal_callback_add() for more on Edje signals.
|
||||
]]
|
||||
params {
|
||||
@in emission: string; [[The signal's "emission" string]]
|
||||
@in source: string; [[The signal's "source" string]]
|
||||
}
|
||||
}
|
||||
signal_process {
|
||||
[[Processes an object's messages and signals queue.
|
||||
|
||||
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.
|
||||
|
||||
If $recurse is $true, this function will be called recursively on all
|
||||
subobjects.
|
||||
]]
|
||||
// FIXME: Should be $true by default!
|
||||
params {
|
||||
recurse: bool @optional; [[Whether to process messages on children
|
||||
objects.]]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -828,7 +828,7 @@ START_TEST(edje_test_message_send_eo)
|
|||
|
||||
eina_value_setup(&v, EINA_VALUE_TYPE_STRING);
|
||||
eina_value_set(&v, "hello world");
|
||||
edje_obj_message_send(obj, 0, v);
|
||||
efl_canvas_layout_signal_message_send(obj, 0, v);
|
||||
eina_value_flush(&v);
|
||||
edje_message_signal_process();
|
||||
edje_object_calc_force(obj);
|
||||
|
@ -836,7 +836,7 @@ START_TEST(edje_test_message_send_eo)
|
|||
|
||||
eina_value_setup(&v, EINA_VALUE_TYPE_INT);
|
||||
eina_value_set(&v, 42);
|
||||
edje_obj_message_send(obj, 1, v);
|
||||
efl_canvas_layout_signal_message_send(obj, 1, v);
|
||||
eina_value_flush(&v);
|
||||
edje_message_signal_process();
|
||||
edje_object_calc_force(obj);
|
||||
|
@ -844,7 +844,7 @@ START_TEST(edje_test_message_send_eo)
|
|||
|
||||
eina_value_setup(&v, EINA_VALUE_TYPE_FLOAT);
|
||||
eina_value_set(&v, 0.12);
|
||||
edje_obj_message_send(obj, 2, v);
|
||||
efl_canvas_layout_signal_message_send(obj, 2, v);
|
||||
eina_value_flush(&v);
|
||||
edje_message_signal_process();
|
||||
edje_object_calc_force(obj);
|
||||
|
@ -855,7 +855,7 @@ START_TEST(edje_test_message_send_eo)
|
|||
eina_value_array_append(va, 12);
|
||||
eina_value_array_append(va, 42);
|
||||
eina_value_array_append(va, 255);
|
||||
edje_obj_message_send(obj, 3, *va);
|
||||
efl_canvas_layout_signal_message_send(obj, 3, *va);
|
||||
eina_value_free(va);
|
||||
edje_message_signal_process();
|
||||
edje_object_calc_force(obj);
|
||||
|
|
|
@ -434,7 +434,7 @@ video_obj_signal_play_cb(void *data, Evas_Object *o, const char *emission EINA_U
|
|||
{
|
||||
Evas_Object *ov = data;
|
||||
emotion_object_play_set(ov, EINA_TRUE);
|
||||
edje_obj_signal_emit(o, "video_state", "play");
|
||||
efl_canvas_layout_signal_emit(o, "video_state", "play");
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -442,7 +442,7 @@ video_obj_signal_pause_cb(void *data, Evas_Object *o, const char *emission EINA_
|
|||
{
|
||||
Evas_Object *ov = data;
|
||||
emotion_object_play_set(ov, EINA_FALSE);
|
||||
edje_obj_signal_emit(o, "video_state", "pause");
|
||||
efl_canvas_layout_signal_emit(o, "video_state", "pause");
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -451,7 +451,7 @@ video_obj_signal_stop_cb(void *data, Evas_Object *o, const char *emission EINA_U
|
|||
Evas_Object *ov = data;
|
||||
emotion_object_play_set(ov, EINA_FALSE);
|
||||
emotion_object_position_set(ov, 0.0);
|
||||
edje_obj_signal_emit(o, "video_state", "stop");
|
||||
efl_canvas_layout_signal_emit(o, "video_state", "stop");
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -630,22 +630,22 @@ init_video_object(const char *module_filename, const char *filename)
|
|||
|
||||
efl_event_callback_array_add(o, emotion_object_test_callbacks(), oe);
|
||||
|
||||
edje_obj_signal_callback_add(oe, "video_control", "play", video_obj_signal_play_cb, o);
|
||||
edje_obj_signal_callback_add(oe, "video_control", "pause", video_obj_signal_pause_cb, o);
|
||||
edje_obj_signal_callback_add(oe, "video_control", "stop", video_obj_signal_stop_cb, o);
|
||||
edje_obj_signal_callback_add(oe, "drag", "video_progress", video_obj_signal_jump_cb, o);
|
||||
edje_obj_signal_callback_add(oe, "drag", "video_alpha", video_obj_signal_alpha_cb, o);
|
||||
edje_obj_signal_callback_add(oe, "drag", "video_volume", video_obj_signal_vol_cb, o);
|
||||
edje_obj_signal_callback_add(oe, "frame_move", "start", video_obj_signal_frame_move_start_cb, oe);
|
||||
edje_obj_signal_callback_add(oe, "frame_move", "stop", video_obj_signal_frame_move_stop_cb, oe);
|
||||
edje_obj_signal_callback_add(oe, "frame_resize", "start", video_obj_signal_frame_resize_start_cb, oe);
|
||||
edje_obj_signal_callback_add(oe, "frame_resize", "stop", video_obj_signal_frame_resize_stop_cb, oe);
|
||||
edje_obj_signal_callback_add(oe, "mouse, move", "*", video_obj_signal_frame_move_cb, oe);
|
||||
efl_canvas_layout_signal_callback_add(oe, "video_control", "play", video_obj_signal_play_cb, o);
|
||||
efl_canvas_layout_signal_callback_add(oe, "video_control", "pause", video_obj_signal_pause_cb, o);
|
||||
efl_canvas_layout_signal_callback_add(oe, "video_control", "stop", video_obj_signal_stop_cb, o);
|
||||
efl_canvas_layout_signal_callback_add(oe, "drag", "video_progress", video_obj_signal_jump_cb, o);
|
||||
efl_canvas_layout_signal_callback_add(oe, "drag", "video_alpha", video_obj_signal_alpha_cb, o);
|
||||
efl_canvas_layout_signal_callback_add(oe, "drag", "video_volume", video_obj_signal_vol_cb, o);
|
||||
efl_canvas_layout_signal_callback_add(oe, "frame_move", "start", video_obj_signal_frame_move_start_cb, oe);
|
||||
efl_canvas_layout_signal_callback_add(oe, "frame_move", "stop", video_obj_signal_frame_move_stop_cb, oe);
|
||||
efl_canvas_layout_signal_callback_add(oe, "frame_resize", "start", video_obj_signal_frame_resize_start_cb, oe);
|
||||
efl_canvas_layout_signal_callback_add(oe, "frame_resize", "stop", video_obj_signal_frame_resize_stop_cb, oe);
|
||||
efl_canvas_layout_signal_callback_add(oe, "mouse, move", "*", video_obj_signal_frame_move_cb, oe);
|
||||
efl_ui_drag_value_set(efl_part(oe, "video_alpha"), 0.0, 1.0);
|
||||
efl_text_set(efl_part(oe, "video_alpha_txt"), "alpha 255");
|
||||
efl_ui_drag_value_set(efl_part(oe, "video_volume"), 0.0, 0.5);
|
||||
efl_text_set(efl_part(oe, "video_volume_txt"), "vol 0.50");
|
||||
edje_obj_signal_emit(oe, "video_state", "play");
|
||||
efl_canvas_layout_signal_emit(oe, "video_state", "play");
|
||||
efl_gfx_visible_set(oe, EINA_TRUE);
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue