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