static void
_efl_net_dialer_simple_inner_io_error(void *data, const Efl_Event *event)
{
Eo *o = data;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, event->info);
efl_event_callback_call(o, EFL_IO_BUFFERED_STREAM_EVENT_ERROR, event->info);
}
static unsigned char
_handle_event(void *data, int type, void *event)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(data, ECORE_CALLBACK_PASS_ON);
EINA_SAFETY_ON_NULL_RETURN_VAL(event, ECORE_CALLBACK_PASS_ON);
const Efl_Event_Description* translated_event = _translate_event(type);
Eio_Sentry_Data *pd = (Eio_Sentry_Data *)data;
Eio_Monitor_Event *monitor_event = (Eio_Monitor_Event *)event;
Eio_Sentry_Event *event_info = malloc(sizeof(Eio_Sentry_Event));
EINA_SAFETY_ON_NULL_RETURN_VAL(event_info, ECORE_CALLBACK_PASS_ON);
event_info->source = eio_monitor_path_get(monitor_event->monitor);
event_info->trigger = monitor_event->filename;
efl_event_callback_call(pd->object, translated_event, event_info);
// If event was error, we must delete the monitor.
if (type == EIO_MONITOR_ERROR)
eina_hash_del(pd->targets, event_info->source, NULL);
free(event_info);
return ECORE_CALLBACK_PASS_ON;
}
EOLIAN static void
_efl_io_queue_limit_set(Eo *o, Efl_Io_Queue_Data *pd, size_t limit)
{
EINA_SAFETY_ON_TRUE_RETURN(efl_io_closer_closed_get(o));
if (pd->limit == limit) return;
pd->limit = limit;
if (pd->limit == 0) goto end;
_efl_io_queue_adjust(pd);
if (pd->allocated > limit)
_efl_io_queue_realloc(o, pd, limit);
if (pd->position_write > limit)
{
pd->position_write = limit;
if (pd->position_read > limit) pd->position_read = limit;
}
_efl_io_queue_adjust_and_realloc_if_needed(o, pd);
efl_event_callback_call(o, EFL_IO_QUEUE_EVENT_SLICE_CHANGED, NULL);
if (pd->closed) return;
end:
_efl_io_queue_update_cans(o, pd);
}
static void
_efl_io_buffered_stream_error(void *data, const Efl_Event *event)
{
Eo *o = data;
Eina_Error *perr = event->info;
DBG("%p %s error: %s", o, efl_name_get(event->object), eina_error_msg_get(*perr));
efl_event_callback_call(o, EFL_IO_BUFFERED_STREAM_EVENT_ERROR, event->info);
}
static Eina_Bool
_delay_change(void *data)
{
EFL_UI_SLIDER_INTERVAL_DATA_GET(data, pd);
pd->delay = NULL;
efl_event_callback_call(data, EFL_UI_SLIDER_EVENT_DELAY_CHANGED, NULL);
if (_elm_config->atspi_mode)
efl_access_value_changed_signal_emit(data);
return ECORE_CALLBACK_CANCEL;
}
static void
_efl_net_control_technology_property_name_changed(Eo *o, Efl_Net_Control_Technology_Data *pd, Eldbus_Message_Iter *value)
{
const char *name;
if (!eldbus_message_iter_arguments_get(value, "s", &name))
{
ERR("Expected string, got %s", eldbus_message_iter_signature_get(value));
return;
}
if (!eina_stringshare_replace(&pd->name, name)) return;
DBG("name=%s", name);
efl_event_callback_call(o, EFL_NET_CONTROL_TECHNOLOGY_EVENT_CHANGED, NULL);
}
static void
bench_eo_callbacks_call(int request)
{
/* Distribution of calls per amount of callbacks in an object as recorded by
running the genlist elementary_test test. */
const double distribution[] = {
0.2920468197,
0.2073086496,
0.217699456,
0.0207158285,
0.019707134,
0.0359433565,
0.0324896742,
0.0104299639,
0.028989003,
0.0082496801,
0.123214227,
0.0001331351,
0.0030730724
};
const int len = EINA_C_ARRAY_LENGTH(distribution);
int i, j;
Eo *obj[len];
for (i = 0 ; i < len ; i++)
{
obj[i] = efl_add_ref(SIMPLE_CLASS, NULL);
for (j = 0 ; j < i ; j++)
{
efl_event_callback_priority_add(obj[i], SIMPLE_FOO, (short) j, _cb, NULL);
}
}
for (i = 0 ; i < len ; i++)
{
for (j = 0 ; j < (int) (distribution[i] * request) ; j++)
{
/* Miss finding the callbacks on purpose, so we measure worst case scenario. */
efl_event_callback_call(obj[i], SIMPLE_BAR, NULL);
}
}
for (i = 0 ; i < len ; i++)
{
efl_unref(obj[i]);
}
}
static void
_efl_net_control_technology_property_connected_changed(Eo *o, Efl_Net_Control_Technology_Data *pd, Eldbus_Message_Iter *value)
{
Eina_Bool connected;
if (!eldbus_message_iter_arguments_get(value, "b", &connected))
{
ERR("Expected boolean, got %s", eldbus_message_iter_signature_get(value));
return;
}
if (pd->connected == connected) return;
pd->connected = connected;
DBG("connected=%hhu", connected);
efl_event_callback_call(o, EFL_NET_CONTROL_TECHNOLOGY_EVENT_CHANGED, NULL);
}
static void
_efl_net_control_technology_property_type_changed(Eo *o, Efl_Net_Control_Technology_Data *pd, Eldbus_Message_Iter *value)
{
const char *str;
Efl_Net_Control_Technology_Type type;
if (!eldbus_message_iter_arguments_get(value, "s", &str))
{
ERR("Expected string, got %s", eldbus_message_iter_signature_get(value));
return;
}
type = efl_net_connman_technology_type_from_str(str);
if (pd->type == type) return;
pd->type = type;
DBG("type=%d (%s)", type, str);
efl_event_callback_call(o, EFL_NET_CONTROL_TECHNOLOGY_EVENT_CHANGED, NULL);
}
void
_efl_ui_slider_interval_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Interval_Data *pd, Eina_Bool user_event)
{
double posx = 0.0, posy = 0.0, pos = 0.0, val;
double posx2 = 0.0, posy2 = 0.0, pos2 = 0.0, val2;
EFL_UI_SLIDER_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (elm_widget_is_legacy(obj))
efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable.slider"),
&posx, &posy);
else
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable.slider"),
&posx, &posy);
if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) pos = posx;
else pos = posy;
if (elm_widget_is_legacy(obj))
efl_ui_drag_value_get(efl_part(wd->resize_obj, "elm.dragable2.slider"),
&posx2, &posy2);
else
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable2.slider"),
&posx2, &posy2);
if (efl_ui_dir_is_horizontal(sd->dir, EINA_TRUE)) pos2 = posx2;
else pos2 = posy2;
val = (pos * (sd->val_max - sd->val_min)) + sd->val_min;
val2 = (pos2 * (sd->val_max - sd->val_min)) + sd->val_min;
if (val > pd->intvl_to)
{
val = pd->intvl_to;
efl_ui_slider_val_set(obj);
}
else if (val2 < pd->intvl_from)
{
val2 = pd->intvl_from;
efl_ui_slider_val_set(obj);
}
if (fabs(val - pd->intvl_from) > DBL_EPSILON)
{
sd->val = val;
pd->intvl_from = val;
if (user_event)
{
efl_event_callback_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
efl_event_callback_legacy_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
ecore_timer_del(pd->delay);
pd->delay = ecore_timer_add(SLIDER_DELAY_CHANGED_INTERVAL, _delay_change, obj);
}
}
if (fabs(val2 - pd->intvl_to) > DBL_EPSILON)
{
pd->intvl_to = val2;
if (user_event)
{
efl_event_callback_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
efl_event_callback_legacy_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
ecore_timer_del(pd->delay);
pd->delay = ecore_timer_add(SLIDER_DELAY_CHANGED_INTERVAL, _delay_change, obj);
}
}
}
static void
_efl_net_dialer_simple_inner_io_connected(void *data, const Efl_Event *event)
{
Eo *o = data;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, event->info);
}
static void
_efl_net_dialer_simple_inner_io_resolved(void *data, const Efl_Event *event)
{
Eo *o = data;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, event->info);
}