kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into devs/hermet/lottie

This commit is contained in:
Hermet Park 2019-09-19 10:29:22 +09:00
parent 8f1010c288 1f19af7780
commit cf210149bc
87 changed files with 607 additions and 419 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/elementary/test_datetime.c
View File

@ -31,7 +31,7 @@ _bt_clicked(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUS
new_time.tm_sec = 0;
elm_datetime_field_visible_set(dt1, ELM_DATETIME_HOUR, EINA_TRUE);
elm_datetime_field_visible_set(dt1, ELM_DATETIME_MINUTE, EINA_TRUE);
efl_ui_clock_pause_set(dt1, EINA_TRUE);
elm_clock_pause_set(dt1, EINA_TRUE);
elm_datetime_value_set(dt1, &new_time);
elm_object_disabled_set(dt1, EINA_TRUE);
elm_object_disabled_set(obj, EINA_TRUE);

1
src/bin/elementary/test_ui_box_stack.c
View File

@ -2,6 +2,7 @@
#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#include <Efl_Ui.h>
#include <Elementary.h>
void

4
src/bin/elementary/test_ui_collection.c
View File

@ -305,10 +305,6 @@ void create_item_container_ui(const Efl_Class *collection_class, const Efl_Class
efl_ui_radio_state_value_set(efl_added, EFL_UI_SELECT_MODE_SINGLE));
efl_text_set(o, "Singleselect");
efl_pack_end(bx, o);
o = efl_add(EFL_UI_RADIO_CLASS, bx,
efl_ui_radio_state_value_set(efl_added, EFL_UI_SELECT_MODE_SINGLE_ALWAYS));
efl_text_set(o, "Singleselect Always");
efl_pack_end(bx, o);
o = efl_add(EFL_UI_RADIO_CLASS, bx,
efl_ui_radio_state_value_set(efl_added, EFL_UI_SELECT_MODE_MULTI));
efl_text_set(o, "Multiselect");

5
src/bin/elementary/test_ui_image.c
View File

@ -73,7 +73,7 @@ test_ui_image(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *event_info EIN
efl_key_data_set(win, "rdg", box);
im = img_add(win, "/images/logo.png");
efl_content_set(win, im);
efl_pack(box, im);
for (i = 0; images_orient[i].name; ++i)
{
@ -152,7 +152,7 @@ test_ui_image_scale_type(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *eve
elm_image_file_set(im, buf, NULL);
efl_gfx_hint_weight_set(im, 1.0, 1.0);
efl_gfx_hint_fill_set(im, EINA_TRUE, EINA_TRUE);
efl_content_set(win, im);
efl_pack(box, im);
efl_key_data_set(win, "im", im);
@ -320,7 +320,6 @@ test_remote_ui_image(void *data EINA_UNUSED, Eo *obj EINA_UNUSED, void *event_i
box2 = efl_add(EFL_UI_RADIO_BOX_CLASS, win);
efl_gfx_hint_weight_set(box2, 1.0, 1.0);
efl_content_set(win, box2);
efl_key_data_set(win, "rdg", box2);
efl_pack(box, box2);

28
src/bin/eolian_mono/eolian/mono/documentation.hh
View File

@ -367,20 +367,34 @@ struct documentation_generator
auto options = efl::eolian::grammar::context_find_tag<options_context>(context);
// Example embedding not requested
if (options.examples_dir.empty()) return true;
std::string file_name = options.examples_dir + full_object_name + ".cs";
bool is_plain_code = false;
std::string file_name = options.examples_dir + full_object_name + ".xml";
std::ifstream exfile(file_name);
// There is no example file for this class or method, just return
if (!exfile.good()) return true;
if (!exfile.good())
{
// There is no example XML file for this class, try a CS file
file_name = options.examples_dir + full_object_name + ".cs";
exfile.open(file_name);
// There are no example files for this class or method, just return
if (!exfile.good()) return true;
is_plain_code = true;
}
std::stringstream example_buff;
// Start with a newline so the first line renders with same indentation as the rest
example_buff << std::endl << exfile.rdbuf();
if (!as_generator(scope_tab(scope_size) << "/// ").generate(sink, attributes::unused, context)) return false;
if (!generate_opening_tag(sink, "example", context)) return false;
if (!generate_opening_tag(sink, "code", context)) return false;
if (is_plain_code)
{
if (!generate_opening_tag(sink, "example", context)) return false;
if (!generate_opening_tag(sink, "code", context)) return false;
}
if (!generate_escaped_content(sink, example_buff.str(), context)) return false;
if (!generate_closing_tag(sink, "code", context)) return false;
if (!generate_closing_tag(sink, "example", context)) return false;
if (is_plain_code)
{
if (!generate_closing_tag(sink, "code", context)) return false;
if (!generate_closing_tag(sink, "example", context)) return false;
}
return as_generator("\n").generate(sink, attributes::unused, context);
}

4
src/examples/elementary/efl_ui_list_example_1.c
View File

@ -240,10 +240,6 @@ elm_main(int argc EINA_UNUSED, char **argv)
efl_ui_radio_state_value_set(radio, EFL_UI_SELECT_MODE_SINGLE);
efl_pack_end(bbox, radio);
radio = efl_add(EFL_UI_RADIO_CLASS, wbox);
efl_text_set(radio, "SINGLE_ALWAYS");
efl_ui_radio_state_value_set(radio, EFL_UI_SELECT_MODE_SINGLE_ALWAYS);
efl_pack_end(bbox, radio);
radio = efl_add(EFL_UI_RADIO_CLASS, wbox);
efl_text_set(radio, "MULTI");
efl_ui_radio_state_value_set(radio, EFL_UI_SELECT_MODE_MULTI);
efl_pack_end(bbox, radio);

2
src/examples/evas/evas-object-manipulation-eo.c
View File

@ -220,7 +220,7 @@ main(void)
}
else
{
efl_gfx_image_border_set(d.clipper_border, 3, 3, 3, 3);
efl_gfx_image_border_insets_set(d.clipper_border, 3, 3, 3, 3);
efl_gfx_image_center_fill_mode_set(d.clipper_border, EFL_GFX_CENTER_FILL_MODE_NONE);
efl_gfx_entity_position_set(d.clipper_border, EINA_POSITION2D((WIDTH / 4) -3, (HEIGHT / 4) - 3));
efl_gfx_entity_size_set(d.clipper_border, EINA_SIZE2D((WIDTH / 2) + 6, (HEIGHT / 2) + 6));

6
src/lib/ecore/efl_appthread.eo
View File

@ -1,7 +1,11 @@
class @beta Efl.Appthread extends Efl.Loop
implements Efl.ThreadIO, Efl.Io.Reader, Efl.Io.Writer, Efl.Io.Closer, Efl.Core.Command_Line
{
[[ ]]
[[This class houses the application's thread and main loop.
It works similarly to @Efl.App but allows communicating with it from a different thread
through the @Efl.ThreadIO, @Efl.Io.Reader and @Efl.Io.Writer interfaces.
Methods can be scheduled to be executed in this thread using @Efl.ThreadIO.call and @Efl.ThreadIO.call_sync.
]]
methods {
}
events {

11
src/lib/ecore/efl_threadio.c
View File

@ -43,17 +43,6 @@ _efl_threadio_outdata_get(const Eo *obj EINA_UNUSED, Efl_ThreadIO_Data *pd)
return pd->outdata;
}
EOLIAN static void
_efl_threadio_call(Eo *obj EINA_UNUSED, Efl_ThreadIO_Data *pd EINA_UNUSED, void *func_data EINA_UNUSED, EflThreadIOCall func EINA_UNUSED, Eina_Free_Cb func_free_cb EINA_UNUSED)
{
}
EOLIAN static void *
_efl_threadio_call_sync(Eo *obj EINA_UNUSED, Efl_ThreadIO_Data *pd EINA_UNUSED, void *func_data EINA_UNUSED, EflThreadIOCallSync func EINA_UNUSED, Eina_Free_Cb func_free_cb EINA_UNUSED)
{
return NULL;
}
//////////////////////////////////////////////////////////////////////////
#include "efl_threadio.eo.c"

36
src/lib/ecore/efl_threadio.eo
View File

@ -1,48 +1,58 @@
import efl_object;
function @beta EflThreadIOCall {
[[ A Function to call on the "other end" of a thread obvject ]]
[[A Function to be called asynchronously on a different thread.]]
params {
@in event: const(event); [[ ]]
@in event: const(event); [[Event struct with an @Efl.Loop_Handler as payload.]]
}
};
function @beta EflThreadIOCallSync {
[[ A Function to call on the "other end" of a thread obvject ]]
[[A Function to be called synchronously on another thread.
Execution will be stopped until this function returns and its return value can be recovered.
]]
params {
@in event: const(event); [[ ]]
@in event: const(event); [[Event struct with an @Efl.Loop_Handler as payload.]]
}
return: void_ptr; [[ ]]
return: void_ptr; [[Data that the function executed on the other thread returned.]]
};
mixin @beta Efl.ThreadIO
{
[[ ]]
[[This mixin defines input and output pointers to allow exchanging data with another thread.
It also defines a mechanism to call methods on that thread.
]]
methods {
@property indata {
[[Input data pointer for the thread.]]
set { }
get { }
values {
data: void_ptr; [[ ]]
data: void_ptr; [[Data pointer.]]
}
}
@property outdata {
[[Output data pointer for the thread.]]
set { }
get { }
values {
data: void_ptr; [[ ]]
data: void_ptr; [[Data pointer.]]
}
}
call {
call @pure_virtual {
[[Executes a method on a different thread, asynchronously.]]
params {
func: EflThreadIOCall; [[ ]]
func: EflThreadIOCall; [[The method to execute asynchronously.]]
}
}
call_sync {
call_sync @pure_virtual {
[[Executes a method on a different thread, synchronously.
This call will not return until the method finishes and its return value can be recovered.
]]
params {
func: EflThreadIOCallSync; [[ ]]
func: EflThreadIOCallSync; [[The method to execute synchronously.]]
}
return: void_ptr; [[ ]]
return: void_ptr; [[The return value from the method.]]
}
}
events {

19
src/lib/efl/interfaces/efl_gfx_image.eo
View File

@ -133,11 +133,11 @@ interface @beta Efl.Gfx.Image
get { }
values {
region: Eina.Rect; [[A rectangle inside the object boundary where content is expected.
The default value is the image object's geometry with the @Efl.Gfx.Image.border
The default value is the image object's geometry with the @.border_insets
values subtracted.]]
}
}
@property border {
@property border_insets {
[[Dimensions of this image's border, a region that does not scale
with the center area.
@ -151,7 +151,7 @@ interface @beta Efl.Gfx.Image
The units used for $l, $r, $t and $b are canvas units (pixels).
Note: The border region itself may be scaled by the
@.border_scale.set function.
@.border_insets_scale.set function.
Note: By default, image objects have no borders set, i.e.
$l, $r, $t and $b start as 0.
@ -167,10 +167,10 @@ interface @beta Efl.Gfx.Image
b: int; [[The border's bottom height. The default value is $0.]]
}
}
@property border_scale {
@property border_insets_scale {
[[Scaling factor applied to the image borders.
This value multiplies the size of the @.border when scaling an
This value multiplies the size of the @.border_insets when scaling an
object.
]]
set {}
@ -186,7 +186,7 @@ interface @beta Efl.Gfx.Image
This function sets how the center part of the image object's
source image is to be drawn, which must be one of the values
in @Efl.Gfx.Center_Fill_Mode. By center we mean the complementary
part of that defined by @.border.set. This is very useful for
part of that defined by @.border_insets.set. This is very useful for
making frames and decorations. You would most probably also be
using a filled image (as in @Efl.Gfx.Fill.fill_auto) to use as a frame.
]]
@ -205,7 +205,7 @@ interface @beta Efl.Gfx.Image
once and then destroy them. When the regions are retrieved by the user,
it is his responsibility to destroy the iterators.. It will remember the
information for the lifetime of the object. It will ignore all value
of @.border, @.border_scale and @.center_fill_mode . To reset the object
of @.border_insets, @.border_insets_scale and @.center_fill_mode . To reset the object
you can just pass $null to both horizontal and vertical at the same
time.
]]
@ -281,9 +281,8 @@ interface @beta Efl.Gfx.Image
}
}
events {
image,preload: void; [[Image data has been preloaded.]]
image,preload_state,changed: bool; [[If $true, image data has been preloaded and can be displayed.
If $false, the image data has been unloaded and can no longer be displayed.]]
image,resized: Eina.Size2D; [[Image was resized (its pixel data). The event data is the image's new size.]]
image,unload: void; [[Image data has been unloaded (by some mechanism in
EFL that threw out the original image data).]]
}
}

2
src/lib/efl_mono/efl_mono_model_internal_child.eo
View File

@ -1,4 +1,4 @@
class Efl.Mono_Model_Internal_Child extends Efl.Loop_Consumer implements Efl.Model
class @beta Efl.Mono_Model_Internal_Child extends Efl.Loop_Consumer implements Efl.Model
{
implements {
Efl.Object.constructor;

3
src/lib/eina/eina_inline_value_util.x
View File

@ -327,8 +327,7 @@ eina_value_reference_copy(const Eina_Value *val)
{
Eina_Value v = EINA_VALUE_EMPTY;
if (!eina_value_setup(&v, eina_value_type_get(val)) ||
!eina_value_copy(val, &v))
if (!eina_value_copy(val, &v))
{
eina_value_setup(&v, EINA_VALUE_TYPE_ERROR);
eina_value_set(&v, EINA_ERROR_VALUE_FAILED);

81
src/lib/eio/efl_io_model.c
View File

@ -762,6 +762,63 @@ _efl_io_model_efl_model_property_set(Eo *obj,
return efl_loop_future_rejected(obj, err);
}
static void
_efl_io_model_children_list(void *data, Eina_Array *entries)
{
Eina_File_Direct_Info *info;
Efl_Model *obj = data;
Efl_Io_Model_Data *pd;
Efl_Model_Children_Event cevt = { 0 };
Eina_Array_Iterator iterator;
unsigned int i;
pd = efl_data_scope_get(obj, EFL_IO_MODEL_CLASS);
if (!pd) return ;
EINA_ARRAY_ITER_NEXT(entries, i, info, iterator)
{
Efl_Io_Model_Info *mi;
if (_already_added(pd, info->path)) continue;
if (pd->filter.cb)
{
if (!pd->filter.cb(pd->filter.data, obj, info))
continue ;
}
mi = calloc(1, sizeof (Efl_Io_Model_Info));
if (!mi) continue ;
mi->path_length = info->path_length;
mi->path = eina_stringshare_add(info->path);
mi->name_start = info->name_start;
mi->name_length = info->name_length;
mi->type = _efl_io_model_info_type_get(info, NULL);
mi->parent_ref = EINA_FALSE;
mi->child_ref = EINA_TRUE;
cevt.index = eina_list_count(pd->files);
cevt.child = NULL;
pd->files = eina_list_append(pd->files, mi);
efl_event_callback_call(obj, EFL_MODEL_EVENT_CHILD_ADDED, &cevt);
}
efl_event_callback_call(obj, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, NULL);
}
static void
_efl_io_model_children_list_cleanup(Eo *o EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
{
Efl_Io_Model_Data *pd = data;
pd->request.listing = NULL;
pd->listed = EINA_TRUE;
}
/**
* Children Count Get
*/
@ -778,6 +835,30 @@ _efl_io_model_efl_model_children_count_get(const Eo *obj, Efl_Io_Model_Data *pd)
{
_eio_build_st(obj, pd);
}
else if (!pd->listed &&
!pd->request.listing &&
pd->info->type == EINA_FILE_DIR)
{
Efl_Io_Manager *iom;
Eina_Future *f;
iom = efl_provider_find(obj, EFL_IO_MANAGER_CLASS);
if (!iom)
{
ERR("Could not find an Efl.Io.Manager on %p.", obj);
return 0;
}
f = efl_io_manager_direct_ls(iom, pd->path, EINA_FALSE,
(void*) obj, _efl_io_model_children_list, NULL);
//start monitoring before listing is done
//we will filter later on if we already published a file or not
_efl_io_model_efl_model_monitor_add(pd);
pd->request.listing = efl_future_then(obj, f,
.free = _efl_io_model_children_list_cleanup,
.data = pd);
}
return eina_list_count(pd->files);
}

114
src/lib/elementary/Efl_Ui.h
View File

@ -140,6 +140,7 @@ extern EAPI double _efl_startup_time;
// EO types. Defined for legacy-only builds as legacy uses typedef of EO types.
#include "efl_ui.eot.h"
#include "efl_ui_selection_types.eot.h"
#include "efl_ui_dnd_types.eot.h"
//define focus manager earlier since focus object and manager is circular
typedef Eo Efl_Ui_Focus_Manager;
@ -175,9 +176,12 @@ EAPI void efl_ui_focus_relation_free(Efl_Ui_Focus_Relations *rel);
# include <efl_ui_widget_scrollable_content.eo.h>
# include <efl_ui_widget_common.h>
# include <efl_ui_widget_part.eo.h>
# include <efl_ui_widget_part_bg.eo.h>
# include <efl_ui_widget_part_shadow.eo.h>
# include <efl_ui_layout_base.eo.h>
# include <efl_ui_layout.eo.h>
# include <efl_ui_layout_part.eo.h>
# include <efl_ui_layout_part_bg.eo.h>
# include <efl_ui_layout_part_box.eo.h>
# include <efl_ui_layout_part_content.eo.h>
# include <efl_ui_layout_part_text.eo.h>
@ -193,45 +197,85 @@ EAPI void efl_ui_focus_relation_free(Efl_Ui_Focus_Relations *rel);
# include <efl_ui_table.eo.h>
# include <efl_ui_table_static.eo.h>
# include <efl_ui_image.eo.h>
# include <efl_ui_image_zoomable.eo.h>
# include <efl_ui_win.eo.h>
/* FIXME: what the actual fuck. */
# include <elm_win_eo.h>
#ifdef EFL_BETA_API_SUPPORT
/**
* @brief Set the window's autodel state.
*
* When closing the window in any way outside of the program control, like
* pressing the X button in the titlebar or using a command from the Window
* Manager, a "delete,request" signal is emitted to indicate that this event
* occurred and the developer can take any action, which may include, or not,
* destroying the window object.
*
* When the @c autodel parameter is set, the window will be automatically
* destroyed when this event occurs, after the signal is emitted. If @c autodel
* is @c false, then the window will not be destroyed and is up to the program
* to do so when it's required.
*
* @param[in] obj The object.
* @param[in] autodel If @c true, the window will automatically delete itself
* when closed.
*
* Note: This function is only available in C.
*
* @ingroup Efl_Ui_Win
*/
EAPI void efl_ui_win_autodel_set(Efl_Ui_Win *obj, Eina_Bool autodel);
/**
* @brief Get the window's autodel state.
*
* @param[in] obj The object.
*
* @return If @c true, the window will automatically delete itself when closed.
*
* Note: This function is only available in C.
*
* @ingroup Efl_Ui_Win
*/
EAPI Eina_Bool efl_ui_win_autodel_get(const Efl_Ui_Win *obj);
#endif
# include <efl_ui_win_inlined.eo.h>
# include <efl_ui_win_socket.eo.h>
# include <efl_ui_relative_layout.eo.h>
/* FIXME: Efl.Ui.Text must not use elm_general.h */
// no.
//# warning Efl.Ui.Text is not available yet without Elementary.h
# if 0
# include <efl_ui_text_interactive.eo.h>
# include <elm_general.h>
# include <efl_text_interactive.eo.h>
# include <efl_ui_text.eo.h>
# include <efl_ui_text_editable.eo.h>
# include <efl_ui_text_async.eo.h>
# endif
# include <efl_ui_animation_view.h>
# include <efl_ui_animation_view_part.eo.h>
# include <efl_ui_animation_view.eo.h>
# include <efl_ui_clock.h>
# include <efl_ui_image_factory.eo.h>
# include <efl_ui_video.h>
# include <efl_ui_calendar.h>
# include <efl_ui_button_eo.h>
# include "efl_ui_caching_factory.eo.h"
# include "efl_ui_widget_factory.eo.h"
# include <efl_ui_widget_factory.eo.h>
# include <efl_ui_image_factory.eo.h>
# include <efl_ui_layout_factory.eo.h>
# include <efl_ui_caching_factory.eo.h>
# include <efl_ui_text_factory_fallback.eo.h>
# include <efl_ui_text_factory_images.eo.h>
# include <efl_ui_text_factory_emoticons.eo.h>
/* FIXME: Multibuttonentry must not use elm_widget_item */
# include <efl_ui_tags.eo.h>
# include <efl_ui_button.eo.h>
# include <efl_ui_check.eo.h>
# include <efl_ui_radio.eo.h>
# include <efl_ui_radio_group.eo.h>
# include <efl_ui_radio_group_impl.eo.h>
# include <efl_ui_radio_box.eo.h>
# include <efl_ui_progressbar.eo.h>
# include <efl_ui_flip_eo.h>
# include <efl_ui_frame_eo.h>
# include <efl_ui_check_eo.h>
# include <efl_ui_image_zoomable_eo.h>
# include <efl_ui_progressbar_eo.h>
# include <efl_ui_radio_eo.h>
# include <efl_ui_panes_eo.h>
# include <efl_ui_flip.eo.h>
# include <efl_ui_frame.eo.h>
# include <efl_ui_panel.eo.h>
# include <efl_ui_panes.eo.h>
# include <efl_ui_panes_part.eo.h>
#define _EFL_UI_SPOTLIGHT_MANAGEREO_EO_CLASS_TYPE
@ -256,6 +300,7 @@ typedef Eo Efl_Ui_Spotlight_Indicator;
# include <efl_ui_spin.eo.h>
# include <efl_ui_spin_button.eo.h>
# include <efl_ui_slider.eo.h>
# include <efl_ui_slider_interval.eo.h>
# include <efl_ui_item.eo.h>
# include <efl_ui_position_manager_entity.eo.h>
# include <efl_ui_position_manager_data_access_v1.eo.h>
@ -278,7 +323,36 @@ typedef Eo Efl_Ui_Spotlight_Indicator;
# include <efl_ui_tab_page.eo.h>
# include <efl_ui_tab_pager.eo.h>
# include <efl_ui_select_model.eo.h>
# include "efl_ui_list_view_types.eot.h"
# include <efl_ui_list_view.eo.h>
# include <efl_ui_list_view_model.eo.h>
# include <efl_ui_list_view_precise_layouter.eo.h>
# include <efl_ui_list_view_relayout.eo.h>
# include <efl_ui_list_view_pan.eo.h>
# include <efl_ui_view_model.eo.h>
# include <efl_ui_size_model.eo.h>
# include <efl_ui_homogeneous_model.eo.h>
# include <efl_ui_exact_model.eo.h>
# include <efl_ui_average_model.eo.h>
# include <efl_ui_scroller.eo.h>
# include <efl_ui_pan.eo.h>
# include <efl_ui_scroll_manager.eo.h>
# include <efl_ui_focus_parent_provider.eo.h>
# include <efl_ui_widget_focus_manager.eo.h>
# include <efl_ui_focus_parent_provider_standard.eo.h>
# include <efl_ui_selection.eo.h>
# include <efl_ui_dnd.eo.h>
# include <efl_ui_dnd_container.eo.h>
# include <efl_ui_selection_manager.eo.h>
# include <efl_datetime_manager.eo.h>
# include <efl_ui_timepicker.eo.h>
# include <efl_ui_datepicker.eo.h>
# include <efl_ui_calendar.eo.h>
/**
* Initialize Elementary
*

87
src/lib/elementary/Elementary.h
View File

@ -149,22 +149,6 @@ EAPI extern Elm_Version *elm_version;
#include <elm_focus.h>
#include <Efl.h>
# include <efl_ui.eot.h>
//define focus manager earlier since focus object and manager is circular
typedef Eo Efl_Ui_Focus_Manager;
#define _EFL_UI_FOCUS_MANAGER_EO_CLASS_TYPE
# include <efl_ui_focus_object.eo.h>
# include <efl_ui_focus_manager.eo.h>
# include <efl_ui_focus_manager_window_root.eo.h>
# include <efl_ui_focus_manager_calc.eo.h>
# include <efl_ui_focus_manager_sub.eo.h>
# include <efl_ui_focus_manager_root_focus.eo.h>
# include <efl_ui_focus_util.eo.h>
# include <efl_ui_l10n.eo.h>
# include <efl_ui_focus_composition.eo.h>
# include <efl_ui_focus_layer.eo.h>
#ifdef EFL_BETA_API_SUPPORT
# include <elm_interface_scrollable.h>
@ -212,8 +196,8 @@ typedef Eo Efl_Ui_Focus_Manager;
#include <elm_button.h>
#include <elm_cache.h>
#include <elm_calendar.h>
/* this is elm_animation_view */
#include <efl_ui_animation_view.h>
#include <efl_ui_calendar.h>
#include <elm_check.h>
#include <elm_clock.h>
#include <elm_cnp.h>
@ -276,80 +260,13 @@ typedef Eo Efl_Ui_Focus_Manager;
#include <elm_thumb.h>
#include <elm_toolbar.h>
#include <elm_transit.h>
/* this is actually elm_video */
#include <efl_ui_video.h>
#include <elm_view_list.h>
#include <elm_view_form.h>
#include <elm_web.h>
#include <elm_win.h>
# include <efl_ui_selection_types.eot.h>
# include <efl_ui_theme.eo.h>
# include <efl_config_global.eo.h>
# include <efl_ui_widget.eo.h>
# include <efl_ui_widget_part.eo.h>
# include <efl_ui_widget_part_bg.eo.h>
# include <efl_ui_widget_part_shadow.eo.h>
# include <efl_ui_layout.eo.h>
# include <efl_ui_layout_part.eo.h>
# include <efl_ui_layout_part_box.eo.h>
# include <efl_ui_layout_part_content.eo.h>
# include <efl_ui_layout_part_bg.eo.h>
# include <efl_ui_layout_part_text.eo.h>
# include <efl_ui_layout_part_table.eo.h>
# include <efl_ui_win_part.eo.h>
# include <efl_ui_bg.eo.h>
# include <efl_ui_box.eo.h>
# include <efl_ui_box_flow.eo.h>
# include <efl_ui_box_stack.eo.h>
# include <efl_ui_table.eo.h>
# include <efl_ui_table_static.eo.h>
# include <efl_ui_image.eo.h>
# include <efl_ui_win.eo.h>
# include <efl_ui_win_inlined.eo.h>
# include <efl_ui_win_socket.eo.h>
# include <efl_text_interactive.eo.h>
# include <efl_ui_text.eo.h>
# include <efl_ui_popup.eo.h>
# include <efl_ui_alert_popup.eo.h>
# include <efl_ui_popup_part_backwall.eo.h>
# include <efl_ui_text_factory_images.eo.h>
# include <efl_ui_text_factory_emoticons.eo.h>
# include <efl_ui_text_factory_fallback.eo.h>
# include <efl_ui_text_editable.eo.h>
# include <efl_ui_text_async.eo.h>
# include <efl_ui_clock.eo.h>
# include <efl_ui_spin.eo.h>
# include <efl_ui_spin_button.eo.h>
# include <efl_ui_datepicker.eo.h>
# include <efl_ui_timepicker.eo.h>
# include <efl_ui_tags.eo.h>
# include <efl_ui_panel.eo.h>
# include <efl_ui_image_factory.eo.h>
# include <efl_ui_slider.eo.h>
# include <efl_ui_slider_interval.eo.h>
# include <efl_ui_layout_factory.eo.h>
# include <efl_ui_item.eo.h>
# include <efl_ui_list_default_item.eo.h>
# include <efl_ui_list_placeholder_item.eo.h>
# include <efl_ui_list.eo.h>
# include <efl_ui_grid_default_item.eo.h>
# include <efl_ui_grid.eo.h>
# include <efl_ui_list_view_types.eot.h>
# include <efl_ui_list_view_model.eo.h>
# include <efl_ui_list_view.eo.h>
# include <efl_ui_list_view_pan.eo.h>
# include <efl_ui_widget_factory.eo.h>
# include <efl_ui_caching_factory.eo.h>
# include <efl_ui_pan.eo.h>
# include <efl_ui_scroll_manager.eo.h>
# include <efl_ui_scroller.eo.h>
# include <efl_ui_dnd_types.eot.h>
# include <efl_ui_selection.eo.h>
# include <efl_ui_dnd.eo.h>
# include <efl_ui_dnd_container.eo.h>
# include <efl_ui_relative_layout.eo.h>
# include <efl_ui_animation_view.eo.h>
/* include deprecated calls last of all */
#include <elm_deprecated.h>

2
src/lib/elementary/efl_access_action.c
View File

@ -4,8 +4,6 @@
#define EFL_ACCESS_ACTION_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
EOLIAN const char *

2
src/lib/elementary/efl_access_component.c
View File

@ -5,8 +5,6 @@
#define EFL_ACCESS_COMPONENT_PROTECTED
#define EFL_ACCESS_OBJECT_PROTECTED
#include <Elementary.h>
#include "elm_priv.h"

2
src/lib/elementary/efl_access_editable_text.c
View File

@ -4,8 +4,6 @@
#define EFL_ACCESS_EDITABLE_TEXT_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
#include "efl_access_editable_text.eo.c"

2
src/lib/elementary/efl_access_object.c
View File

@ -4,8 +4,6 @@
#define EFL_ACCESS_OBJECT_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
const char* Access_Name[] = {

2
src/lib/elementary/efl_access_selection.c
View File

@ -4,8 +4,6 @@
#define ELM_INTERFACE_ATSPI_VALUE_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
#include "efl_access_selection.eo.c"

2
src/lib/elementary/efl_access_text.c
View File

@ -4,8 +4,6 @@
#define EFL_ACCESS_TEXT_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
void

2
src/lib/elementary/efl_access_value.c
View File

@ -4,8 +4,6 @@
#define EFL_ACCESS_VALUE_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
#include "efl_access_value.eo.c"

2
src/lib/elementary/efl_access_widget_action.c
View File

@ -5,8 +5,6 @@
#define EFL_ACCESS_ACTION_PROTECTED
#define EFL_ACCESS_WIDGET_ACTION_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
extern Eina_Hash *_elm_key_bindings;

2
src/lib/elementary/efl_access_window.c
View File

@ -2,8 +2,6 @@
#include "elementary_config.h"
#endif
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
#include "efl_access_window.eo.c"

12
src/lib/elementary/efl_ui_caching_factory.c
View File

@ -199,7 +199,11 @@ _efl_ui_caching_factory_efl_ui_factory_create(Eo *obj,
r->factory = efl_ref(obj);
all = calloc(1, sizeof (Eina_Future *));
if (!all) return efl_loop_future_rejected(obj, ENOMEM);
if (!all)
{
free(r);
return efl_loop_future_rejected(obj, ENOMEM);
}
EINA_ITERATOR_FOREACH(models, model)
{
@ -209,7 +213,11 @@ _efl_ui_caching_factory_efl_ui_factory_create(Eo *obj,
.data = r);
all = realloc(all, (count + 1) * sizeof (Eina_Future *));
if (!all) return efl_loop_future_rejected(obj, ENOMEM);
if (!all)
{
free(r);
return efl_loop_future_rejected(obj, ENOMEM);
}
}
eina_iterator_free(models);

55
src/lib/elementary/efl_ui_calendar.h
View File

@ -1,55 +0,0 @@
/**
* @defgroup Elm_Calendar Calendar
* @ingroup Elementary
*
* @image html calendar_inheritance_tree.png
* @image latex calendar_inheritance_tree.eps
*
* This is a calendar widget. It helps applications to flexibly
* display a calendar with day of the week, date, year and
* month. Applications are able to set specific dates to be reported
* back, when selected, in the smart callbacks of the calendar
* widget. The API of this widget lets the applications perform other
* functions, like:
*
* - placing marks on specific dates
* - setting the bounds for the calendar (minimum and maximum years)
* - setting the day names of the week (e.g. "Thu" or "Thursday")
* - setting the year and month format.
*
* This widget inherits from the @ref Layout one, so that all the
* functions acting on it also work for calendar objects.
*
* This widget emits the following signals, besides the ones sent from
* @ref Layout:
* - @c "changed" - emitted when the date in the calendar is changed.
* - @c "display,changed" - emitted when the current month displayed in the
* calendar is changed.
* - @c "focused" - When the calendar has received focus. (since 1.8)
* - @c "unfocused" - When the calendar has lost focus. (since 1.8)
* - @c "language,changed" - the program's language changed (since 1.9)
*
* Supported elm_object common APIs.
* @li @ref elm_object_signal_emit
* @li @ref elm_object_signal_callback_add
* @li @ref elm_object_signal_callback_del
*
* Here is some sample code using it:
* @li @ref calendar_example_01
* @li @ref calendar_example_02
* @li @ref calendar_example_03
* @li @ref calendar_example_04
* @li @ref calendar_example_05
* @li @ref calendar_example_06
*/
/**
* @addtogroup Elm_Calendar
* @{
*/
#include "efl_ui_calendar.eo.h"
/**
* @}
*/

26
src/lib/elementary/efl_ui_check.c
View File

@ -50,6 +50,25 @@ static const Elm_Action key_actions[] = {
{NULL, NULL}
};
static void
_check_legacy_event(Eo *obj)
{
EFL_UI_CHECK_DATA_GET(obj, pd);
if (pd->selected)
{
if (pd->legacy_changed_emitted_select) return;
pd->legacy_changed_emitted_select = EINA_TRUE;
pd->legacy_changed_emitted_unselect = EINA_FALSE;
}
else
{
if (pd->legacy_changed_emitted_unselect) return;
pd->legacy_changed_emitted_unselect = EINA_TRUE;
pd->legacy_changed_emitted_select = EINA_FALSE;
}
evas_object_smart_callback_call(obj, "changed", NULL);
}
static void
_activate(Evas_Object *obj)
{
@ -97,8 +116,7 @@ _activate(Evas_Object *obj)
// "efl,state,check,on" or "efl,state,check,off" for eo-api
efl_ui_selectable_selected_set(obj, !efl_ui_selectable_selected_get(obj));
if (elm_widget_is_legacy(obj))
evas_object_smart_callback_call(obj, "changed", NULL);
_check_legacy_event(obj);
if (_elm_config->atspi_mode)
efl_access_state_changed_signal_emit(obj,
EFL_ACCESS_STATE_TYPE_CHECKED,
@ -231,6 +249,8 @@ _on_check_off(void *data,
Evas_Object *obj = data;
_flush_selected(obj, EINA_FALSE);
if (elm_widget_is_legacy(obj))
_check_legacy_event(obj);
}
static void
@ -242,6 +262,8 @@ _on_check_on(void *data,
Evas_Object *obj = data;
_flush_selected(obj, EINA_TRUE);
if (elm_widget_is_legacy(obj))
_check_legacy_event(obj);
}
static void

2
src/lib/elementary/efl_ui_check_private.h
View File

@ -28,6 +28,8 @@ struct _Efl_Ui_Check_Data
{
Eina_Bool *statep;
Eina_Bool selected;
Eina_Bool legacy_changed_emitted_unselect : 1;
Eina_Bool legacy_changed_emitted_select : 1;
};
/**

4
src/lib/elementary/efl_ui_collection.c
View File

@ -486,7 +486,7 @@ EOLIAN static void
_efl_ui_collection_efl_ui_multi_selectable_select_mode_set(Eo *obj EINA_UNUSED, Efl_Ui_Collection_Data *pd, Efl_Ui_Select_Mode mode)
{
pd->mode = mode;
if ((mode == EFL_UI_SELECT_MODE_SINGLE_ALWAYS || mode == EFL_UI_SELECT_MODE_SINGLE) &&
if ((mode == EFL_UI_SELECT_MODE_SINGLE) &&
eina_list_count(pd->selected) > 0)
{
Efl_Ui_Item *last = eina_list_last_data_get(pd->selected);
@ -569,7 +569,7 @@ _selection_changed(void *data, const Efl_Event *ev)
if (selection)
{
if (pd->mode == EFL_UI_SELECT_MODE_SINGLE_ALWAYS || pd->mode == EFL_UI_SELECT_MODE_SINGLE)
if (pd->mode == EFL_UI_SELECT_MODE_SINGLE)
{
_single_selection_behaviour(obj, pd, ev->object);
}

1
src/lib/elementary/efl_ui_homogeneous_model.c
View File

@ -35,7 +35,6 @@ _efl_ui_homogeneous_model_property_set(Eo *obj, Eina_Value *value,
return efl_loop_future_rejected(obj, EFL_MODEL_ERROR_INCORRECT_VALUE);
*defined = EINA_TRUE;
f = efl_loop_future_resolved(obj, *value);
eina_value_free(value);
return f;
}

31
src/lib/elementary/efl_ui_image.c
View File

@ -1221,6 +1221,37 @@ _efl_ui_image_efl_layout_signal_signal_emit(Eo *obj EINA_UNUSED, Efl_Ui_Image_Da
edje_object_signal_emit(sd->img, emission, source);
}
EOLIAN static void
_efl_ui_image_efl_layout_signal_message_send(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *pd, int id, const Eina_Value msg)
{
if (pd->edje)
efl_layout_signal_message_send(pd->img, id, msg);
}
EOLIAN static Eina_Bool
_efl_ui_image_efl_layout_signal_signal_callback_add(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *pd, const char *emission, const char *source, void *func_data, EflLayoutSignalCb func, Eina_Free_Cb func_free_cb)
{
if (pd->edje)
return efl_layout_signal_callback_add(pd->img, emission, source, func_data, func, func_free_cb);
return EINA_FALSE;
}
EOLIAN static Eina_Bool
_efl_ui_image_efl_layout_signal_signal_callback_del(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *pd, const char *emission, const char *source, void *func_data, EflLayoutSignalCb func, Eina_Free_Cb func_free_cb)
{
if (pd->edje)
return efl_layout_signal_callback_del(pd->img, emission, source, func_data, func, func_free_cb);
return EINA_FALSE;
}
EOLIAN static void
_efl_ui_image_efl_layout_signal_signal_process(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *pd, Eina_Bool recurse)
{
if (pd->edje)
efl_layout_signal_process(pd->img, recurse);
}
EOLIAN static Eina_Size2D
_efl_ui_image_efl_layout_group_group_size_min_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{

4
src/lib/elementary/efl_ui_image.eo
View File

@ -83,6 +83,10 @@ class @beta Efl.Ui.Image extends Efl.Ui.Widget implements Efl.Input.Clickable, E
Efl.Player.playable { get; }
Efl.Player.play { get; set; }
Efl.Layout.Signal.signal_emit;
Efl.Layout.Signal.message_send;
Efl.Layout.Signal.signal_callback_add;
Efl.Layout.Signal.signal_callback_del;
Efl.Layout.Signal.signal_process;
Efl.Layout.Group.group_size_min { get; }
Efl.Layout.Group.group_size_max { get; }
Efl.Layout.Group.group_data { get; }

1
src/lib/elementary/efl_ui_image_zoomable.c
View File

@ -12,6 +12,7 @@
#include "elm_priv.h"
#include "efl_ui_image_zoomable_private.h"
#include "efl_ui_image_zoomable_pan.eo.h"
#define MY_PAN_CLASS EFL_UI_IMAGE_ZOOMABLE_PAN_CLASS

2
src/lib/elementary/efl_ui_internal_text_interactive.c
View File

@ -2,7 +2,7 @@
# include "elementary_config.h"
#endif
#include <Elementary.h>
#include "elm_priv.h"
#include "efl_ui_internal_text_interactive.h"
#define MY_CLASS EFL_UI_INTERNAL_TEXT_INTERACTIVE_CLASS

4
src/lib/elementary/efl_ui_item.c
View File

@ -45,7 +45,7 @@ _item_select(Eo *obj, Efl_Ui_Item_Data *pd)
if (pd->container)
{
m = _fetch_state(pd->container);
if (m == EFL_UI_SELECT_MODE_NONE || (pd->selected && m != EFL_UI_SELECT_MODE_SINGLE_ALWAYS))
if (m == EFL_UI_SELECT_MODE_NONE)
return;
}
else
@ -95,7 +95,7 @@ _item_unpressed(void *data, const Efl_Event *ev EINA_UNUSED)
efl_layout_signal_emit(obj, "efl,state,unpressed", "efl");
m = _fetch_state(pd->container);
if ((m != EFL_UI_SELECT_MODE_SINGLE_ALWAYS) && (pd->selected))
if (pd->selected)
efl_ui_selectable_selected_set(obj, EINA_FALSE);
else if (m != EFL_UI_SELECT_MODE_NONE)
efl_ui_selectable_selected_set(obj, EINA_TRUE);

2
src/lib/elementary/efl_ui_list_view.c
View File

@ -8,7 +8,7 @@
#define EFL_UI_FOCUS_COMPOSITION_PROTECTED
#define EFL_UI_WIDGET_FOCUS_MANAGER_PROTECTED
#include <Elementary.h>
#include "elm_priv.h"
#include "efl_ui_list_view_private.h"
#include "efl_ui_list_view_precise_layouter.eo.h"

2
src/lib/elementary/efl_ui_list_view_seg_array.c
View File

@ -2,7 +2,7 @@
# include "elementary_config.h"
#endif
#include <Efl.h>
#include "elm_priv.h"
#include <assert.h>
#include "efl_ui_list_view_private.h"

2
src/lib/elementary/efl_ui_multi_selectable.eo
View File

@ -2,8 +2,6 @@ enum @beta Efl.Ui.Select_Mode {
[[Type of multi selectable object.]]
single, [[Only single child is selected. If a child is selected,
previous selected child will be unselected.]]
single_always, [[Same as single select except, this will be selected
in every select call even if child is already been selected.]]
multi, [[Allow multiple selection of children.]]
none [[No child can be selected at all.]]
}

18
src/lib/elementary/efl_ui_position_manager_grid.c
View File

@ -766,7 +766,16 @@ _efl_ui_position_manager_grid_efl_ui_position_manager_entity_version(Eo *obj EIN
EOLIAN static void
_efl_ui_position_manager_grid_efl_ui_position_manager_data_access_v1_data_access_set(Eo *obj, Efl_Ui_Position_Manager_Grid_Data *pd, void *obj_access_data, Efl_Ui_Position_Manager_Object_Batch_Callback obj_access, Eina_Free_Cb obj_access_free_cb, void *size_access_data, Efl_Ui_Position_Manager_Size_Batch_Callback size_access, Eina_Free_Cb size_access_free_cb, int size)
{
// Cleanup cache first
_group_cache_invalidate(obj, pd);
// Clean callback if they were set
if (pd->callbacks.object.free_cb)
pd->callbacks.object.free_cb(pd->callbacks.object.data);
if (pd->callbacks.size.free_cb)
pd->callbacks.size.free_cb(pd->callbacks.size.data);
// Set them
pd->callbacks.object.data = obj_access_data;
pd->callbacks.object.access = obj_access;
pd->callbacks.object.free_cb = obj_access_free_cb;
@ -779,6 +788,15 @@ _efl_ui_position_manager_grid_efl_ui_position_manager_data_access_v1_data_access
}
EOLIAN static void
_efl_ui_position_manager_grid_efl_object_invalidate(Eo *obj,
Efl_Ui_Position_Manager_Grid_Data *pd EINA_UNUSED)
{
efl_ui_position_manager_data_access_v1_data_access_set(obj, NULL, NULL, NULL, NULL, NULL, NULL, 0);
efl_invalidate(efl_super(obj, EFL_UI_POSITION_MANAGER_GRID_CLASS));
}
EOLIAN static Efl_Object*
_efl_ui_position_manager_grid_efl_object_finalize(Eo *obj, Efl_Ui_Position_Manager_Grid_Data *pd)
{

1
src/lib/elementary/efl_ui_position_manager_grid.eo
View File

@ -18,5 +18,6 @@ class @beta Efl.Ui.Position_Manager.Grid extends Efl.Object
Efl.Ui.Layout_Orientable.orientation {set; get;}
Efl.Ui.Position_Manager.Data_Access_V1.data_access {set;}
Efl.Object.finalize;
Efl.Object.invalidate;
}
}

15
src/lib/elementary/efl_ui_position_manager_list.c
View File

@ -480,12 +480,14 @@ _efl_ui_position_manager_list_efl_ui_layout_orientable_orientation_get(const Eo
}
EOLIAN static void
_efl_ui_position_manager_list_efl_object_destructor(Eo *obj, Efl_Ui_Position_Manager_List_Data *pd)
_efl_ui_position_manager_list_efl_object_invalidate(Eo *obj, Efl_Ui_Position_Manager_List_Data *pd)
{
if (pd->rebuild_absolut_size)
eina_future_cancel(pd->rebuild_absolut_size);
efl_destructor(efl_super(obj, MY_CLASS));
efl_ui_position_manager_data_access_v1_data_access_set(obj, NULL, NULL, NULL, NULL, NULL, NULL, 0);
efl_invalidate(efl_super(obj, MY_CLASS));
}
EOLIAN static int
@ -524,7 +526,16 @@ _efl_ui_position_manager_list_efl_ui_position_manager_entity_version(Eo *obj EIN
EOLIAN static void
_efl_ui_position_manager_list_efl_ui_position_manager_data_access_v1_data_access_set(Eo *obj, Efl_Ui_Position_Manager_List_Data *pd, void *obj_access_data, Efl_Ui_Position_Manager_Object_Batch_Callback obj_access, Eina_Free_Cb obj_access_free_cb, void *size_access_data, Efl_Ui_Position_Manager_Size_Batch_Callback size_access, Eina_Free_Cb size_access_free_cb, int size)
{
// Cleanup cache first
cache_invalidate(obj, pd);
// Clean callback if they were set
if (pd->callbacks.object.free_cb)
pd->callbacks.object.free_cb(pd->callbacks.object.data);
if (pd->callbacks.size.free_cb)
pd->callbacks.size.free_cb(pd->callbacks.size.data);
// Set them
pd->callbacks.object.data = obj_access_data;
pd->callbacks.object.access = obj_access;
pd->callbacks.object.free_cb = obj_access_free_cb;

2
src/lib/elementary/efl_ui_position_manager_list.eo
View File

@ -8,7 +8,7 @@ class @beta Efl.Ui.Position_Manager.List extends Efl.Object
the layout of all items. This supports the vertical and horizontal orientation.
]]
implements {
Efl.Object.destructor;
Efl.Object.invalidate;
Efl.Ui.Position_Manager.Entity.version;
Efl.Ui.Position_Manager.Entity.viewport {set;}
Efl.Ui.Position_Manager.Entity.scroll_position {set;}

17
src/lib/elementary/efl_ui_radio_box.c
View File

@ -2,7 +2,6 @@
# include "elementary_config.h"
#endif
#include <Elementary.h>
#include "elm_priv.h"
#define MY_CLASS EFL_UI_RADIO_BOX_CLASS
@ -13,10 +12,10 @@ typedef struct {
} Efl_Ui_Radio_Box_Data;
static inline Eina_Bool
register_safe_in_group_begin(Eo *subobj, Efl_Ui_Radio_Box_Data *pd)
register_safe_in_group_begin(Eo *subobj, Efl_Ui_Radio_Box_Data *pd, Eina_Bool is_radio)
{
EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(subobj, EFL_UI_RADIO_CLASS), EINA_FALSE);
if (!pd->in_pack)
if (pd->in_pack) return EINA_TRUE;
if (is_radio)
efl_ui_radio_group_register(pd->group, subobj);
pd->in_pack = EINA_TRUE;
@ -24,9 +23,9 @@ register_safe_in_group_begin(Eo *subobj, Efl_Ui_Radio_Box_Data *pd)
}
static inline Eina_Bool
register_safe_group_end(Eo *subobj, Efl_Ui_Radio_Box_Data *pd, Eina_Bool result)
register_safe_group_end(Eo *subobj, Efl_Ui_Radio_Box_Data *pd, Eina_Bool is_radio, Eina_Bool result)
{
if (!result)
if (is_radio && (!result))
efl_ui_radio_group_unregister(pd->group, subobj);
pd->in_pack = EINA_FALSE;
@ -34,11 +33,11 @@ register_safe_group_end(Eo *subobj, Efl_Ui_Radio_Box_Data *pd, Eina_Bool result)
}
#define REGISTER_SAFE(f) \
Eina_Bool result; \
if (!register_safe_in_group_begin(subobj, pd)) \
Eina_Bool result, is_radio = efl_isa(subobj, EFL_UI_RADIO_CLASS); \
if (!register_safe_in_group_begin(subobj, pd, is_radio)) \
return EINA_FALSE; \
result = f ; \
return register_safe_group_end(subobj, pd, result);
return register_safe_group_end(subobj, pd, is_radio, result);
static void
unpack_from_logical(Eo *obj, Efl_Ui_Radio_Box_Data *pd)

2
src/lib/elementary/efl_ui_radio_box.eo
View File

@ -2,7 +2,7 @@ class @beta Efl.Ui.Radio_Box extends Efl.Ui.Box implements Efl.Ui.Radio_Group
composite Efl.Ui.Radio_Group
{
[[A standard @Efl.Ui.Box container which automatically handles grouping of any @Efl.Ui.Radio
widget added to it.
widget added to it in addition to regular widgets.
All @Efl.Ui.Radio widgets are added to the same internal group which you only indirectly
access through this object.

5
src/lib/elementary/efl_ui_video.c
View File

@ -2,16 +2,13 @@
# include "elementary_config.h"
#endif
#include <Emotion.h>
#define EFL_ACCESS_OBJECT_PROTECTED
#define EFL_ACCESS_WIDGET_ACTION_PROTECTED
#include <Elementary.h>
#include "elm_priv.h"
#include "elm_widget_layout.h"
#include "efl_ui_video_private.h"
#include "elm_priv.h"
/* TODO: add buffering support to Emotion and display buffering
* progress in the theme when needed */

12
src/lib/elementary/efl_ui_widget_factory.c
View File

@ -186,7 +186,11 @@ _efl_ui_widget_factory_efl_ui_factory_create(Eo *obj, Efl_Ui_Widget_Factory_Data
r->factory = efl_ref(obj);
f = calloc(count + 1, sizeof (Eina_Future *));
if (!f) return efl_loop_future_rejected(obj, ENOMEM);
if (!f)
{
free(r);
return efl_loop_future_rejected(obj, ENOMEM);
}
EINA_ITERATOR_FOREACH(models, model)
{
@ -195,7 +199,11 @@ _efl_ui_widget_factory_efl_ui_factory_create(Eo *obj, Efl_Ui_Widget_Factory_Data
.free = _efl_ui_widget_factory_single_cleanup);
f = realloc(f, (count + 1) * sizeof (Eina_Future *));
if (!f) return efl_loop_future_rejected(obj, ENOMEM);
if (!f)
{
free(r);
return efl_loop_future_rejected(obj, ENOMEM);
}
}
eina_iterator_free(models);

8
src/lib/elementary/efl_ui_widget_part_bg.eo
View File

@ -1,6 +1,12 @@
class @beta Efl.Ui.Widget_Part_Bg extends Efl.Ui.Widget_Part implements Efl.File, Efl.Gfx.Color, Efl.Gfx.Image
{
[[Elementary widget internal part background class]]
[[Elementary widget internal part background class
This part will proxy the calls on it to the @Efl.Ui.Bg internal object of this widget.
This internal object is stacked below the @Efl.Ui.Widget.resize_object and co-located with the widget.
All @Efl.Ui.Widget objects have this part, allowing the background of the widget to be customized.
]]
data: null;
implements {
Efl.File.file { get; set; }

12
src/lib/elementary/efl_ui_win.c
View File

@ -9472,3 +9472,15 @@ efl_ui_win_shared_data_get(Efl_Ui_Win *obj)
return &pd->spd;
}
EAPI void
efl_ui_win_autodel_set(Efl_Ui_Win *obj, Eina_Bool autodel)
{
elm_win_autodel_set(obj, autodel);
}
EAPI Eina_Bool
efl_ui_win_autodel_get(const Efl_Ui_Win *obj)
{
return elm_win_autodel_get(obj);
}

2
src/lib/elementary/elm_atspi_app_object.c
View File

@ -4,8 +4,6 @@
#define EFL_ACCESS_OBJECT_PROTECTED
#include <Elementary.h>
#include "elm_widget.h"
#include "elm_priv.h"
extern Eina_List *_elm_win_list;

1
src/lib/elementary/elm_calendar.h
View File

@ -50,6 +50,7 @@
#include "elm_calendar_common.h"
#ifndef EFL_NOLEGACY_API_SUPPORT
#include "elm_calendar_eo.legacy.h"
#include "elm_calendar_legacy.h"
#endif
/**

5
src/lib/elementary/elm_config.c
View File

@ -1733,6 +1733,11 @@ _config_system_load(void)
EINA_SAFETY_ON_FALSE_RETURN_VAL(eet_data_undump(ef, "config", embedded_config, strlen(embedded_config)-1, EINA_FALSE), NULL);
eet_close(ef);
ef = eet_open(tmp, EET_FILE_MODE_READ);
if (!ef)
{
ERR("Failed to load a fallback config file.");
return NULL;
}
cfg = eet_data_read(ef, _config_edd, "config");
eet_close(ef);
}

3
src/lib/elementary/elm_datetime.h
View File

@ -204,6 +204,7 @@
#ifndef _ELM_DATE_TIME_H
#define _ELM_DATE_TIME_H
#include <elm_clock_eo.h>
typedef enum
{
ELM_DATETIME_YEAR = 0, /**< Indicates Year field. */
@ -462,7 +463,7 @@ EAPI Eina_Bool elm_datetime_value_max_set(Evas_Object *obj, const Efl_Time *maxt
*/
EAPI Eina_Bool elm_datetime_value_max_get(const Evas_Object *obj, Efl_Time *maxtime);
#define ELM_DATETIME_EVENT_CHANGED EFL_UI_CLOCK_EVENT_CHANGED
#define ELM_DATETIME_EVENT_CHANGED ELM_CLOCK_EVENT_CHANGED
#endif
/**

3
src/lib/elementary/elm_general.h
View File

@ -1,3 +1,5 @@
#ifndef _ELM_GENERAL_H
#define _ELM_GENERAL_H
/**
* @defgroup Elm_General General
* @ingroup Elementary
@ -821,3 +823,4 @@ typedef enum
/**
* @}
*/
#endif

9
src/lib/elementary/elm_interface_scrollable.h
View File

@ -31,9 +31,8 @@
* Elm_Scrollable_Smart_Interface::extern_pan_set.
*/
#ifndef EFL_NOLEGACY_API_SUPPORT
#include "elm_pan_eo.legacy.h"
#endif
#include <elm_pan_eo.legacy.h>
#include <elm_scroller.h>
/**
* Elementary scroller panning base smart data.
@ -75,7 +74,7 @@ struct _Elm_Scrollable_Smart_Interface_Data
Elm_Scroller_Policy hbar_flags, vbar_flags;
Elm_Scroller_Single_Direction one_direction_at_a_time;
Efl_Ui_Layout_Orientation block;
Elm_Scroller_Movement_Block block;
struct
{
@ -229,7 +228,7 @@ struct _Elm_Scrollable_Smart_Interface_Data
Eina_Bool loop_h : 1;
Eina_Bool loop_v : 1;
Efl_Ui_Focus_Manager *manager;
void *manager; /* Efl_Ui_Focus_Manager */
};
#define ELM_SCROLLABLE_CHECK(obj, ...) \

12
src/lib/elementary/elm_priv.h
View File

@ -24,6 +24,7 @@
// Evas internal EO APIs
# include "Evas.h"
# include "Evas_Internal.h"
# include "Emotion.h"
#include "Elementary.h"
#include "Efl_Ui.h"
@ -153,16 +154,7 @@
#include "elm_widget_item_static_focus_eo.h"
#include "elm_win_eo.h"
# include "efl_ui_focus_parent_provider.eo.h"
# include "efl_ui_widget_focus_manager.eo.h"
# include "efl_ui_focus_parent_provider_standard.eo.h"
# include "elm_widget_item_static_focus_eo.h"
# include "efl_ui_selection_manager.eo.h"
# include "efl_datetime_manager.eo.h"
# include "efl_ui_size_model.eo.h"
# include "efl_ui_homogeneous_model.eo.h"
# include "efl_ui_exact_model.eo.h"
# include "efl_ui_average_model.eo.h"
#include "efl_ui_layout_legacy_eo.h"
extern const char *_efl_model_property_itemw;

3
src/lib/elementary/elm_scroller_legacy.h
View File

@ -1,3 +1,5 @@
#ifndef _ELM_SCROLLER_LEGACY_H
#define _ELM_SCROLLER_LEGACY_H
#ifndef _ELM_INTERFACE_SCROLLABLE_EO_TYPES
#define _ELM_INTERFACE_SCROLLABLE_EO_TYPES
@ -637,3 +639,4 @@ EAPI void elm_scroller_propagate_events_set(Evas_Object *obj, Eina_Bool propagat
* @ingroup Elm_Scroller
*/
EAPI Eina_Bool elm_scroller_propagate_events_get(const Evas_Object *obj);
#endif

5
src/lib/elementary/elm_widget.h
View File

@ -298,6 +298,11 @@
*/
#include "elm_object_item.h"
#include "efl_ui.eot.h"
typedef Eo Efl_Ui_Focus_Manager;
#define _EFL_UI_FOCUS_MANAGER_EO_CLASS_TYPE
#include "efl_ui_focus_object.eo.h"
#include "efl_ui_focus_manager.eo.h"
typedef Eina_Bool (*Elm_Widget_Del_Pre_Cb)(void *data);
typedef void (*Elm_Widget_Item_Signal_Cb)(void *data, Elm_Object_Item *item, const char *emission, const char *source);

46
src/lib/elementary/elm_win_eo.h
View File

@ -11,55 +11,11 @@
EAPI void elm_win_autodel_set(Evas_Object *obj, Eina_Bool autodel);
EAPI Eina_Bool elm_win_autodel_get(const Evas_Object *obj);
#ifdef EFL_BETA_API_SUPPORT
/**
* @brief Set the window's autodel state.
*
* When closing the window in any way outside of the program control, like
* pressing the X button in the titlebar or using a command from the Window
* Manager, a "delete,request" signal is emitted to indicate that this event
* occurred and the developer can take any action, which may include, or not,
* destroying the window object.
*
* When the @c autodel parameter is set, the window will be automatically
* destroyed when this event occurs, after the signal is emitted. If @c autodel
* is @c false, then the window will not be destroyed and is up to the program
* to do so when it's required.
*
* @param[in] obj The object.
* @param[in] autodel If @c true, the window will automatically delete itself
* when closed.
*
* Note: This function is only available in C.
*
* @ingroup Efl_Ui_Win
*/
static inline void
efl_ui_win_autodel_set(Efl_Ui_Win *obj, Eina_Bool autodel)
{
elm_win_autodel_set(obj, autodel);
}
/**
* @brief Get the window's autodel state.
*
* @param[in] obj The object.
*
* @return If @c true, the window will automatically delete itself when closed.
*
* Note: This function is only available in C.
*
* @ingroup Efl_Ui_Win
*/
static inline Eina_Bool
efl_ui_win_autodel_get(const Efl_Ui_Win *obj)
{
return elm_win_autodel_get(obj);
}
/**
* @}
*/
#endif
#endif

2
src/lib/elementary/meson.build
View File

@ -427,11 +427,11 @@ elementary_pub_headers = [
'elm_calendar.h',
'elm_calendar_legacy.h',
'elm_calendar_common.h',
'efl_ui_calendar.h',
'elm_check.h',
'efl_ui_check_eo.h',
'elm_check_legacy.h',
'elm_clock.h',
'elm_clock_eo.h',
'elm_clock_legacy.h',
'elm_cnp.h',
'elm_colorselector.h',

10
src/lib/eolian/database_validate.c
View File

@ -12,7 +12,6 @@ typedef struct _Validate_State
{
Eina_Bool warned;
Eina_Bool stable;
Eina_Bool unimplemented;
Eina_Bool unimplemented_beta;
} Validate_State;
@ -913,10 +912,6 @@ _db_check_implemented(Validate_State *vals, Eolian_Class *cl, Eina_Hash *fs,
Eina_Bool succ = EINA_TRUE;
/* unimplemented checks are not enabled for any objects */
if (!vals->unimplemented)
return EINA_TRUE;
/* class is beta and we didn't enable unimplemented checking for those */
if (!vals->unimplemented_beta && cl->base.is_beta)
return EINA_TRUE;
@ -926,8 +921,12 @@ _db_check_implemented(Validate_State *vals, Eolian_Class *cl, Eina_Hash *fs,
EINA_LIST_FOREACH(cl->callables, l, impl)
{
const Eolian_Function *fid = impl->foo_id;
/* not checking beta and the function is beta: skip */
if (!vals->unimplemented_beta && fid->base.is_beta)
continue;
/* not checking beta and the function's class is beta: skip */
if (!vals->unimplemented_beta && fid->klass->base.is_beta)
continue;
Impl_Status st = (Impl_Status)eina_hash_find(fs, &fid);
/* found an interface this func was originally defined in in the
* composite list; in that case, ignore it and assume it will come
@ -1476,7 +1475,6 @@ database_validate(const Eolian_Unit *src)
Validate_State vals = {
EINA_FALSE,
EINA_TRUE,
!!getenv("EOLIAN_CLASS_UNIMPLEMENTED_WARN"),
!!getenv("EOLIAN_CLASS_UNIMPLEMENTED_BETA_WARN")
};

33
src/lib/eolian/eo_parser.c
View File

@ -1077,7 +1077,7 @@ end:
static void
parse_param(Eo_Lexer *ls, Eina_List **params, Eina_Bool allow_inout,
Eina_Bool is_vals)
Eina_Bool is_vals, const Eolian_Function *func)
{
Eina_Bool has_optional = EINA_FALSE,
has_owned = EINA_FALSE,
@ -1107,10 +1107,17 @@ parse_param(Eo_Lexer *ls, Eina_List **params, Eina_Bool allow_inout,
par->base.name = eina_stringshare_ref(ls->t.value.s);
eo_lexer_get(ls);
check_next(ls, ':');
if (par->param_dir == EOLIAN_OUT_PARAM || par->param_dir == EOLIAN_INOUT_PARAM)
par->type = eo_lexer_type_release(ls, parse_type_void(ls, EINA_TRUE));
else
par->type = eo_lexer_type_release(ls, parse_type(ls, EINA_TRUE));
if ((ls->klass && ls->klass->base.is_beta) || func->base.is_beta)
{
if (par->param_dir == EOLIAN_OUT_PARAM || par->param_dir == EOLIAN_INOUT_PARAM)
{
/* void is allowed for out/inout for beta-api for now to make a voidptr */
par->type = eo_lexer_type_release(ls, parse_type_void(ls, EINA_TRUE));
goto type_done;
}
}
par->type = eo_lexer_type_release(ls, parse_type(ls, EINA_TRUE));
type_done:
if ((is_vals || (par->param_dir == EOLIAN_OUT_PARAM)) && (ls->t.token == '('))
{
int line = ls->line_number, col = ls->column;
@ -1148,14 +1155,14 @@ end:
static void
parse_params(Eo_Lexer *ls, Eina_List **params, Eina_Bool allow_inout,
Eina_Bool is_vals)
Eina_Bool is_vals, const Eolian_Function *func)
{
int line, col;
eo_lexer_get(ls);
line = ls->line_number, col = ls->column;
check_next(ls, '{');
while (ls->t.token != '}')
parse_param(ls, params, allow_inout, is_vals);
parse_param(ls, params, allow_inout, is_vals, func);
check_match(ls, '}', '{', line, col);
}
@ -1268,7 +1275,7 @@ parse_accessor:
Eina_List **stor;
CASE_LOCK(ls, keys, "keys definition")
stor = is_get ? &prop->prop_keys_get : &prop->prop_keys_set;
parse_params(ls, stor, EINA_FALSE, EINA_FALSE);
parse_params(ls, stor, EINA_FALSE, EINA_FALSE, prop);
break;
}
case KW_values:
@ -1276,7 +1283,7 @@ parse_accessor:
Eina_List **stor;
CASE_LOCK(ls, values, "values definition")
stor = is_get ? &prop->prop_values_get : &prop->prop_values_set;
parse_params(ls, stor, EINA_FALSE, EINA_TRUE);
parse_params(ls, stor, EINA_FALSE, EINA_TRUE, prop);
break;
}
default:
@ -1377,11 +1384,11 @@ body:
break;
case KW_keys:
CASE_LOCK(ls, keys, "keys definition")
parse_params(ls, &prop->prop_keys, EINA_FALSE, EINA_FALSE);
parse_params(ls, &prop->prop_keys, EINA_FALSE, EINA_FALSE, prop);
break;
case KW_values:
CASE_LOCK(ls, values, "values definition")
parse_params(ls, &prop->prop_values, EINA_FALSE, EINA_TRUE);
parse_params(ls, &prop->prop_values, EINA_FALSE, EINA_TRUE, prop);
break;
default:
goto end;
@ -1478,7 +1485,7 @@ tags_done:
break;
case KW_params:
CASE_LOCK(ls, params, "params definition");
parse_params(ls, &meth->params, EINA_TRUE, EINA_FALSE);
parse_params(ls, &meth->params, EINA_TRUE, EINA_FALSE, meth);
break;
default:
goto end;
@ -1576,7 +1583,7 @@ body:
break;
case KW_params:
CASE_LOCK(ls, params, "params definition")
parse_params(ls, &meth->params, EINA_TRUE, EINA_FALSE);
parse_params(ls, &meth->params, EINA_TRUE, EINA_FALSE, meth);
break;
default:
goto end;

4
src/lib/evas/canvas/efl_canvas_image_internal.eo
View File

@ -15,8 +15,8 @@ abstract @beta Efl.Canvas.Image_Internal extends Efl.Canvas.Object implements Ef
Efl.Gfx.Image.smooth_scale { get; set; }
Efl.Gfx.Image.ratio { get; }
Efl.Gfx.Image.content_region { get; }
Efl.Gfx.Image.border { get; set; }
Efl.Gfx.Image.border_scale { get; set; }
Efl.Gfx.Image.border_insets { get; set; }
Efl.Gfx.Image.border_insets_scale { get; set; }
Efl.Gfx.Image.center_fill_mode { get; set; }
Efl.Gfx.Image.stretch_region { get; set; }
Efl.Gfx.Image.scale_hint { get; set; }

2
src/lib/evas/canvas/evas_callbacks.c
View File

@ -359,6 +359,8 @@ _evas_callback_legacy_smart_compatibility_do_it(Evas_Object *eo_obj, const Efl_E
/* this is inverted: the base call is the legacy compat and this is the new event */
else if ((efl_event_desc == EFL_GFX_ENTITY_EVENT_SHOW) || (efl_event_desc == EFL_GFX_ENTITY_EVENT_HIDE))
efl_event_callback_call(eo_obj, EFL_GFX_ENTITY_EVENT_VISIBILITY_CHANGED, event_info);
else if ((efl_event_desc == EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD) || (efl_event_desc == EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD))
efl_event_callback_call(eo_obj, EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD_STATE_CHANGED, event_info);
}

8
src/lib/evas/canvas/evas_image_legacy.c
View File

@ -117,28 +117,28 @@ EAPI void
evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b)
{
EVAS_IMAGE_API(obj);
efl_gfx_image_border_set(obj, l, r, t, b);
efl_gfx_image_border_insets_set(obj, l, r, t, b);
}
EAPI void
evas_object_image_border_get(const Evas_Object *obj, int *l, int *r, int *t, int *b)
{
EVAS_IMAGE_API(obj);
efl_gfx_image_border_get(obj, l, r, t, b);
efl_gfx_image_border_insets_get(obj, l, r, t, b);
}
EAPI void
evas_object_image_border_scale_set(Evas_Object *obj, double scale)
{
EVAS_IMAGE_API(obj);
efl_gfx_image_border_scale_set(obj, scale);
efl_gfx_image_border_insets_scale_set(obj, scale);
}
EAPI double
evas_object_image_border_scale_get(const Evas_Object *obj)
{
EVAS_IMAGE_API(obj, 0.0);
return efl_gfx_image_border_scale_get(obj);
return efl_gfx_image_border_insets_scale_get(obj);
}
EAPI void

8
src/lib/evas/canvas/evas_object_image.c
View File

@ -590,7 +590,7 @@ _efl_canvas_image_internal_efl_gfx_image_content_region_get(const Eo *eo_obj, Ev
}
EOLIAN static void
_efl_canvas_image_internal_efl_gfx_image_border_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int b)
_efl_canvas_image_internal_efl_gfx_image_border_insets_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int b)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
@ -617,7 +617,7 @@ _efl_canvas_image_internal_efl_gfx_image_border_set(Eo *eo_obj, Evas_Image_Data
}
EOLIAN static void
_efl_canvas_image_internal_efl_gfx_image_border_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *l, int *r, int *t, int *b)
_efl_canvas_image_internal_efl_gfx_image_border_insets_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *l, int *r, int *t, int *b)
{
if (l) *l = o->cur->border.l;
if (r) *r = o->cur->border.r;
@ -956,7 +956,7 @@ _efl_canvas_image_internal_efl_gfx_fill_fill_auto_get(const Eo *eo_obj EINA_UNUS
}
EOLIAN static void
_efl_canvas_image_internal_efl_gfx_image_border_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale)
_efl_canvas_image_internal_efl_gfx_image_border_insets_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
@ -971,7 +971,7 @@ _efl_canvas_image_internal_efl_gfx_image_border_scale_set(Eo *eo_obj, Evas_Image
}
EOLIAN static double
_efl_canvas_image_internal_efl_gfx_image_border_scale_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_efl_canvas_image_internal_efl_gfx_image_border_insets_scale_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->border.scale;
}

10
src/lib/evas/canvas/evas_object_inform.c
View File

@ -7,6 +7,10 @@ EWAPI const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_SHOW =
EFL_EVENT_DESCRIPTION("show");
EWAPI const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_HIDE =
EFL_EVENT_DESCRIPTION("hide");
EWAPI const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_IMAGE_PRELOAD =
EFL_EVENT_DESCRIPTION("preload");
EWAPI const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_IMAGE_UNLOAD =
EFL_EVENT_DESCRIPTION("unload");
/* END: events to maintain compatibility with legacy */
/* local calls */
@ -94,8 +98,9 @@ evas_object_inform_call_image_preloaded(Evas_Object *eo_obj)
and mimic as it finished preloading done. */
(preload & EVAS_IMAGE_PRELOAD_CANCEL))
{
Eina_Bool val = EINA_TRUE;
event_id = _evas_object_event_new();
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_PRELOADED, NULL, event_id, EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD);
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_PRELOADED, &val, event_id, EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD);
_evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas, event_id);
}
}
@ -105,8 +110,9 @@ evas_object_inform_call_image_unloaded(Evas_Object *eo_obj)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
int event_id = _evas_object_event_new();
Eina_Bool val = EINA_FALSE;
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_UNLOADED, NULL, event_id, EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD);
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_UNLOADED, &val, event_id, EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD);
_evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas, event_id);
}

1
src/lib/evas/canvas/evas_object_intercept.c
View File

@ -48,6 +48,7 @@ void
evas_object_intercept_cleanup(Evas_Object *eo_obj)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
if (!obj) return;
if (obj->interceptors) free(obj->interceptors);
}

8
src/lib/evas/gesture/efl_gesture_events.eo
View File

@ -4,10 +4,10 @@ interface @beta Efl.Gesture.Events
events {
gesture,tap: Efl.Canvas.Gesture_Tap; [[Event for tap gesture]]
gesture,double_tap: Efl.Canvas.Gesture_Double_Tap; [[Event for double tap gesture]]
gesture,triple_tap: Efl.Canvas.Gesture_Triple_Tap; [[Event for triple tap gesture]]
gesture,long_tap: Efl.Canvas.Gesture_Long_Tap; [[Event for long tap gesture]]
gesture,triple_tap: Efl.Canvas.Gesture_Triple_Tap; [[Event for triple tap gesture]]
gesture,long_tap: Efl.Canvas.Gesture_Long_Tap; [[Event for long tap gesture]]
gesture,momentum: Efl.Canvas.Gesture_Momentum; [[Event for momentum gesture]]
gesture,flick: Efl.Canvas.Gesture_Flick; [[Event for flick gesture]]
gesture,zoom: Efl.Canvas.Gesture_Zoom; [[Event for zoom gesture]]
gesture,flick: Efl.Canvas.Gesture_Flick; [[Event for flick gesture]]
gesture,zoom: Efl.Canvas.Gesture_Zoom; [[Event for zoom gesture]]
}
}

4
src/lib/evas/include/evas_private.h
View File

@ -1966,6 +1966,10 @@ EWAPI extern const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_SHOW;
#define EFL_GFX_ENTITY_EVENT_SHOW (&(_EFL_GFX_ENTITY_EVENT_SHOW))
EWAPI extern const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_HIDE;
#define EFL_GFX_ENTITY_EVENT_HIDE (&(_EFL_GFX_ENTITY_EVENT_HIDE))
EWAPI extern const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_IMAGE_PRELOAD;
#define EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD (&(_EFL_GFX_ENTITY_EVENT_IMAGE_PRELOAD))
EWAPI extern const Efl_Event_Description _EFL_GFX_ENTITY_EVENT_IMAGE_UNLOAD;
#define EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD (&(_EFL_GFX_ENTITY_EVENT_IMAGE_UNLOAD))
/* END: events to maintain compatibility with legacy */
/****************************************************************************/

15
src/modules/eina/mp/chained_pool/eina_chained_mempool.c
View File

@ -189,7 +189,7 @@ _eina_chained_mempool_alloc_in(Chained_Mempool *pool, Chained_Pool *p)
mem = p->last;
p->last += pool->item_alloc;
if (p->last >= p->limit)
p->last = NULL;
p->last = NULL;
}
else
{
@ -199,11 +199,11 @@ _eina_chained_mempool_alloc_in(Chained_Mempool *pool, Chained_Pool *p)
// Request a free pointer
mem = eina_trash_pop(&p->base);
}
// move to end - it just filled up
if (!p->base && !p->last)
pool->first = eina_inlist_demote(pool->first, EINA_INLIST_GET(p));
p->usage++;
pool->usage++;
@ -411,6 +411,15 @@ eina_chained_mempool_from(void *data, void *ptr)
goto end;
}
// is the pointer in the allocated zone of the mempool
if (p->last != NULL && ((unsigned char *)ptr >= p->last))
{
#ifdef DEBUG
ERR("%p has not been allocated yet from %p pool of %p '%s' Chained_Mempool.", ptr, p, pool, pool->name);
#endif
goto end;
}
// is it really a pointer returned by malloc
if ((((unsigned char *)ptr) - (unsigned char *)(p + 1)) % pool->item_alloc)
{

3
src/modules/eina/mp/one_big/eina_one_big.c
View File

@ -32,6 +32,7 @@
#include "eina_log.h"
#include "eina_lock.h"
#include "eina_thread.h"
#include "eina_cpu.h"
#ifndef NVALGRIND
# include <memcheck.h>
@ -288,7 +289,7 @@ eina_one_big_init(const char *context,
item_size = va_arg(args, int);
if (item_size < 1) item_size = 1;
pool->item_size = eina_mempool_alignof(item_size);
pool->item_size = MAX(eina_mempool_alignof(item_size), sizeof(void*));
pool->max = va_arg(args, int);
if (pool->max < 1) pool->max = 1;

18
src/modules/evas/vg_loaders/svg/evas_vg_load_svg.c
View File

@ -84,7 +84,7 @@ _parse_number(const char **content, double *number)
{
char *end = NULL;
*number = strtod(*content, &end);
*number = eina_convert_strtod_c(*content, &end);
// if the start of string is not number
if ((*content) == end) return EINA_FALSE;
//skip comma if any
@ -102,7 +102,7 @@ _parse_number(const char **content, double *number)
static inline double
_to_double(Evas_SVG_Parser *svg_parse, const char *str, SVG_Parser_Length_Type type)
{
double parsed_value = strtod(str, NULL);
double parsed_value = eina_convert_strtod_c(str, NULL);
if (strstr(str, "cm"))
parsed_value = parsed_value * 35.43307;
@ -141,7 +141,7 @@ _gradient_to_double(Evas_SVG_Parser *svg_parse, const char *str, SVG_Parser_Leng
{
char *end = NULL;
double parsed_value = strtod(str, &end);
double parsed_value = eina_convert_strtod_c(str, &end);
double max = 1;
/**
@ -182,7 +182,7 @@ _to_offset(const char *str)
{
char *end = NULL;
double parsed_value = strtod(str, &end);
double parsed_value = eina_convert_strtod_c(str, &end);
if (strstr(str, "%"))
parsed_value = parsed_value / 100.0;
@ -195,7 +195,7 @@ _to_opacity(const char *str)
{
char *end = NULL;
int a = 0;
double opacity = strtod(str, &end);
double opacity = eina_convert_strtod_c(str, &end);
if (*end == '\0')
a = lrint(opacity * 255);
@ -277,7 +277,7 @@ _parse_dash_array(const char *str, Efl_Gfx_Dash** dash, int *length)
{
// skip white space, comma
str = _skipcomma(str);
tmp[count++] = strtod(str, &end);
tmp[count++] = eina_convert_strtod_c(str, &end);
str = _skipcomma(end);
}
@ -337,7 +337,7 @@ _color_parser(const char *value, char **end)
{
double r;
r = strtod(value + 4, end);
r = eina_convert_strtod_c(value + 4, end);
*end = _skip_space(*end, NULL);
if (**end == '%')
r = 255 * r / 100;
@ -590,7 +590,7 @@ parse_numbers_array(char *str, double *points, int *pt_count)
*str == '+' ||
*str == '.')
{
points[count++] = strtod(str, &end);
points[count++] = eina_convert_strtod_c(str, &end);
str = end;
str = _skip_space(str, NULL);
if (*str == ',')
@ -758,7 +758,7 @@ parse_length(const char *str, Svg_Length_Type *type)
{
*type = length_tags[i].type;
}
value = strtod(str, NULL);
value = eina_convert_strtod_c(str, NULL);
return value;
}

2
src/tests/ecore_wl2/ecore_wl2_test_display.c
View File

@ -159,6 +159,8 @@ EFL_START_TEST(wl2_display_inputs_get)
itr = ecore_wl2_display_inputs_get(disp);
ck_assert(itr != NULL);
eina_iterator_free(itr);
}
EFL_END_TEST

1
src/tests/efl/efl_test_composite_model.c
View File

@ -27,7 +27,6 @@
static const int child_number = 3;
static const int base_ints[] = { 41, 42, 43 };
static const Eina_Bool base_selections[] = { EINA_FALSE, EINA_FALSE, EINA_TRUE };
static Eina_Value
_children_slice_get_then(void *data EINA_UNUSED,

22
src/tests/efl_mono/dummy_test_object.c
View File

@ -16,6 +16,8 @@ typedef struct Dummy_Test_Object_Data
Eina_List *list_for_accessor;
int setter_only;
int iface_prop;
int protected_prop;
int public_getter_private_setter;
Eo *provider;
Eo *iface_provider;
int prop1;
@ -4672,6 +4674,26 @@ int _dummy_test_object_get_setter_only(EINA_UNUSED Eo *obj, Dummy_Test_Object_Da
return pd->setter_only;
}
void _dummy_test_object_dummy_test_iface_protected_prop_set(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, int value)
{
pd->protected_prop = value;
}
int _dummy_test_object_dummy_test_iface_protected_prop_get(EINA_UNUSED const Eo *obj, Dummy_Test_Object_Data *pd)
{
return pd->protected_prop;
}
void _dummy_test_object_dummy_test_iface_public_getter_private_setter_set(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, int value)
{
pd->public_getter_private_setter = value;
}
int _dummy_test_object_dummy_test_iface_public_getter_private_setter_get(EINA_UNUSED const Eo *obj, Dummy_Test_Object_Data *pd)
{
return pd->public_getter_private_setter;
}
void _dummy_test_object_dummy_test_iface_iface_prop_set(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, int value)
{
pd->iface_prop = value;

3
src/tests/efl_mono/dummy_test_object.eo
View File

@ -1653,6 +1653,9 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
Efl.Object.provider_find;
Dummy.Test_Iface.emit_nonconflicted;
Dummy.Test_Iface.iface_prop { get; set; }
Dummy.Test_Iface.protected_prop { get; set; }
Dummy.Test_Iface.public_getter_private_setter{ get; set; }
Dummy.Test_Iface.static_prop{ get; set; }
Dummy.Test_Iface.method_protected;
Dummy.Test_Iface.call_method_protected;
}

14
src/tests/eina/eina_test_mempool.c
View File

@ -88,6 +88,17 @@ EFL_START_TEST(eina_mempool_pass_through)
EFL_END_TEST
#endif
#ifdef EINA_BUILD_ONE_BIG
EFL_START_TEST(eina_mempool_one_big)
{
Eina_Mempool *mp;
mp = eina_mempool_add("one_big", "test", NULL, sizeof (int), 384);
_eina_mempool_test(mp, EINA_FALSE, EINA_FALSE, EINA_TRUE);
}
EFL_END_TEST
#endif
void
eina_test_mempool(TCase *tc)
{
@ -97,4 +108,7 @@ eina_test_mempool(TCase *tc)
#ifdef EINA_BUILD_PASS_THROUGH
tcase_add_test(tc, eina_mempool_pass_through);
#endif
#ifdef EINA_BUILD_ONE_BIG
tcase_add_test(tc, eina_mempool_one_big);
#endif
}

14
src/tests/elementary/efl_ui_test_box.c
View File

@ -418,8 +418,12 @@ EFL_START_TEST (efl_ui_box_pack_unpack)
ck_assert(efl_pack(layout, btn[1]));
ck_assert_ptr_eq(efl_pack_content_get(layout, 0), btn[1]);
ck_assert_int_eq(efl_pack_index_get(layout, btn[1]), 0);
EXPECT_ERROR_START;
ck_assert(!efl_pack_end(layout, btn[1]));
EXPECT_ERROR_END;
EXPECT_ERROR_START;
ck_assert(!efl_pack(layout, NULL));
EXPECT_ERROR_END;
ck_assert(efl_pack_after(layout, btn[3], btn[1]));
ck_assert_ptr_eq(efl_pack_content_get(layout, 1), btn[3]);
ck_assert_int_eq(efl_pack_index_get(layout, btn[3]), 1);
@ -428,8 +432,12 @@ EFL_START_TEST (efl_ui_box_pack_unpack)
ck_assert_int_eq(efl_pack_index_get(layout, btn[5]), 2);
ck_assert_ptr_eq(efl_pack_content_get(layout, -1), btn[5]);
ck_assert_int_eq(efl_pack_index_get(layout, btn[5]), 2);
EXPECT_ERROR_START;
ck_assert(!efl_pack_after(layout, btn[5], NULL));
EXPECT_ERROR_END;
EXPECT_ERROR_START;
ck_assert(!efl_pack_after(layout, NULL, btn[5]));
EXPECT_ERROR_END;
ck_assert(efl_pack_before(layout, btn[4], btn[5]));
ck_assert(efl_pack_begin(layout, btn[0]));
ck_assert_ptr_eq(efl_pack_content_get(layout, 0), btn[0]);
@ -462,15 +470,21 @@ EFL_START_TEST (efl_ui_box_pack_unpack)
//unpack test
ck_assert_ptr_eq(efl_pack_unpack_at(layout, 2), btn[2]);
EXPECT_ERROR_START;
ck_assert(!efl_pack_unpack(layout, btn[2]));
EXPECT_ERROR_END;
efl_pack_at(layout, btn[2], 2);
ck_assert(efl_pack_unpack(layout, efl_pack_content_get(layout, 2)));
EXPECT_ERROR_START;
ck_assert(!efl_pack_unpack(layout, btn[2]));
EXPECT_ERROR_END;
efl_pack_at(layout, btn[2], 2);
ck_assert_ptr_eq(efl_pack_unpack_at(layout, efl_pack_index_get(layout, btn[2])), btn[2]);
EXPECT_ERROR_START;
ck_assert(!efl_pack_unpack(layout, NULL));
EXPECT_ERROR_END;
ck_assert_int_eq(efl_content_count(layout), BTN_NUM - 1);
efl_pack_unpack_all(layout);

3
src/tests/elementary/efl_ui_test_table.c
View File

@ -457,8 +457,9 @@ EFL_START_TEST (efl_ui_table_pack_table)
//unpack test
ck_assert(efl_pack_unpack(layout, btn[2]));
EXPECT_ERROR_START;
ck_assert(!efl_pack_unpack(layout, btn[2]));
EXPECT_ERROR_END;
efl_pack_unpack_all(layout);
ck_assert_int_eq(efl_content_count(layout), 0);
ck_assert(!efl_invalidated_get(btn[0]));

38
src/tests/elementary/elm_test_check.c
View File

@ -49,10 +49,45 @@ EFL_START_TEST(elm_test_check_onoff_text)
}
EFL_END_TEST
EFL_START_TEST(elm_test_check_callbacks)
{
Evas_Object *win, *check;
int called = 0;
int i;
win = win_add(NULL, "check", ELM_WIN_BASIC);
evas_object_resize(win, 500, 500);
check = elm_check_add(win);
if (_i)
elm_object_style_set(check, "toggle");
elm_object_text_set(check, "TEST TEST TEST");
evas_object_smart_callback_add(check, "changed", event_callback_single_call_int_data, &called);
evas_object_resize(check, 200, 100);
evas_object_show(win);
evas_object_show(check);
get_me_to_those_events(check);
for (i = 0; i < 4; i++)
{
called = 0;
if (_i)
click_object_at(check, 150, 50);
else
click_object(check);
ecore_main_loop_iterate();
ck_assert_int_eq(elm_check_state_get(check), !(i % 2));
ck_assert_int_eq(called, 1);
}
}
EFL_END_TEST
EFL_START_TEST(elm_test_check_state)
{
Evas_Object *win, *check;
Eina_Bool state = EINA_TRUE;
int called = 0;
win = win_add(NULL, "check", ELM_WIN_BASIC);
@ -61,9 +96,11 @@ EFL_START_TEST(elm_test_check_state)
ck_assert(elm_check_state_get(check) == EINA_TRUE);
ck_assert(state == EINA_TRUE);
evas_object_smart_callback_add(check, "changed", event_callback_single_call_int_data, &called);
elm_check_state_set(check, EINA_FALSE);
ck_assert(elm_check_state_get(check) == EINA_FALSE);
ck_assert(state == EINA_FALSE);
ck_assert_int_eq(called, 0);
}
EFL_END_TEST
@ -88,5 +125,6 @@ void elm_test_check(TCase *tc)
tcase_add_test(tc, elm_test_check_legacy_type_check);
tcase_add_test(tc, elm_test_check_onoff_text);
tcase_add_test(tc, elm_test_check_state);
tcase_add_loop_test(tc, elm_test_check_callbacks, 0, 2);
tcase_add_test(tc, elm_atspi_role_get);
}

2
src/tests/elementary/elm_test_widget_focus.c
View File

@ -93,7 +93,7 @@ static Evas_Object*
_custom_progressbar(Evas_Object *win)
{
Evas_Object *o = elm_progressbar_add(win);
efl_ui_widget_focus_allow_set(o, EINA_TRUE);
elm_object_focus_allow_set(o, EINA_TRUE);
return o;
}

33
src/tests/elementary/spec/efl_test_multi_selectable.c
View File

@ -135,38 +135,6 @@ EFL_START_TEST(test_single_select)
}
EFL_END_TEST
EFL_START_TEST(test_single_select_always)
{
int c = 0;
Eina_Array *arr_selected;
efl_ui_select_mode_set(widget, EFL_UI_SELECT_MODE_SINGLE_ALWAYS);
efl_event_callback_add(widget, EFL_UI_SINGLE_SELECTABLE_EVENT_SELECTION_CHANGED, (void*) event_callback_single_call_int_data, &c);
efl_event_callback_add(widget, EFL_UI_SINGLE_SELECTABLE_EVENT_SELECTION_CHANGED, event_callback_that_quits_the_main_loop_when_called, NULL);
efl_ui_selectable_selected_set(efl_pack_content_get(widget, 0), EINA_TRUE);
if (c == 0) efl_loop_begin(efl_main_loop_get());
ck_assert_int_eq(c, 1);
c = 0;
efl_ui_selectable_selected_set(efl_pack_content_get(widget, 2), EINA_TRUE);
if (c == 0) efl_loop_begin(efl_main_loop_get());
ck_assert_int_eq(c, 1);
c = 0;
efl_ui_selectable_selected_set(efl_pack_content_get(widget, 2), EINA_TRUE);
if (c == 0) efl_loop_begin(efl_main_loop_get());
ck_assert_int_eq(c, 1);
c = 0;
ck_assert_int_eq(efl_ui_selectable_selected_get(efl_pack_content_get(widget, 0)), EINA_FALSE);
ck_assert_int_eq(efl_ui_selectable_selected_get(efl_pack_content_get(widget, 2)), EINA_TRUE);
ck_assert_ptr_eq(efl_ui_single_selectable_last_selected_get(widget), efl_pack_content_get(widget, 2));
_iterator_to_array(&arr_selected, efl_ui_selected_items_get(widget));
ck_assert_int_eq(eina_array_count(arr_selected), 1);
ck_assert_ptr_eq(eina_array_data_get(arr_selected, 0), efl_pack_content_get(widget, 2));
efl_event_callback_del(widget, EFL_UI_SINGLE_SELECTABLE_EVENT_SELECTION_CHANGED, (void*) event_callback_single_call_int_data, &c);
efl_event_callback_del(widget, EFL_UI_SINGLE_SELECTABLE_EVENT_SELECTION_CHANGED, event_callback_that_quits_the_main_loop_when_called, NULL);
}
EFL_END_TEST
EFL_START_TEST(test_none_select)
{
Efl_Ui_Item *selected = NULL;
@ -290,7 +258,6 @@ efl_ui_multi_selectable_behavior_test(TCase *tc)
tcase_add_test(tc, test_multi_select_removal);
tcase_add_test(tc, test_single_select);
tcase_add_test(tc, test_none_select);
tcase_add_test(tc, test_single_select_always);
tcase_add_test(tc, select_all_api);
tcase_add_test(tc, unselect_all_api);
tcase_add_test(tc, unselect_range);

4
src/tests/eolian/data/object_impl_add.eo
View File

@ -13,4 +13,8 @@ class Object_Impl_Add extends Base {
}
}
}
implements {
Base.constructor;
}
}

6
src/tests/eolian/data/object_impl_add_ref.c
View File

@ -87,4 +87,10 @@ _object_impl_add_c_get(const Eo *obj, Object_Impl_Data *pd)
}
EOLIAN static void
_object_impl_add_base_constructor(Eo *obj, Object_Impl_Data *pd)
{
}
#include "object_impl_add.eo.c"

4
src/tests/eolian/data/parts.eo
View File

@ -3,4 +3,8 @@ class Parts extends Override {
part1: Override; [[Part 1]]
part2 @beta: Parts; [[Part 2]]
}
implements {
Override.a { set; }
Override.foo;
}
}

2
src/tests/evas/evas_test_image.c
View File

@ -737,7 +737,7 @@ EFL_START_TEST(evas_object_image_cached_data_comparision)
ck_assert_int_eq(region.y, 0);
ck_assert_int_eq(region.w, 250);
ck_assert_int_eq(region.h, 250);
efl_gfx_image_border_set(img, 7, 14, 5, 10);
efl_gfx_image_border_insets_set(img, 7, 14, 5, 10);
region = efl_gfx_image_content_region_get(img);
ck_assert_int_eq(region.x, 7);
ck_assert_int_eq(region.y, 5);