summaryrefslogtreecommitdiff
path: root/src/lib/evas/canvas/evas_canvas_eo.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/evas/canvas/evas_canvas_eo.h')
-rw-r--r--src/lib/evas/canvas/evas_canvas_eo.h1068
1 files changed, 1068 insertions, 0 deletions
diff --git a/src/lib/evas/canvas/evas_canvas_eo.h b/src/lib/evas/canvas/evas_canvas_eo.h
new file mode 100644
index 0000000..da3fa26
--- /dev/null
+++ b/src/lib/evas/canvas/evas_canvas_eo.h
@@ -0,0 +1,1068 @@
1#ifndef _EVAS_CANVAS_EO_H_
2#define _EVAS_CANVAS_EO_H_
3
4#ifndef _EVAS_CANVAS_EO_CLASS_TYPE
5#define _EVAS_CANVAS_EO_CLASS_TYPE
6
7typedef Eo Evas_Canvas;
8
9#endif
10
11#ifndef _EVAS_CANVAS_EO_TYPES
12#define _EVAS_CANVAS_EO_TYPES
13
14
15#endif
16/** Evas canvas class
17 *
18 * @ingroup Evas_Canvas
19 */
20#define EVAS_CANVAS_CLASS evas_canvas_class_get()
21
22EWAPI const Efl_Class *evas_canvas_class_get(void);
23
24/**
25 * @brief Set the image cache.
26 *
27 * This function sets the image cache of canvas in bytes.
28 *
29 * @param[in] obj The object.
30 * @param[in] size The cache size.
31 *
32 * @ingroup Evas_Canvas
33 */
34EOAPI void evas_canvas_image_cache_set(Eo *obj, int size);
35
36/**
37 * @brief Get the image cache.
38 *
39 * This function returns the image cache size of canvas in bytes.
40 *
41 * @param[in] obj The object.
42 *
43 * @return The cache size.
44 *
45 * @ingroup Evas_Canvas
46 */
47EOAPI int evas_canvas_image_cache_get(const Eo *obj);
48
49/**
50 * @brief Set the default set of flags an event begins with
51 *
52 * Events in evas can have an event_flags member. This starts out with an
53 * initial value (no flags). This lets you set the default flags that an event
54 * begins with to @c flags.
55 *
56 * @param[in] obj The object.
57 * @param[in] flags The default flags to use.
58 *
59 * @since 1.2
60 *
61 * @ingroup Evas_Canvas
62 */
63EOAPI void evas_canvas_event_default_flags_set(Eo *obj, Efl_Input_Flags flags);
64
65/**
66 * @brief Get the default set of flags an event begins with
67 *
68 * This gets the default event flags events are produced with when fed in.
69 *
70 * @param[in] obj The object.
71 *
72 * @return The default flags to use.
73 *
74 * @since 1.2
75 *
76 * @ingroup Evas_Canvas
77 */
78EOAPI Efl_Input_Flags evas_canvas_event_default_flags_get(const Eo *obj);
79
80/**
81 * @brief Changes the size of font cache of the given evas.
82 *
83 * @param[in] obj The object.
84 * @param[in] size The size in bytes.
85 *
86 * @ingroup Evas_Canvas
87 */
88EOAPI void evas_canvas_font_cache_set(Eo *obj, int size);
89
90/**
91 * @brief Get the size of font cache of the given evas in bytes.
92 *
93 * @param[in] obj The object.
94 *
95 * @return The size in bytes.
96 *
97 * @ingroup Evas_Canvas
98 */
99EOAPI int evas_canvas_font_cache_get(const Eo *obj);
100
101/**
102 * @brief Attaches a specific pointer to the evas for fetching later.
103 *
104 * @param[in] obj The object.
105 * @param[in] data The attached pointer.
106 *
107 * @ingroup Evas_Canvas
108 */
109EOAPI void evas_canvas_data_attach_set(Eo *obj, void *data);
110
111/**
112 * @brief Returns the pointer attached by @ref evas_canvas_data_attach_set.
113 *
114 * @param[in] obj The object.
115 *
116 * @return The attached pointer.
117 *
118 * @ingroup Evas_Canvas
119 */
120EOAPI void *evas_canvas_data_attach_get(const Eo *obj);
121
122/**
123 * @brief Retrieve the object focused by the default seat.
124 *
125 * Focused objects will be the ones having key events delivered to, which the
126 * programmer can act upon by means of @ref evas_object_event_callback_add
127 * usage.
128 *
129 * @note Most users wouldn't be dealing directly with Evas' focused objects.
130 * Instead, they would be using a higher level library for that (like a
131 * toolkit, as Elementary) to handle focus and who's receiving input for them.
132 *
133 * This call returns the object that currently has focus on the canvas @c e or
134 * @c null, if none.
135 *
136 * See also @ref evas_object_focus_set, @ref evas_object_focus_get, @ref
137 * evas_object_key_grab, @ref evas_object_key_ungrab,
138 * @ref evas_canvas_seat_focus_get, @ref efl_canvas_object_seat_focus_check,
139 * @ref efl_canvas_object_seat_focus_add,
140 * @ref efl_canvas_object_seat_focus_del.
141 *
142 * @param[in] obj The object.
143 *
144 * @return The object that has focus or @c null if there is not one.
145 *
146 * @ingroup Evas_Canvas
147 */
148EOAPI Efl_Canvas_Object *evas_canvas_focus_get(const Eo *obj) EINA_WARN_UNUSED_RESULT;
149
150/**
151 * @brief Return the focused object by a given seat.
152 *
153 * @param[in] obj The object.
154 * @param[in] seat The seat to fetch the focused object or @c null for the
155 * default seat.
156 *
157 * @return The object that has the focus or @c null if the seat has no focused
158 * object.
159 *
160 * @since 1.19
161 *
162 * @ingroup Evas_Canvas
163 */
164EOAPI Efl_Canvas_Object *evas_canvas_seat_focus_get(const Eo *obj, Efl_Input_Device *seat);
165
166/**
167 * @brief Get the highest (stacked) Evas object on the canvas @c e.
168 *
169 * This function will take all populated layers in the canvas into account,
170 * getting the highest object for the highest layer, naturally.
171 *
172 * @warning This function will skip objects parented by smart objects, acting
173 * only on the ones at the "top level", with regard to object parenting.
174 *
175 * See also @ref evas_object_layer_get, @ref evas_object_layer_set, @ref
176 * evas_object_below_get, @ref evas_object_above_get.
177 *
178 * @param[in] obj The object.
179 *
180 * @return A pointer to the highest object on it (if any) or @c null otherwise.
181 *
182 * @ingroup Evas_Canvas
183 */
184EOAPI Efl_Canvas_Object *evas_canvas_object_top_get(const Eo *obj) EINA_WARN_UNUSED_RESULT;
185
186/**
187 * @brief This function returns the current known default pointer coordinates.
188 *
189 * @param[in] obj The object.
190 * @param[in] dev The pointer device.
191 * @param[out] x The pointer to a Evas_Coord to be filled in.
192 * @param[out] y The pointer to a Evas_Coord to be filled in.
193 *
194 * @since 1.19
195 *
196 * @ingroup Evas_Canvas
197 */
198EOAPI void evas_canvas_pointer_canvas_xy_by_device_get(const Eo *obj, Efl_Input_Device *dev, int *x, int *y);
199
200/**
201 * @brief This function returns the current known default pointer coordinates
202 *
203 * This function returns the current known canvas unit coordinates of the mouse
204 * pointer and sets the contents of the Evas_Coords pointed to by @c x and @c y
205 * to contain these coordinates. If @c e is not a valid canvas the results of
206 * this function are undefined.
207 *
208 * @param[in] obj The object.
209 * @param[out] x The pointer to a Evas_Coord to be filled in.
210 * @param[out] y The pointer to a Evas_Coord to be filled in.
211 *
212 * @ingroup Evas_Canvas
213 */
214EOAPI void evas_canvas_pointer_canvas_xy_get(const Eo *obj, int *x, int *y);
215
216/**
217 * @brief Get the number of mouse or multi presses currently active.
218 *
219 * @param[in] obj The object.
220 *
221 * @return Mouse or multi presses currently active
222 *
223 * @since 1.2
224 *
225 * @ingroup Evas_Canvas
226 */
227EOAPI int evas_canvas_event_down_count_get(const Eo *obj);
228
229/**
230 * @brief This gets the internal counter that counts the number of smart
231 * calculations.
232 *
233 * Whenever evas performs smart object calculations on the whole canvas it
234 * increments a counter by 1. This function returns the value of the smart
235 * object calculate counter. It starts with a value of 0 and will increase (and
236 * eventually wrap around to negative values and so on) by 1 every time objects
237 * are calculated. You can use this counter to ensure you don't re-do
238 * calculations withint the same calculation generation/run if the calculations
239 * maybe cause self-feeding effects.
240 *
241 * @param[in] obj The object.
242 *
243 * @return Number of smart calculations
244 *
245 * @since 1.1
246 *
247 * @ingroup Evas_Canvas
248 */
249EOAPI int evas_canvas_smart_objects_calculate_count_get(const Eo *obj);
250
251/**
252 * @brief Get the focus state for the default seat.
253 *
254 * @param[in] obj The object.
255 *
256 * @return @c true if focused, @c false otherwise
257 *
258 * @ingroup Evas_Canvas
259 */
260EOAPI Eina_Bool evas_canvas_focus_state_get(const Eo *obj);
261
262/**
263 * @brief Get the focus state by a given seat.
264 *
265 * @param[in] obj The object.
266 * @param[in] seat The seat to check the focus state. Use @c null for the
267 * default seat.
268 *
269 * @return @c true if the seat has the canvas focus, @c false otherwise.
270 *
271 * @ingroup Evas_Canvas
272 */
273EOAPI Eina_Bool evas_canvas_seat_focus_state_get(const Eo *obj, Efl_Input_Device *seat);
274
275/**
276 * @brief Get the changed marker for the canvas.
277 *
278 * @param[in] obj The object.
279 *
280 * @return @c true if changed, @c false otherwise
281 *
282 * @since 1.11
283 *
284 * @ingroup Evas_Canvas
285 */
286EOAPI Eina_Bool evas_canvas_changed_get(const Eo *obj);
287
288/**
289 * @brief This function returns the current known pointer coordinates.
290 *
291 * @param[in] obj The object.
292 * @param[in] dev The mouse device.
293 * @param[out] x The pointer to an integer to be filled in.
294 * @param[out] y The pointer to an integer to be filled in.
295 *
296 * @since 1.19
297 *
298 * @ingroup Evas_Canvas
299 */
300EOAPI void evas_canvas_pointer_output_xy_by_device_get(const Eo *obj, Efl_Input_Device *dev, int *x, int *y);
301
302/**
303 * @brief This function returns the current known default pointer coordinates.
304 *
305 * This function returns the current known screen/output coordinates of the
306 * mouse pointer and sets the contents of the integers pointed to by @c x and
307 * @c y to contain these coordinates. If @c e is not a valid canvas the results
308 * of this function are undefined.
309 *
310 * @param[in] obj The object.
311 * @param[out] x The pointer to an integer to be filled in.
312 * @param[out] y The pointer to an integer to be filled in.
313 *
314 * @ingroup Evas_Canvas
315 */
316EOAPI void evas_canvas_pointer_output_xy_get(const Eo *obj, int *x, int *y);
317
318/**
319 * @brief Get the lowest (stacked) Evas object on the canvas @c e.
320 *
321 * This function will take all populated layers in the canvas into account,
322 * getting the lowest object for the lowest layer, naturally.
323 *
324 * @warning This function will skip objects parented by smart objects, acting
325 * only on the ones at the "top level", with regard to object parenting.
326 *
327 * See also @ref evas_object_layer_get, @ref evas_object_layer_set, @ref
328 * evas_object_below_get, @ref evas_object_below_set.
329 *
330 * @param[in] obj The object.
331 *
332 * @return A pointer to the lowest object on it, if any, or @c null otherwise.
333 *
334 * @ingroup Evas_Canvas
335 */
336EOAPI Efl_Canvas_Object *evas_canvas_object_bottom_get(const Eo *obj) EINA_WARN_UNUSED_RESULT;
337
338/**
339 * @brief Returns a bitmask with the mouse buttons currently pressed, set to 1.
340 *
341 * @param[in] obj The object.
342 * @param[in] dev The mouse device.
343 *
344 * @return A bitmask of the currently depressed buttons on the canvas.
345 *
346 * @ingroup Evas_Canvas
347 */
348EOAPI unsigned int evas_canvas_pointer_button_down_mask_by_device_get(const Eo *obj, Efl_Input_Device *dev);
349
350/**
351 * @brief Returns a bitmask with the default mouse buttons currently pressed,
352 * set to 1.
353 *
354 * Calling this function will return a 32-bit integer with the appropriate bits
355 * set to 1, which correspond to a mouse button being depressed. This limits
356 * Evas to a mouse devices with a maximum of 32 buttons, but that is generally
357 * in excess of any host system's pointing device abilities.
358 *
359 * A canvas by default begins with no mouse buttons being pressed and only
360 * pointer move events can alter that.
361 *
362 * The least significant bit corresponds to the first mouse button (button 1)
363 * and the most significant bit corresponds to the last mouse button (button
364 * 32).
365 *
366 * If @c e is not a valid canvas, the return value is undefined.
367 *
368 * @param[in] obj The object.
369 *
370 * @return A bitmask of the currently depressed buttons on the canvas.
371 *
372 * @ingroup Evas_Canvas
373 */
374EOAPI unsigned int evas_canvas_pointer_button_down_mask_get(const Eo *obj) EINA_WARN_UNUSED_RESULT;
375
376/**
377 * @brief Retrieve a list of Evas objects lying over a given position in a
378 * canvas.
379 *
380 * This function will traverse all the layers of the given canvas, from top to
381 * bottom, querying for objects with areas covering the given position. It will
382 * enter the smart objects. It will not append to the list pass events as
383 * hidden objects. Call eina_list_free on the returned list after usage.
384 *
385 * @param[in] obj The object.
386 * @param[in] stop An Evas Object where to stop searching.
387 * @param[in] x The horizontal coordinate of the position.
388 * @param[in] y The vertical coordinate of the position.
389 *
390 * @return List of objects
391 *
392 * @ingroup Evas_Canvas
393 */
394EOAPI Eina_List *evas_canvas_tree_objects_at_xy_get(Eo *obj, Efl_Canvas_Object *stop, int x, int y) EINA_WARN_UNUSED_RESULT;
395
396/**
397 * @brief Enables or turns on programmatically the lock key with name
398 * @c keyname for the default seat.
399 *
400 * The effect will be as if the key was put on its active state after this
401 * call.
402 *
403 * See also @ref evas_canvas_key_lock_add, @ref evas_canvas_key_lock_del,
404 * @ref evas_canvas_key_lock_del, @ref evas_canvas_key_lock_off,
405 * @ref evas_canvas_seat_key_lock_on, @ref evas_canvas_seat_key_lock_off.
406 *
407 * @param[in] obj The object.
408 * @param[in] keyname The name of the lock to enable.
409 *
410 * @ingroup Evas_Canvas
411 */
412EOAPI void evas_canvas_key_lock_on(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
413
414/**
415 * @brief Enables or turns on programmatically the lock key with name
416 * @c keyname for a give seat.
417 *
418 * The effect will be as if the key was put on its active state after this
419 * call.
420 *
421 * See also @ref evas_canvas_key_lock_add, @ref evas_canvas_key_lock_del,
422 * @ref evas_canvas_key_lock_del, @ref evas_canvas_key_lock_off,
423 * @ref evas_canvas_key_lock_on, @ref evas_canvas_seat_key_lock_off.
424 *
425 * @param[in] obj The object.
426 * @param[in] keyname The name of the lock to enable.
427 * @param[in] seat The seat to enable the keylock. A @c null seat repesents the
428 * default seat.
429 *
430 * @since 1.19
431 *
432 * @ingroup Evas_Canvas
433 */
434EOAPI void evas_canvas_seat_key_lock_on(Eo *obj, const char *keyname, Efl_Input_Device *seat) EINA_ARG_NONNULL(2);
435
436/**
437 * @brief Disables or turns off programmatically the lock key with name
438 * @c keyname for a given seat.
439 *
440 * The effect will be as if the key was put on its inactive state after this
441 * call.
442 *
443 * See also @ref evas_canvas_key_lock_on, @ref evas_canvas_seat_key_lock_on,
444 * @ref evas_canvas_key_lock_off.
445 *
446 * @param[in] obj The object.
447 * @param[in] keyname The name of the lock to enable.
448 * @param[in] seat The seat to disable the keylock. A @c null seat repesents
449 * the default seat.
450 *
451 * @since 1.19
452 *
453 * @ingroup Evas_Canvas
454 */
455EOAPI void evas_canvas_seat_key_lock_off(Eo *obj, const char *keyname, Efl_Input_Device *seat) EINA_ARG_NONNULL(2);
456
457/**
458 * @brief Adds the @c keyname key to the current list of modifier keys.
459 *
460 * Modifiers are keys like shift, alt and ctrl, i.e. keys which are meant to be
461 * pressed together with others, altering the behavior of the second keys
462 * pressed. Evas is so that these keys can be user defined.
463 *
464 * This call allows custom modifiers to be added to the Evas system at run
465 * time. It is then possible to set and unset modifier keys programmatically
466 * for other parts of the program to check and act on. Programmers using Evas
467 * would check for modifier keys on key event callbacks using @ref
468 * evas_key_modifier_is_set.
469 *
470 * @note If the programmer instantiates the canvas by means of the @ref
471 * ecore_evas_new family of helper functions, Ecore will take care of
472 * registering on it all standard modifiers: "Shift", "Control", "Alt", "Meta",
473 * "Hyper", "Super".
474 *
475 * @param[in] obj The object.
476 * @param[in] keyname The name of the modifier key to add to the list of Evas
477 * modifiers.
478 *
479 * @ingroup Evas_Canvas
480 */
481EOAPI void evas_canvas_key_modifier_add(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
482
483/**
484 * @brief Disables or turns off programmatically the modifier key with name
485 * @c keyname for the default seat.
486 *
487 * See also @ref evas_canvas_key_modifier_add, @ref evas_key_modifier_get,
488 * @ref evas_canvas_key_modifier_on, @ref evas_canvas_seat_key_modifier_off,
489 * @ref evas_canvas_seat_key_modifier_off, @ref evas_key_modifier_is_set, @ref
490 * evas_seat_key_modifier_is_set.
491 *
492 * @param[in] obj The object.
493 * @param[in] keyname The name of the modifier to disable.
494 *
495 * @ingroup Evas_Canvas
496 */
497EOAPI void evas_canvas_key_modifier_off(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
498
499/**
500 * @brief Render the given Evas canvas asynchronously.
501 *
502 * This function only returns @c true when a frame will be rendered. If the
503 * previous frame is still rendering, @c false will be returned so the users
504 * know not to wait for the updates callback and just return to their main
505 * loop.
506 *
507 * If a @c func callback is given, a list of updated areas will be generated
508 * and the function will be called from the main thread after the rendered
509 * frame is flushed to the screen. The resulting list should be freed with @ref
510 * evas_render_updates_free.
511 *
512 * The list is given in the @c event_info parameter of the callback function.
513 *
514 * @param[in] obj The object.
515 *
516 * @return @c true if the canvas will render, @c false otherwise.
517 *
518 * @since 1.8
519 *
520 * @ingroup Evas_Canvas
521 */
522EOAPI Eina_Bool evas_canvas_render_async(Eo *obj);
523
524/** Inform the evas that it lost the focus from the default seat.
525 *
526 * @ingroup Evas_Canvas
527 */
528EOAPI void evas_canvas_focus_out(Eo *obj);
529
530/**
531 * @brief Update the canvas internal objects but not triggering immediate
532 * renderization.
533 *
534 * This function updates the canvas internal objects not triggering
535 * renderization. To force renderization function @ref evas_canvas_render
536 * should be used.
537 * @param[in] obj The object.
538 *
539 * @ingroup Evas_Canvas
540 */
541EOAPI void evas_canvas_norender(Eo *obj);
542
543/**
544 * @brief Pop the nochange flag down 1.
545 *
546 * This tells evas, that while the nochange flag is greater than 0, do not mark
547 * objects as "changed" when making changes.
548 *
549 * @warning Do not use this function unless you know what Evas exactly works
550 * with "changed" state.
551 * @param[in] obj The object.
552 *
553 * @ingroup Evas_Canvas
554 */
555EOAPI void evas_canvas_nochange_pop(Eo *obj);
556
557/**
558 * @brief Disables or turns off programmatically the lock key with name
559 * @c keyname for the default seat.
560 *
561 * The effect will be as if the key was put on its inactive state after this
562 * call.
563 *
564 * See also @ref evas_canvas_key_lock_on, @ref evas_canvas_seat_key_lock_on,
565 * @ref evas_canvas_seat_key_lock_off.
566 *
567 * @param[in] obj The object.
568 * @param[in] keyname The name of the lock to disable.
569 *
570 * @ingroup Evas_Canvas
571 */
572EOAPI void evas_canvas_key_lock_off(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
573
574/**
575 * @brief Push the nochange flag up 1
576 *
577 * This tells evas, that while the nochange flag is greater than 0, do not mark
578 * objects as "changed" when making changes.
579 *
580 * @warning Do not use this function unless you know what Evas exactly works
581 * with "changed" state.
582 * @param[in] obj The object.
583 *
584 * @ingroup Evas_Canvas
585 */
586EOAPI void evas_canvas_nochange_push(Eo *obj);
587
588/** Force the given evas and associated engine to flush its font cache.
589 *
590 * @ingroup Evas_Canvas
591 */
592EOAPI void evas_canvas_font_cache_flush(Eo *obj);
593
594/**
595 * @brief Enables or turns on programmatically the modifier key with name
596 * @c keyname for the default seat.
597 *
598 * The effect will be as if the key was pressed for the whole time between this
599 * call and a matching evas_key_modifier_off().
600 *
601 * See also @ref evas_canvas_key_modifier_off,
602 * @ref evas_canvas_seat_key_modifier_on,
603 * @ref evas_canvas_seat_key_modifier_off.
604 *
605 * @param[in] obj The object.
606 * @param[in] keyname The name of the modifier to enable.
607 *
608 * @ingroup Evas_Canvas
609 */
610EOAPI void evas_canvas_key_modifier_on(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
611
612/**
613 * @brief Enables or turns on programmatically the modifier key with name
614 * @c keyname for a given seat.
615 *
616 * The effect will be as if the key was pressed for the whole time between this
617 * call and a matching @ref evas_canvas_seat_key_modifier_off.
618 *
619 * See also @ref evas_canvas_key_modifier_off,
620 * @ref evas_canvas_seat_key_modifier_on,
621 * @ref evas_canvas_seat_key_modifier_off.
622 *
623 * @param[in] obj The object.
624 * @param[in] keyname The name of the lock to enable.
625 * @param[in] seat The seat to enable the modifier. A @c null seat repesents
626 * the default seat.
627 *
628 * @since 1.19
629 *
630 * @ingroup Evas_Canvas
631 */
632EOAPI void evas_canvas_seat_key_modifier_on(Eo *obj, const char *keyname, Efl_Input_Device *seat) EINA_ARG_NONNULL(2);
633
634/**
635 * @brief Disables or turns off programmatically the modifier key with name
636 * @c keyname for a given seat.
637 *
638 * See also @ref evas_canvas_key_modifier_add, @ref evas_key_modifier_get,
639 * @ref evas_canvas_key_modifier_on, @ref evas_canvas_seat_key_modifier_off,
640 * @ref evas_canvas_seat_key_modifier_off, @ref evas_key_modifier_is_set, @ref
641 * evas_seat_key_modifier_is_set.
642 *
643 * @param[in] obj The object.
644 * @param[in] keyname The name of the lock to enable.
645 * @param[in] seat The seat to disable the modifier. A @c null seat repesents
646 * the default seat.
647 *
648 * @since 1.19
649 *
650 * @ingroup Evas_Canvas
651 */
652EOAPI void evas_canvas_seat_key_modifier_off(Eo *obj, const char *keyname, Efl_Input_Device *seat) EINA_ARG_NONNULL(2);
653
654/**
655 * @brief List of available font descriptions known or found by this evas.
656 *
657 * The list depends on Evas compile time configuration, such as fontconfig
658 * support, and the paths provided at runtime as explained in @ref
659 * Evas_Font_Path_Group.
660 *
661 * @param[in] obj The object.
662 *
663 * @return A newly allocated list of strings. Do not change the strings. Be
664 * sure to call @ref evas_font_available_list_free after you're done.
665 *
666 * @ingroup Evas_Canvas
667 */
668EOAPI Eina_List *evas_canvas_font_available_list(const Eo *obj) EINA_WARN_UNUSED_RESULT;
669
670/**
671 * @brief Retrieves the object on the given evas with the given name.
672 *
673 * This looks for the evas object given a name by @ref evas_object_name_set. If
674 * the name is not unique canvas-wide, then which one of the many objects with
675 * that name is returned is undefined, so only use this if you can ensure the
676 * object name is unique.
677 *
678 * @param[in] obj The object.
679 * @param[in] name The given name.
680 *
681 * @return If successful, the Evas object with the given name. Otherwise,
682 * @c null.
683 *
684 * @ingroup Evas_Canvas
685 */
686EOAPI Efl_Canvas_Object *evas_canvas_object_name_find(const Eo *obj, const char *name) EINA_WARN_UNUSED_RESULT;
687
688/**
689 * @brief Appends a font path to the list of font paths used by the given evas.
690 *
691 * @param[in] obj The object.
692 * @param[in] path The new font path.
693 *
694 * @ingroup Evas_Canvas
695 */
696EOAPI void evas_canvas_font_path_append(Eo *obj, const char *path) EINA_ARG_NONNULL(2);
697
698/** Removes all font paths loaded into memory for the given evas.
699 *
700 * @ingroup Evas_Canvas
701 */
702EOAPI void evas_canvas_font_path_clear(Eo *obj);
703
704/**
705 * @brief This function returns the nth touch point's coordinates.
706 *
707 * Touch point's coordinates is updated whenever moving that point on the
708 * canvas.
709 *
710 * @param[in] obj The object.
711 * @param[in] n The number of the touched point (0 being the first).
712 * @param[out] x Last known X position in window coordinates
713 * @param[out] y Last known Y position in window coordinates
714 *
715 * @ingroup Evas_Canvas
716 */
717EOAPI void evas_canvas_touch_point_list_nth_xy_get(Eo *obj, unsigned int n, double *x, double *y);
718
719/**
720 * @brief Removes the @c keyname key from the current list of lock keys on
721 * canvas @c e.
722 *
723 * @param[in] obj The object.
724 * @param[in] keyname The name of the key to remove from the locks list.
725 *
726 * @ingroup Evas_Canvas
727 */
728EOAPI void evas_canvas_key_lock_del(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
729
730/**
731 * @brief Add a damage rectangle.
732 *
733 * This is the function by which one tells evas that a part of the canvas has
734 * to be repainted.
735 *
736 * @note All newly created Evas rectangles get the default color values of 255
737 * 255 255 255 (opaque white).
738 *
739 * @param[in] obj The object.
740 * @param[in] x The rectangle's left position.
741 * @param[in] y The rectangle's top position.
742 * @param[in] w The rectangle's width.
743 * @param[in] h The rectangle's height.
744 *
745 * @ingroup Evas_Canvas
746 */
747EOAPI void evas_canvas_damage_rectangle_add(Eo *obj, int x, int y, int w, int h);
748
749/** Sync evas canvas
750 *
751 * @ingroup Evas_Canvas
752 */
753EOAPI void evas_canvas_sync(Eo *obj);
754
755/**
756 * @brief Retrieves the list of font paths used by the given evas.
757 *
758 * @param[in] obj The object.
759 *
760 * @return The list of font paths used.
761 *
762 * @ingroup Evas_Canvas
763 */
764EOAPI const Eina_List *evas_canvas_font_path_list(const Eo *obj) EINA_WARN_UNUSED_RESULT;
765
766/**
767 * @brief Reload the image cache.
768 *
769 * This function reloads the image cache of canvas.
770 * @param[in] obj The object.
771 *
772 * @ingroup Evas_Canvas
773 */
774EOAPI void evas_canvas_image_cache_reload(Eo *obj);
775
776/**
777 * @brief Convert/scale a canvas coordinate into output screen coordinates.
778 *
779 * This function takes in a horizontal coordinate as the @c x parameter and
780 * converts it into output units, accounting for output size, viewport size and
781 * location, returning it as the function return value. If @c e is invalid,
782 * the results are undefined.
783 *
784 * @param[in] obj The object.
785 * @param[in] x The canvas X coordinate.
786 *
787 * @return The output/screen coordinate translated to output coordinates.
788 *
789 * @ingroup Evas_Canvas
790 */
791EOAPI int evas_canvas_coord_world_x_to_screen(const Eo *obj, int x) EINA_WARN_UNUSED_RESULT;
792
793/**
794 * @brief Force immediate renderization of the given Evas canvas.
795 *
796 * This function forces an immediate renderization update of the given canvas
797 * @c e.
798 *
799 * @note This is a very low level function, which most of Evas' users wouldn't
800 * care about. You might use it, for instance, to grab an Evas' canvas update
801 * regions and paint them back, using the canvas' pixmap, on a displaying
802 * system working below Evas.
803 *
804 * @note Evas is a stateful canvas. If no operations changing its state took
805 * place since the last rendering action, you won't see any changes and this
806 * call will be a no-op.
807 *
808 * @param[in] obj The object.
809 *
810 * @return A newly allocated list of updated rectangles of the canvas
811 * (@Eina.Rect structs). Free this list with @ref evas_render_updates_free.
812 *
813 * @ingroup Evas_Canvas
814 */
815EOAPI Eina_List *evas_canvas_render_updates(Eo *obj) EINA_WARN_UNUSED_RESULT;
816
817/**
818 * @brief Flush the image cache of the canvas.
819 *
820 * This function flushes image cache of canvas.
821 * @param[in] obj The object.
822 *
823 * @ingroup Evas_Canvas
824 */
825EOAPI void evas_canvas_image_cache_flush(Eo *obj);
826
827/**
828 * @brief Convert/scale an output screen coordinate into canvas coordinates.
829 *
830 * This function takes in a vertical coordinate as the @c y parameter and
831 * converts it into canvas units, accounting for output size, viewport size and
832 * location, returning it as the function return value. If @c e is invalid, the
833 * results are undefined.
834 *
835 * @param[in] obj The object.
836 * @param[in] y The screen/output y coordinate.
837 *
838 * @return The screen coordinate translated to canvas unit coordinates.
839 *
840 * @ingroup Evas_Canvas
841 */
842EOAPI int evas_canvas_coord_screen_y_to_world(const Eo *obj, int y) EINA_WARN_UNUSED_RESULT;
843
844/**
845 * @brief Removes the @c keyname key from the current list of modifier keys on
846 * canvas @c e.
847 *
848 * See also @ref evas_canvas_key_modifier_add.
849 *
850 * @param[in] obj The object.
851 * @param[in] keyname The name of the key to remove from the modifiers list.
852 *
853 * @ingroup Evas_Canvas
854 */
855EOAPI void evas_canvas_key_modifier_del(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
856
857/** Inform to the evas that it got the focus from the default seat.
858 *
859 * @ingroup Evas_Canvas
860 */
861EOAPI void evas_canvas_focus_in(Eo *obj);
862
863/**
864 * @brief Inform to the evas that it got the focus from a given seat.
865 *
866 * @param[in] obj The object.
867 * @param[in] seat The seat or @c null for the default seat.
868 *
869 * @since 1.19
870 *
871 * @ingroup Evas_Canvas
872 */
873EOAPI void evas_canvas_seat_focus_in(Eo *obj, Efl_Input_Device *seat);
874
875/**
876 * @brief Inform to the evas that it lost the focus from a given seat.
877 *
878 * @param[in] obj The object.
879 * @param[in] seat The seat or @c null for the default seat.
880 *
881 * @since 1.19
882 *
883 * @ingroup Evas_Canvas
884 */
885EOAPI void evas_canvas_seat_focus_out(Eo *obj, Efl_Input_Device *seat);
886
887/**
888 * @brief Add an "obscured region" to an Evas canvas.
889 *
890 * This is the function by which one tells an Evas canvas that a part of it
891 * must not be repainted. The region must be rectangular and its coordinates
892 * inside the canvas viewport are passed in the call. After this call, the
893 * region specified won't participate in any form in Evas' calculations and
894 * actions during its rendering updates, having its displaying content frozen
895 * as it was just after this function took place.
896 *
897 * We call it "obscured region" because the most common use case for this
898 * rendering (partial) freeze is something else (most probably other canvas)
899 * being on top of the specified rectangular region, thus shading it completely
900 * from the user's final scene in a display. To avoid unnecessary processing,
901 * one should indicate to the obscured canvas not to bother about the
902 * non-important area.
903 *
904 * The majority of users won't have to worry about this function, as they'll be
905 * using just one canvas in their applications, with nothing inset or on top of
906 * it in any form.
907 *
908 * To make this region one that has to be repainted again, call the function
909 * @ref evas_obscured_clear.
910 *
911 * @note This is a very low level function, which most of Evas' users wouldn't
912 * care about.
913 *
914 * @note This function does not flag the canvas as having its state changed. If
915 * you want to re-render it afterwards expecting new contents, you have to add
916 * "damage" regions yourself (see @ref evas_damage_rectangle_add).
917 *
918 * @param[in] obj The object.
919 * @param[in] x The rectangle's top left corner's horizontal coordinate.
920 * @param[in] y The rectangle's top left corner's vertical coordinate.
921 * @param[in] w The rectangle's width.
922 * @param[in] h The rectangle's height.
923 *
924 * @ingroup Evas_Canvas
925 */
926EOAPI void evas_canvas_obscured_rectangle_add(Eo *obj, int x, int y, int w, int h);
927
928/**
929 * @brief Make the canvas discard as much data as possible used by the engine
930 * at runtime.
931 *
932 * This function will unload images, delete textures and much more where
933 * possible. You may also want to call @ref evas_canvas_render_idle_flush
934 * immediately prior to this to perhaps discard a little more, though this
935 * function should implicitly delete most of what
936 * @ref evas_canvas_render_idle_flush might discard too.
937 * @param[in] obj The object.
938 *
939 * @ingroup Evas_Canvas
940 */
941EOAPI void evas_canvas_render_dump(Eo *obj);
942
943/** Force renderization of the given canvas.
944 *
945 * @ingroup Evas_Canvas
946 */
947EOAPI void evas_canvas_render(Eo *obj);
948
949/**
950 * @brief Prepends a font path to the list of font paths used by the given
951 * evas.
952 *
953 * @param[in] obj The object.
954 * @param[in] path The new font path.
955 *
956 * @ingroup Evas_Canvas
957 */
958EOAPI void evas_canvas_font_path_prepend(Eo *obj, const char *path) EINA_ARG_NONNULL(2);
959
960/**
961 * @brief Remove all "obscured regions" from an Evas canvas.
962 *
963 * This function removes all the rectangles from the obscured regions list of
964 * the canvas @c e. It takes obscured areas added with
965 * @ref evas_canvas_obscured_rectangle_add and make them again a regions that
966 * have to be repainted on rendering updates.
967 *
968 * @note This is a very low level function, which most of Evas' users wouldn't
969 * care about.
970 *
971 * @note This function does not flag the canvas as having its state changed. If
972 * you want to re-render it afterwards expecting new contents, you have to add
973 * "damage" regions yourself (see @ref evas_canvas_damage_rectangle_add).
974 * @param[in] obj The object.
975 *
976 * @ingroup Evas_Canvas
977 */
978EOAPI void evas_canvas_obscured_clear(Eo *obj);
979
980/**
981 * @brief Convert/scale an output screen coordinate into canvas coordinates.
982 *
983 * This function takes in a horizontal coordinate as the @c x parameter and
984 * converts it into canvas units, accounting for output size, viewport size and
985 * location, returning it as the function return value. If @c e is invalid, the
986 * results are undefined.
987 *
988 * @param[in] obj The object.
989 * @param[in] x The screen/output x coordinate.
990 *
991 * @return The screen coordinate translated to canvas unit coordinates.
992 *
993 * @ingroup Evas_Canvas
994 */
995EOAPI int evas_canvas_coord_screen_x_to_world(const Eo *obj, int x) EINA_WARN_UNUSED_RESULT;
996
997/**
998 * @brief Adds the @c keyname key to the current list of lock keys.
999 *
1000 * Locks are keys like caps lock, num lock or scroll lock, i.e., keys which are
1001 * meant to be pressed once -- toggling a binary state which is bound to it --
1002 * and thus altering the behavior of all subsequently pressed keys somehow,
1003 * depending on its state. Evas is so that these keys can be defined by the
1004 * user.
1005 *
1006 * This allows custom locks to be added to the evas system at run time. It is
1007 * then possible to set and unset lock keys programmatically for other parts of
1008 * the program to check and act on. Programmers using Evas would check for lock
1009 * keys on key event callbacks using @ref evas_key_lock_is_set.
1010 *
1011 * @note If the programmer instantiates the canvas by means of the
1012 * ecore_evas_new() family of helper functions, Ecore will take care of
1013 * registering on it all standard lock keys: "Caps_Lock", "Num_Lock",
1014 * "Scroll_Lock".
1015 *
1016 * @param[in] obj The object.
1017 * @param[in] keyname The name of the key to add to the locks list.
1018 *
1019 * @ingroup Evas_Canvas
1020 */
1021EOAPI void evas_canvas_key_lock_add(Eo *obj, const char *keyname) EINA_ARG_NONNULL(2);
1022
1023/**
1024 * @brief Make the canvas discard internally cached data used for rendering.
1025 *
1026 * This function flushes the arrays of delete, active and render objects. Other
1027 * things it may also discard are: shared memory segments, temporary scratch
1028 * buffers, cached data to avoid re-compute of that data etc.
1029 * @param[in] obj The object.
1030 *
1031 * @ingroup Evas_Canvas
1032 */
1033EOAPI void evas_canvas_render_idle_flush(Eo *obj);
1034
1035/**
1036 * @brief Return the default device of a given type.
1037 *
1038 * @note Currently EFL only creates a seat, mouse and keyboard.
1039 *
1040 * @param[in] obj The object.
1041 * @param[in] type The class of the default device to fetch.
1042 *
1043 * @return The default device or @c null on error.
1044 *
1045 * @since 1.19
1046 *
1047 * @ingroup Evas_Canvas
1048 */
1049EOAPI Efl_Input_Device *evas_canvas_default_device_get(const Eo *obj, Efl_Input_Device_Type type);
1050
1051/**
1052 * @brief Convert/scale a canvas coordinate into output screen coordinates.
1053 *
1054 * This function takes in a vertical coordinate as the @c x parameter and
1055 * converts it into output units, accounting for output size, viewport size and
1056 * location, returning it as the function return value. If @c e is invalid, the
1057 * results are undefined.
1058 *
1059 * @param[in] obj The object.
1060 * @param[in] y The canvas y coordinate.
1061 *
1062 * @return The output/screen coordinate translated to output coordinates.
1063 *
1064 * @ingroup Evas_Canvas
1065 */
1066EOAPI int evas_canvas_coord_world_y_to_screen(const Eo *obj, int y) EINA_WARN_UNUSED_RESULT;
1067
1068#endif