summaryrefslogtreecommitdiff
path: root/src/lib/ecore
diff options
context:
space:
mode:
authorCedric BAIL <cedric.bail@free.fr>2019-04-03 17:25:06 -0700
committerCedric BAIL <cedric.bail@free.fr>2019-05-10 11:00:31 -0700
commitfd35f6c193a7da2ad600e723f16308a5499fd6f4 (patch)
treef761b48cc3f5f393bc7fd87ad4afc23353165212 /src/lib/ecore
parent7b44b02e1089689e429f420b4c1dce8ab0c25fea (diff)
ecore: add Efl.Filter_Model
This model provide facility to filter the content of composited model. Reviewed-by: SangHyeon Jade Lee <sh10233.lee@samsung.com> Differential Revision: https://phab.enlightenment.org/D8797
Diffstat (limited to 'src/lib/ecore')
-rw-r--r--src/lib/ecore/Ecore_Eo.h1
-rw-r--r--src/lib/ecore/efl_filter_model.c569
-rw-r--r--src/lib/ecore/efl_filter_model.eo31
-rw-r--r--src/lib/ecore/meson.build2
4 files changed, 603 insertions, 0 deletions
diff --git a/src/lib/ecore/Ecore_Eo.h b/src/lib/ecore/Ecore_Eo.h
index 6e872d9d2c..363868c1a4 100644
--- a/src/lib/ecore/Ecore_Eo.h
+++ b/src/lib/ecore/Ecore_Eo.h
@@ -119,6 +119,7 @@ EAPI Eo *efl_main_loop_get(void);
119#include "efl_composite_model.eo.h" 119#include "efl_composite_model.eo.h"
120#include "efl_boolean_model.eo.h" 120#include "efl_boolean_model.eo.h"
121#include "efl_select_model.eo.h" 121#include "efl_select_model.eo.h"
122#include "efl_filter_model.eo.h"
122#include "efl_view_model.eo.h" 123#include "efl_view_model.eo.h"
123 124
124/** 125/**
diff --git a/src/lib/ecore/efl_filter_model.c b/src/lib/ecore/efl_filter_model.c
new file mode 100644
index 0000000000..9f2511cfa0
--- /dev/null
+++ b/src/lib/ecore/efl_filter_model.c
@@ -0,0 +1,569 @@
1#ifdef HAVE_CONFIG_H
2# include <config.h>
3#endif
4
5#include <Efl_Core.h>
6
7#include "efl_composite_model_private.h"
8
9typedef struct _Efl_Filter_Model_Mapping Efl_Filter_Model_Mapping;
10struct _Efl_Filter_Model_Mapping
11{
12 EINA_RBTREE;
13
14 uint64_t original;
15 uint64_t mapped;
16
17 EINA_REFCOUNT;
18};
19
20typedef struct _Efl_Filter_Model_Data Efl_Filter_Model_Data;
21struct _Efl_Filter_Model_Data
22{
23 Efl_Filter_Model_Mapping *self;
24
25 Eina_Rbtree *mapping;
26
27 struct {
28 void *data;
29 EflFilterModel cb;
30 Eina_Free_Cb free_cb;
31 uint64_t count;
32 } filter;
33
34 uint64_t counted;
35 Eina_Bool counting_started : 1;
36 Eina_Bool processed : 1;
37};
38
39static Eina_Rbtree_Direction
40_filter_mapping_cmp_cb(const Eina_Rbtree *left, const Eina_Rbtree *right, void *data EINA_UNUSED)
41{
42 const Efl_Filter_Model_Mapping *l, *r;
43
44 l = (const Efl_Filter_Model_Mapping *) left;
45 r = (const Efl_Filter_Model_Mapping *) right;
46
47 if (l->mapped < r->mapped)
48 return EINA_RBTREE_LEFT;
49 return EINA_RBTREE_RIGHT;
50}
51
52static int
53_filter_mapping_looking_cb(const Eina_Rbtree *node, const void *key,
54 int length EINA_UNUSED, void *data EINA_UNUSED)
55{
56 const Efl_Filter_Model_Mapping *n = (const Efl_Filter_Model_Mapping *) node;
57 const uint64_t *k = key;
58
59 return n->mapped - *k;
60}
61
62static void
63_efl_filter_model_filter_set(Eo *obj EINA_UNUSED, Efl_Filter_Model_Data *pd,
64 void *filter_data, EflFilterModel filter, Eina_Free_Cb filter_free_cb)
65{
66 if (pd->filter.cb)
67 pd->filter.free_cb(pd->filter.data);
68 pd->filter.data = filter_data;
69 pd->filter.cb = filter;
70 pd->filter.free_cb = filter_free_cb;
71}
72
73static void
74_rbtree_free_cb(Eina_Rbtree *node, void *data EINA_UNUSED)
75{
76 Efl_Filter_Model_Mapping *m = (Efl_Filter_Model_Mapping*) node;
77
78 EINA_REFCOUNT_UNREF(m)
79 free(m);
80}
81
82typedef struct _Efl_Filter_Request Efl_Filter_Request;
83struct _Efl_Filter_Request
84{
85 Efl_Filter_Model_Data *pd;
86 Efl_Model *parent;
87 Efl_Model *child;
88 uint64_t index;
89};
90
91static Efl_Filter_Model *
92_efl_filter_lookup(const Efl_Class *klass,
93 Efl_Model *parent, Efl_Model *view,
94 Efl_Filter_Model_Mapping *mapping)
95{
96 Efl_Filter_Model *child;
97 Efl_Filter_Model_Data *cpd;
98
99 child = _efl_composite_lookup(klass, parent, view, mapping->mapped);
100 if (!child) return NULL;
101
102 cpd = efl_data_scope_get(child, EFL_FILTER_MODEL_CLASS);
103 cpd->processed = EINA_TRUE;
104 cpd->self = mapping;
105 EINA_REFCOUNT_REF(mapping);
106
107 return child;
108}
109
110static Eina_Value
111_efl_filter_model_filter(Eo *o EINA_UNUSED, void *data, const Eina_Value v)
112{
113 Efl_Filter_Model_Mapping *mapping;
114 Efl_Filter_Model *child;
115 Efl_Model_Children_Event cevt = { 0 };
116 Efl_Filter_Request *r = data;
117 Eina_Value ret = v;
118 Eina_Bool result = EINA_FALSE;
119
120 if (!eina_value_bool_get(&v, &result)) goto end;
121 if (!result) goto end;
122
123 mapping = calloc(1, sizeof (Efl_Filter_Model_Mapping));
124 if (!mapping)
125 {
126 ret = eina_value_bool_init(EINA_FALSE);
127 goto end;
128 }
129 EINA_REFCOUNT_INIT(mapping);
130
131 mapping->original = r->index;
132 mapping->mapped = r->pd->filter.count++;
133
134 r->pd->mapping = eina_rbtree_inline_insert(r->pd->mapping, EINA_RBTREE_GET(mapping),
135 _filter_mapping_cmp_cb, NULL);
136
137 child = _efl_filter_lookup(efl_class_get(r->parent), r->parent, r->child, mapping);
138 if (!child) goto end;
139
140 cevt.index = mapping->mapped;
141 cevt.child = child;
142
143 efl_event_callback_call(r->parent, EFL_MODEL_EVENT_CHILD_ADDED, &cevt);
144 efl_event_callback_call(r->parent, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, NULL);
145
146 efl_unref(cevt.child);
147
148 ret = eina_value_bool_init(EINA_TRUE);
149
150 end:
151 return ret;
152}
153
154static void
155_efl_filter_model_filter_clean(Eo *o EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
156{
157 Efl_Filter_Request *r = data;
158
159 efl_unref(r->parent);
160 efl_unref(r->child);
161 free(r);
162}
163
164static Eina_Value
165_efl_filter_model_child_fetch(Eo *o EINA_UNUSED, void *data, const Eina_Value v)
166{
167 Efl_Filter_Request *r = data;
168 unsigned int i, len;
169 Eina_Future *f;
170 Eo *target = NULL;
171
172 // Get the first and only child in the array
173 EINA_VALUE_ARRAY_FOREACH(&v, len, i, target)
174 break;
175
176 r->child = efl_ref(target);
177
178 f = r->pd->filter.cb(r->pd->filter.data, r->parent, r->child);
179 f = efl_future_then(r->parent, f,
180 .success = _efl_filter_model_filter,
181 .success_type = EINA_VALUE_TYPE_BOOL,
182 .free = _efl_filter_model_filter_clean,
183 .data = r);
184 return eina_future_as_value(f);
185}
186
187static Eina_Value
188_efl_filter_model_child_error(Eo *o, void *data, Eina_Error err)
189{
190 _efl_filter_model_filter_clean(o, data, NULL);
191 return eina_value_error_init(err);
192}
193
194static void
195_efl_filter_model_child_added(void *data, const Efl_Event *event)
196{
197 Efl_Filter_Model_Data *pd = data;
198 Efl_Model_Children_Event *ev = event->info;
199 Efl_Model *child = ev->child;
200 Efl_Filter_Request *r;
201 Eina_Future *f;
202
203 if (child)
204 {
205 Efl_Filter_Model_Data *cpd = efl_data_scope_get(child, EFL_FILTER_MODEL_CLASS);
206
207 if (cpd->processed) return ;
208 }
209
210 r = calloc(1, sizeof (Efl_Filter_Request));
211 if (!r) return ;
212
213 r->pd = pd;
214 r->index = ev->index;
215 r->parent = efl_ref(event->object);
216
217 if (!child)
218 {
219 f = efl_model_children_slice_get(efl_ui_view_model_get(r->parent), r->index, 1);
220 f = efl_future_then(event->object, f,
221 .success = _efl_filter_model_child_fetch,
222 .success_type = EINA_VALUE_TYPE_ARRAY,
223 .error = _efl_filter_model_child_error,
224 .data = r);
225 return ;
226 }
227
228 r->child = efl_ref(child);
229
230 f = pd->filter.cb(pd->filter.data, r->parent, r->child);
231 f = efl_future_then(event->object, f,
232 .success = _efl_filter_model_filter,
233 .success_type = EINA_VALUE_TYPE_BOOL,
234 .free = _efl_filter_model_filter_clean,
235 .data = r);
236
237 efl_event_callback_stop(event->object);
238}
239
240static void
241_efl_filter_model_child_removed(void *data, const Efl_Event *event)
242{
243 Efl_Filter_Model_Mapping *mapping;
244 Efl_Filter_Model_Data *pd = data;
245 Efl_Model_Children_Event *ev = event->info;
246 uint64_t removed = ev->index;
247
248 mapping = (void *)eina_rbtree_inline_lookup(pd->mapping,
249 &removed, sizeof (uint64_t),
250 _filter_mapping_looking_cb, NULL);
251 if (!mapping) return;
252
253 pd->mapping = eina_rbtree_inline_remove(pd->mapping, EINA_RBTREE_GET(mapping),
254 _filter_mapping_cmp_cb, NULL);
255
256 EINA_REFCOUNT_UNREF(mapping)
257 free(mapping);
258
259 // Update the tree for the index to reflect the removed child
260 for (removed++; removed < pd->filter.count; removed++)
261 {
262 mapping = (void *)eina_rbtree_inline_lookup(pd->mapping,
263 &removed, sizeof (uint64_t),
264 _filter_mapping_looking_cb, NULL);
265 if (!mapping) continue;
266
267 pd->mapping = eina_rbtree_inline_remove(pd->mapping, EINA_RBTREE_GET(mapping),
268 _filter_mapping_cmp_cb, NULL);
269 mapping->mapped--;
270 pd->mapping = eina_rbtree_inline_insert(pd->mapping, EINA_RBTREE_GET(mapping),
271 _filter_mapping_cmp_cb, NULL);
272 }
273 pd->filter.count--;
274 pd->counted--;
275}
276
277EFL_CALLBACKS_ARRAY_DEFINE(filters_callbacks,
278 { EFL_MODEL_EVENT_CHILD_ADDED, _efl_filter_model_child_added },
279 { EFL_MODEL_EVENT_CHILD_REMOVED, _efl_filter_model_child_removed });
280
281static void
282_efl_filter_model_efl_object_destructor(Eo *obj, Efl_Filter_Model_Data *pd)
283{
284 eina_rbtree_delete(pd->mapping, _rbtree_free_cb, NULL);
285
286 if (pd->self)
287 {
288 EINA_REFCOUNT_UNREF(pd->self)
289 free(pd->self);
290 }
291 pd->self = NULL;
292
293 efl_destructor(efl_super(obj, EFL_FILTER_MODEL_CLASS));
294}
295
296static Eina_Value
297_filter_remove_array(Eo *o EINA_UNUSED, void *data, const Eina_Value v)
298{
299 Efl_Filter_Model_Mapping *mapping = data;
300 unsigned int i, len;
301 Eo *target = NULL;
302
303 EINA_VALUE_ARRAY_FOREACH(&v, len, i, target)
304 break;
305
306 if (efl_isa(target, EFL_FILTER_MODEL_CLASS))
307 {
308 Efl_Filter_Model_Data *pd = efl_data_scope_get(target, EFL_FILTER_MODEL_CLASS);
309
310 pd->self = mapping;
311 EINA_REFCOUNT_REF(pd->self);
312 }
313
314 return eina_value_object_init(target);
315}
316
317/* Result from eina_future_all_array is an EINA_VALUE_TYPE_ARRAY that contain Eina_Value of
318 Eo Model. It is expected that children slice get return an EINA_VALUE_TYPE_ARRAY that
319 contain Eo Model directly.
320*/
321static Eina_Value
322_filter_cleanup_array(Eo *o EINA_UNUSED, void *data EINA_UNUSED, const Eina_Value v)
323{
324 unsigned int i, len;
325 Eina_Value created = EINA_VALUE_EMPTY;
326 Eina_Value r = EINA_VALUE_EMPTY;
327
328 eina_value_array_setup(&r, EINA_VALUE_TYPE_OBJECT, 4);
329
330 EINA_VALUE_ARRAY_FOREACH(&v, len, i, created)
331 {
332 Eo *target = NULL;
333
334 if (eina_value_type_get(&created) != EINA_VALUE_TYPE_OBJECT)
335 goto on_error;
336
337 target = eina_value_object_get(&created);
338 if (!target) goto on_error;
339
340 eina_value_array_append(&r, target);
341 }
342
343 return r;
344
345 on_error:
346 eina_value_flush(&r);
347 return eina_value_error_init(EFL_MODEL_ERROR_UNKNOWN);
348}
349
350static Eina_Future *
351_efl_filter_model_efl_model_children_slice_get(Eo *obj, Efl_Filter_Model_Data *pd,
352 unsigned int start, unsigned int count)
353{
354 Efl_Filter_Model_Mapping **mapping = NULL;
355 Eina_Future **r = NULL;
356 Eina_Future *f;
357 unsigned int i;
358 Eina_Error err = ENOMEM;
359
360 if ((uint64_t) start + (uint64_t) count > pd->filter.count)
361 return efl_loop_future_rejected(obj, EFL_MODEL_ERROR_INCORRECT_VALUE);
362 if (count == 0)
363 return efl_loop_future_rejected(obj, EFL_MODEL_ERROR_INCORRECT_VALUE);
364
365 r = malloc((count + 1) * sizeof (Eina_Future *));
366 if (!r) return efl_loop_future_rejected(obj, ENOMEM);
367
368 mapping = calloc(count, sizeof (Efl_Filter_Model_Mapping *));
369 if (!mapping) goto on_error;
370
371 for (i = 0; i < count; i++)
372 {
373 uint64_t lookup = start + i;
374
375 mapping[i] = (void *)eina_rbtree_inline_lookup(pd->mapping,
376 &lookup, sizeof (uint64_t),
377 _filter_mapping_looking_cb, NULL);
378 if (!mapping[i]) goto on_error;
379 }
380
381 for (i = 0; i < count; i++)
382 {
383 r[i] = efl_model_children_slice_get(efl_super(obj, EFL_FILTER_MODEL_CLASS),
384 mapping[i]->original, 1);
385 r[i] = efl_future_then(obj, r[i], .success_type = EINA_VALUE_TYPE_ARRAY,
386 .success = _filter_remove_array,
387 .data = mapping[i]);
388 if (!r) goto on_error;
389 }
390 r[i] = EINA_FUTURE_SENTINEL;
391
392 f = efl_future_then(obj, eina_future_all_array(r), .success = _filter_cleanup_array);
393 free(r);
394 free(mapping);
395
396 return f;
397
398 on_error:
399 free(mapping);
400
401 if (r)
402 for (i = 0; i < count; i ++)
403 if (r[i]) eina_future_cancel(r[i]);
404 free(r);
405
406 return efl_loop_future_rejected(obj, err);
407}
408
409typedef struct _Efl_Filter_Model_Result Efl_Filter_Model_Result;
410struct _Efl_Filter_Model_Result
411{
412 Efl_Filter_Model_Data *pd;
413 uint64_t count;
414 Efl_Model *targets[1];
415};
416
417// This future receive an array of boolean that indicate if a fetched object is to be kept
418static Eina_Value
419_efl_filter_model_array_result_request(Eo *o EINA_UNUSED, void *data, const Eina_Value v)
420{
421 Efl_Filter_Model_Result *req = data;
422 Efl_Filter_Model_Data *pd = req->pd;
423 unsigned int i, len;
424 Eina_Value request = EINA_VALUE_EMPTY;
425 uint64_t pcount = pd->filter.count;
426
427 EINA_VALUE_ARRAY_FOREACH(&v, len, i, request)
428 {
429 Efl_Filter_Model_Mapping *mapping;
430 Efl_Model_Children_Event cevt = { 0 };
431 Eina_Bool b;
432
433 if (eina_value_type_get(&request) != EINA_VALUE_TYPE_BOOL)
434 continue ;
435
436 if (!eina_value_bool_get(&request, &b)) continue;
437 if (!b) continue;
438
439 mapping = calloc(1, sizeof (Efl_Filter_Model_Mapping));
440 if (!mapping) continue;
441
442 EINA_REFCOUNT_INIT(mapping);
443 mapping->original = i;
444 mapping->mapped = pd->filter.count++;
445
446 // Insert in tree here
447 pd->mapping = eina_rbtree_inline_insert(pd->mapping, EINA_RBTREE_GET(mapping),
448 _filter_mapping_cmp_cb, NULL);
449
450 cevt.index = mapping->mapped;
451 cevt.child = _efl_filter_lookup(efl_class_get(o), o, req->targets[i], mapping);
452 if (!cevt.child) continue;
453
454 efl_event_callback_call(o, EFL_MODEL_EVENT_CHILD_ADDED, &cevt);
455 efl_unref(cevt.child);
456 }
457
458 if (pcount != pd->filter.count)
459 efl_event_callback_call(o, EFL_MODEL_EVENT_CHILDREN_COUNT_CHANGED, NULL);
460
461 return v;
462}
463
464static void
465_efl_filter_model_array_result_free(Eo *o EINA_UNUSED, void *data, const Eina_Future *dead_future EINA_UNUSED)
466{
467 Efl_Filter_Model_Result *req = data;
468 uint64_t i;
469
470 for (i = 0; i < req->count; i++)
471 efl_unref(req->targets[i]);
472 free(req);
473}
474
475// This future receive an array of children object
476static Eina_Value
477_efl_filter_model_array_fetch(Eo *o, void *data, const Eina_Value v)
478{
479 Efl_Filter_Model_Result *req;
480 Efl_Filter_Model_Data *pd = data;
481 unsigned int i, len;
482 Eo *target = NULL;
483 Eina_Future **array = NULL;
484 Eina_Future *r;
485 Eina_Value res = v;
486
487 if (!eina_value_array_count(&v)) return v;
488
489 array = malloc((eina_value_array_count(&v) + 1) * sizeof (Eina_Future*));
490 if (!array) return eina_value_error_init(ENOMEM);
491
492 req = malloc(sizeof (Efl_Filter_Model_Result) +
493 sizeof (Eo*) * (eina_value_array_count(&v) - 1));
494 if (!req)
495 {
496 res = eina_value_error_init(ENOMEM);
497 goto on_error;
498 }
499
500 req->pd = pd;
501 req->count = eina_value_array_count(&v);
502
503 EINA_VALUE_ARRAY_FOREACH(&v, len, i, target)
504 {
505 array[i] = pd->filter.cb(pd->filter.data, o, target);
506 req->targets[i] = efl_ref(target);
507 }
508
509 array[i] = EINA_FUTURE_SENTINEL;
510
511 r = eina_future_all_array(array);
512 r = efl_future_then(o, r, .success_type = EINA_VALUE_TYPE_ARRAY,
513 .success = _efl_filter_model_array_result_request,
514 .free = _efl_filter_model_array_result_free,
515 .data = req);
516 res = eina_future_as_value(r);
517
518 on_error:
519 free(array);
520
521 return res;
522}
523
524static unsigned int
525_efl_filter_model_efl_model_children_count_get(const Eo *obj, Efl_Filter_Model_Data *pd)
526{
527 if (!pd->counting_started && pd->filter.cb)
528 {
529 pd->counting_started = EINA_TRUE;
530
531 // Start watching for children now
532 efl_event_callback_array_add((Eo *)obj, filters_callbacks(), pd);
533
534 // Start counting (which may trigger filter being added asynchronously)
535 pd->counted = efl_model_children_count_get(efl_super(obj, EFL_FILTER_MODEL_CLASS));
536 if (pd->counted > 0)
537 {
538 Eina_Future *f;
539
540 f = efl_model_children_slice_get(efl_ui_view_model_get(obj), 0, pd->counted);
541 efl_future_then(obj, f, .success_type = EINA_VALUE_TYPE_ARRAY,
542 .success = _efl_filter_model_array_fetch,
543 .data = pd);
544 }
545 }
546
547 return pd->filter.count;
548}
549
550static Eina_Value *
551_efl_filter_model_efl_model_property_get(const Eo *obj, Efl_Filter_Model_Data *pd,
552 const char *property)
553{
554 if (pd->self && !strcmp(property, EFL_COMPOSITE_MODEL_CHILD_INDEX))
555 {
556 return eina_value_uint64_new(pd->self->mapped);
557 }
558
559 return efl_model_property_get(efl_super(obj, EFL_FILTER_MODEL_CLASS), property);
560}
561
562static unsigned int
563_efl_filter_model_efl_composite_model_index_get(const Eo *obj, Efl_Filter_Model_Data *pd)
564{
565 if (pd->self) return pd->self->mapped;
566 return efl_composite_model_index_get(efl_super(obj, EFL_FILTER_MODEL_CLASS));
567}
568
569#include "efl_filter_model.eo.c"
diff --git a/src/lib/ecore/efl_filter_model.eo b/src/lib/ecore/efl_filter_model.eo
new file mode 100644
index 0000000000..8710707b06
--- /dev/null
+++ b/src/lib/ecore/efl_filter_model.eo
@@ -0,0 +1,31 @@
1function @beta EflFilterModel {
2 [[EflFilterModel function]]
3 params {
4 parent: Efl.Filter_Model; [[This object can be used to know when to cancel the future.]]
5 child: Efl.Model; [[You must reference this object for the duration of your use of it as the caller will not do that for you.]]
6 }
7 return: future<bool>; [[$true if the model should be kept.]]
8};
9
10class @beta Efl.Filter_Model extends Efl.Composite_Model
11{
12 [[Efl model designed to filter its children.]]
13 methods {
14 filter_set {
15 [[Set a filter function that will catch children from the composited model.]]
16 params {
17 filter: EflFilterModel; [[Filter callback]]
18 }
19 }
20 }
21 implements {
22 Efl.Object.destructor;
23 Efl.Model.children_slice_get;
24 Efl.Model.children_count { get; }
25 Efl.Model.property { get; }
26 Efl.Composite_Model.index { get; }
27 }
28 constructors {
29 .filter_set;
30 }
31} \ No newline at end of file
diff --git a/src/lib/ecore/meson.build b/src/lib/ecore/meson.build
index 64d255fe73..b34276c3cc 100644
--- a/src/lib/ecore/meson.build
+++ b/src/lib/ecore/meson.build
@@ -66,6 +66,7 @@ pub_eo_files = [
66 'efl_core_proc_env.eo', 66 'efl_core_proc_env.eo',
67 'efl_core_command_line.eo', 67 'efl_core_command_line.eo',
68 'efl_loop_timer.eo', 68 'efl_loop_timer.eo',
69 'efl_filter_model.eo',
69] 70]
70 71
71foreach eo_file : pub_eo_files 72foreach eo_file : pub_eo_files
@@ -145,6 +146,7 @@ ecore_src = [
145 'efl_model_accessor_view.c', 146 'efl_model_accessor_view.c',
146 'efl_model_accessor_view_private.h', 147 'efl_model_accessor_view_private.h',
147 'efl_view_model.c', 148 'efl_view_model.c',
149 'efl_filter_model.c',
148 'efl_linear_interpolator.c', 150 'efl_linear_interpolator.c',
149 'efl_accelerate_interpolator.c', 151 'efl_accelerate_interpolator.c',
150 'efl_decelerate_interpolator.c', 152 'efl_decelerate_interpolator.c',