1 /** 2 * @defgroup Elm_Config Elementary Config 3 * @ingroup Elementary 4 * 5 * Elementary configuration is formed by a set options bounded to a 6 * given @ref Elm_Profile, like @ref Elm_Theme, @ref Elm_Fingers 7 * "finger size", etc. These are functions with which one synchronizes 8 * changes made to those values to the configuration storing files, de 9 * facto. You most probably don't want to use the functions in this 10 * group unless you're writing an elementary configuration manager. 11 * 12 * @{ 13 */ 14 15 /** 16 * Save back Elementary's configuration, so that it will persist on 17 * future sessions. 18 * 19 * @return @c EINA_TRUE, when successful. @c EINA_FALSE, otherwise. 20 * @ingroup Elm_Config 21 * 22 * This function will take effect -- thus, do I/O -- immediately. Use 23 * it when you want to save all configuration changes at once. The 24 * current configuration set will get saved onto the current profile 25 * configuration file. 26 * 27 */ 28 EAPI Eina_Bool elm_config_save(void); 29 30 /** 31 * Reload Elementary's configuration, bounded to current selected 32 * profile. 33 * 34 * @return @c EINA_TRUE, when successful. @c EINA_FALSE, otherwise. 35 * @ingroup Elm_Config 36 * 37 * Useful when you want to force reloading of configuration values for 38 * a profile. If one removes user custom configuration directories, 39 * for example, it will force a reload with system values instead. 40 * 41 */ 42 EAPI void elm_config_reload(void); 43 44 /** 45 * Flush all config settings then apply those settings to all applications 46 * using elementary on the current display. 47 * 48 * @ingroup Elm_Config 49 */ 50 EAPI void elm_config_all_flush(void); 51 52 /** 53 * @} 54 */ 55 56 /** 57 * @defgroup Elm_Profile Elementary Profile 58 * @ingroup Elementary 59 * 60 * Profiles are pre-set options that affect the whole look-and-feel of 61 * Elementary-based applications. There are, for example, profiles 62 * aimed at desktop computer applications and others aimed at mobile, 63 * touchscreen-based ones. You most probably don't want to use the 64 * functions in this group unless you're writing an elementary 65 * configuration manager. 66 * 67 * @{ 68 */ 69 70 /** 71 * Get Elementary's profile in use. 72 * 73 * This gets the global profile that is applied to all Elementary 74 * applications. 75 * 76 * @return The profile's name 77 * @ingroup Elm_Profile 78 */ 79 EAPI const char *elm_config_profile_get(void); 80 81 /** 82 * Get an Elementary's profile directory path in the filesystem. One 83 * may want to fetch a system profile's dir or a user one (fetched 84 * inside $HOME). 85 * 86 * @param profile The profile's name 87 * @param is_user Whether to lookup for a user profile (@c EINA_TRUE) 88 * or a system one (@c EINA_FALSE) 89 * @return The profile's directory path. 90 * @ingroup Elm_Profile 91 * 92 * @note You must free it with elm_config_profile_dir_free(). 93 */ 94 EAPI const char *elm_config_profile_dir_get(const char *profile, Eina_Bool is_user); 95 96 /** 97 * Free an Elementary's profile directory path, as returned by 98 * elm_config_profile_dir_get(). 99 * 100 * @param p_dir The profile's path 101 * @ingroup Elm_Profile 102 * 103 */ 104 EAPI void elm_config_profile_dir_free(const char *p_dir); 105 106 /** 107 * Get Elementary's list of available profiles. 108 * 109 * @return The profiles list. List node data are the profile name 110 * strings. 111 * @ingroup Elm_Profile 112 * 113 * @note One must free this list, after usage, with the function 114 * elm_config_profile_list_free(). 115 */ 116 EAPI Eina_List *elm_config_profile_list_get(void); 117 118 /** 119 * Get Elementary's list of available profiles including hidden ones. 120 * 121 * This gets a full list of profiles even with hidden names that should not 122 * be user-visible. 123 * 124 * @return The profiles list. List node data are the profile name 125 * strings. 126 * @ingroup Elm_Profile 127 * 128 * @note One must free this list, after usage, with the function 129 * elm_config_profile_list_free(). 130 * @since 1.17 131 */ 132 EAPI Eina_List *elm_config_profile_list_full_get(void); 133 134 /** 135 * Free Elementary's list of available profiles. 136 * 137 * @param l The profiles list, as returned by elm_config_profile_list_get(). 138 * @ingroup Elm_Profile 139 * 140 */ 141 EAPI void elm_config_profile_list_free(Eina_List *l); 142 143 /** 144 * Return if a profile of the given name exists 145 * 146 * @return EINA_TRUE if the profile exists, or EINA_FALSE if not 147 * @param profile The profile's name 148 * @ingroup Elm_Profile 149 * 150 * @since 1.17 151 */ 152 EAPI Eina_Bool elm_config_profile_exists(const char *profile); 153 154 /** 155 * Set Elementary's profile. 156 * 157 * This sets the global profile that is applied to Elementary 158 * applications. Just the process the call comes from will be 159 * affected. 160 * 161 * @param profile The profile's name 162 * @ingroup Elm_Profile 163 * 164 */ 165 EAPI void elm_config_profile_set(const char *profile); 166 167 /** 168 * Take the current config and write it out to the named profile 169 * 170 * This will take the current in-memory config and write it out to the named 171 * profile specified by @p profile. This will not change profile for the 172 * application or make other processes switch profile. 173 * 174 * @param profile The profile's name 175 * @ingroup Elm_Profile 176 * 177 * @since 1.17 178 */ 179 EAPI void elm_config_profile_save(const char *profile); 180 181 /** 182 * Add a new profile of the given name to be derived from the current profile 183 * 184 * This creates a new profile of name @p profile that will be derived from 185 * the currently used profile using the modification commands encoded in the 186 * @p derive_options string. 187 * 188 * At this point it is not expected that anyone would generally use this API 189 * except if you are a desktop environment and so the user base of this API 190 * will be enlightenment itself. 191 * 192 * @param profile The new profile's name 193 * @param derive_options A string of derive options detailing how to modify 194 * 195 * @see elm_config_profile_derived_del 196 * @ingroup Elm_Profile 197 * 198 * @since 1.17 199 */ 200 EAPI void elm_config_profile_derived_add(const char *profile, const char *derive_options); 201 202 /** 203 * Deletes a profile that is derived from the current one 204 * 205 * This deletes a derived profile added by elm_config_profile_derived_add(). 206 * This will delete the profile of the given name @p profile that is derived 207 * from the current profile. 208 * 209 * At this point it is not expected that anyone would generally use this API 210 * except if you are a desktop environment and so the user base of this API 211 * will be enlightenment itself. 212 * 213 * @param profile The profile's name that is to be deleted 214 * 215 * @see elm_config_profile_derived_add 216 * @ingroup Elm_Profile 217 * 218 * @since 1.17 219 */ 220 EAPI void elm_config_profile_derived_del(const char *profile); 221 222 /** 223 * @} 224 */ 225 226 /** 227 * @defgroup Elm_Scrolling Elementary Scrolling 228 * @ingroup Elementary 229 * 230 * These are functions setting how scrollable views in Elementary 231 * widgets should behave on user interaction. 232 * 233 * @{ 234 */ 235 236 /** 237 * Get whether scrollers should bounce when they reach their 238 * viewport's edge during a scroll. 239 * 240 * @return the thumb scroll bouncing state 241 * 242 * This is the default behavior for touch screens, in general. 243 * @ingroup Elm_Scrolling 244 */ 245 EAPI Eina_Bool elm_config_scroll_bounce_enabled_get(void); 246 247 /** 248 * Set whether scrollers should bounce when they reach their 249 * viewport's edge during a scroll. 250 * 251 * @param enabled the thumb scroll bouncing state 252 * 253 * @see elm_config_scroll_bounce_enabled_get() 254 * @ingroup Elm_Scrolling 255 */ 256 EAPI void elm_config_scroll_bounce_enabled_set(Eina_Bool enabled); 257 258 /** 259 * Get the amount of inertia a scroller will impose at bounce 260 * animations. 261 * 262 * @return the thumb scroll bounce friction 263 * 264 * @ingroup Elm_Scrolling 265 */ 266 EAPI double elm_config_scroll_bounce_friction_get(void); 267 268 /** 269 * Set the amount of inertia a scroller will impose at bounce 270 * animations. 271 * 272 * @param friction the thumb scroll bounce friction 273 * 274 * @see elm_config_scroll_bounce_friction_get() 275 * @ingroup Elm_Scrolling 276 */ 277 EAPI void elm_config_scroll_bounce_friction_set(double friction); 278 279 /** 280 * Get the amount of inertia a <b>paged</b> scroller will impose at 281 * page fitting animations. 282 * 283 * @return the page scroll friction 284 * 285 * @ingroup Elm_Scrolling 286 */ 287 EAPI double elm_config_scroll_page_scroll_friction_get(void); 288 289 /** 290 * Set the amount of inertia a <b>paged</b> scroller will impose at 291 * page fitting animations. 292 * 293 * @param friction the page scroll friction 294 * 295 * @see elm_config_scroll_page_scroll_friction_get() 296 * @ingroup Elm_Scrolling 297 */ 298 EAPI void elm_config_scroll_page_scroll_friction_set(double friction); 299 300 /** 301 * Get enable status of context menu disabled. 302 * 303 * @see elm_config_context_menu_disabled_set() 304 * 305 * @return @c EINA_TRUE if context menu is disabled, otherwise @c EINA_FALSE. 306 * 307 * @ingroup Elm_Entry_Group 308 * @since 1.17 309 */ 310 EAPI Eina_Bool elm_config_context_menu_disabled_get(void); 311 312 /** 313 * Enable or disable the context menu in entries. 314 * 315 * @param disabled disable context menu if @c EINA_TRUE, enable otherwise 316 * 317 * @see elm_config_context_menu_disabled_get() 318 * @ingroup Elm_Entry_Group 319 * @since 1.17 320 */ 321 EAPI void elm_config_context_menu_disabled_set(Eina_Bool disabled); 322 323 /** 324 * Get the amount of inertia a scroller will impose at region bring 325 * animations. 326 * 327 * @return the bring in scroll friction 328 * 329 * @ingroup Elm_Scrolling 330 */ 331 EAPI double elm_config_scroll_bring_in_scroll_friction_get(void); 332 333 /** 334 * Set the amount of inertia a scroller will impose at region bring 335 * animations. 336 * 337 * @param friction the bring in scroll friction 338 * 339 * @see elm_config_scroll_bring_in_scroll_friction_get() 340 * @ingroup Elm_Scrolling 341 */ 342 EAPI void elm_config_scroll_bring_in_scroll_friction_set(double friction); 343 344 /** 345 * Get the amount of inertia scrollers will impose at animations 346 * triggered by Elementary widgets' zooming API. 347 * 348 * @return the zoom friction 349 * 350 * @ingroup Elm_Scrolling 351 */ 352 EAPI double elm_config_scroll_zoom_friction_get(void); 353 354 /** 355 * Set the amount of inertia scrollers will impose at animations 356 * triggered by Elementary widgets' zooming API. 357 * 358 * @param friction the zoom friction 359 * 360 * @see elm_config_scroll_zoom_friction_get() 361 * @ingroup Elm_Scrolling 362 */ 363 EAPI void elm_config_scroll_zoom_friction_set(double friction); 364 365 /** 366 * Get whether scrollers should be draggable from any point in their 367 * views. 368 * 369 * @return the thumb scroll state 370 * 371 * @note This is the default behavior for touch screens, in general. 372 * @note All other functions namespaced with "thumbscroll" will only 373 * have effect if this mode is enabled. 374 * 375 * @ingroup Elm_Scrolling 376 */ 377 EAPI Eina_Bool elm_config_scroll_thumbscroll_enabled_get(void); 378 379 /** 380 * Set whether scrollers should be draggable from any point in their 381 * views. 382 * 383 * @param enabled the thumb scroll state 384 * 385 * @see elm_config_scroll_thumbscroll_enabled_get() 386 * @ingroup Elm_Scrolling 387 */ 388 EAPI void elm_config_scroll_thumbscroll_enabled_set(Eina_Bool enabled); 389 390 /** 391 * Get the number of pixels one should travel while dragging a 392 * scroller's view to actually trigger scrolling. 393 * 394 * @return the thumb scroll threshold 395 * 396 * One would use higher values for touch screens, in general, because 397 * of their inherent imprecision. 398 * @ingroup Elm_Scrolling 399 */ 400 EAPI unsigned int elm_config_scroll_thumbscroll_threshold_get(void); 401 402 /** 403 * Set the number of pixels one should travel while dragging a 404 * scroller's view to actually trigger scrolling. 405 * 406 * @param threshold the thumb scroll threshold 407 * 408 * @see elm_config_thumbscroll_threshold_get() 409 * @ingroup Elm_Scrolling 410 */ 411 EAPI void elm_config_scroll_thumbscroll_threshold_set(unsigned int threshold); 412 413 /** 414 * Get the number of pixels the range which can be scrolled, 415 * while the scroller is holded. 416 * 417 * @return the thumb scroll hold threshold 418 * 419 * @ingroup Elm_Scrolling 420 */ 421 EAPI unsigned int elm_config_scroll_thumbscroll_hold_threshold_get(void); 422 423 /** 424 * Set the number of pixels the range which can be scrolled, 425 * while the scroller is holded. 426 * 427 * @param threshold the thumb scroll hold threshold 428 * 429 * @see elm_config_thumbscroll_hold_threshold_get() 430 * @ingroup Elm_Scrolling 431 */ 432 EAPI void elm_config_scroll_thumbscroll_hold_threshold_set(unsigned int threshold); 433 434 /** 435 * Get the minimum speed of mouse cursor movement which will trigger 436 * list self scrolling animation after a mouse up event 437 * (pixels/second). 438 * 439 * @return the thumb scroll momentum threshold 440 * 441 * @ingroup Elm_Scrolling 442 */ 443 EAPI double elm_config_scroll_thumbscroll_momentum_threshold_get(void); 444 445 /** 446 * Set the minimum speed of mouse cursor movement which will trigger 447 * list self scrolling animation after a mouse up event 448 * (pixels/second). 449 * 450 * @param threshold the thumb scroll momentum threshold 451 * 452 * @see elm_config_thumbscroll_momentum_threshold_get() 453 * @ingroup Elm_Scrolling 454 */ 455 EAPI void elm_config_scroll_thumbscroll_momentum_threshold_set(double threshold); 456 457 /** 458 * Get the number of pixels the maximum distance which can be flicked. 459 * If it is flicked more than this, 460 * the flick distance is same with maximum distance. 461 * 462 * @return the thumb scroll maximum flick distance 463 * 464 * @ingroup Elm_Scrolling 465 */ 466 EAPI unsigned int elm_config_scroll_thumbscroll_momentum_distance_max_get(void); 467 468 /** 469 * Set the number of pixels the maximum distance which can be flicked. 470 * If it is flicked more than this, 471 * the flick distance is same with maximum distance. 472 * 473 * @param distance the thumb scroll maximum flick distance 474 * 475 * @see elm_config_thumbscroll_momentum_distance_max_get() 476 * @ingroup Elm_Scrolling 477 */ 478 EAPI void elm_config_scroll_thumbscroll_momentum_distance_max_set(unsigned int distance); 479 480 /** 481 * Get the scale ratio of geometric sequence as a kind of inertia a scroller 482 * will impose at self scrolling animations. 483 * 484 * @return the thumb scroll friction 485 * 486 * @ingroup Elm_Scrolling 487 */ 488 EAPI double elm_config_scroll_thumbscroll_momentum_friction_get(void); 489 490 /** 491 * Set the scale ratio of geometric sequence as a kind of inertia a scroller 492 * will impose at self scrolling animations. 493 * 494 * @param friction the thumb scroll friction 495 * 496 * @see elm_config_thumbscroll_momentum_friction_get() 497 * @ingroup Elm_Scrolling 498 */ 499 EAPI void elm_config_scroll_thumbscroll_momentum_friction_set(double friction); 500 501 /** 502 * Get the amount of lag between your actual mouse cursor dragging 503 * movement and a scroller's view movement itself, while pushing it 504 * into bounce state manually. 505 * 506 * @return the thumb scroll border friction 507 * 508 * @ingroup Elm_Scrolling 509 */ 510 EAPI double elm_config_scroll_thumbscroll_border_friction_get(void); 511 512 /** 513 * Set the amount of lag between your actual mouse cursor dragging 514 * movement and a scroller's view movement itself, while pushing it 515 * into bounce state manually. 516 * 517 * @param friction the thumb scroll border friction. @c 0.0 for 518 * perfect synchrony between two movements, @c 1.0 for maximum 519 * lag. 520 * 521 * @see elm_config_thumbscroll_border_friction_get() 522 * @note parameter value will get bound to 0.0 - 1.0 interval, always 523 * 524 * @ingroup Elm_Scrolling 525 */ 526 EAPI void elm_config_scroll_thumbscroll_border_friction_set(double friction); 527 528 /** 529 * Get the sensitivity amount which is be multiplied by the length of 530 * mouse dragging. 531 * 532 * @return the thumb scroll sensitivity friction 533 * 534 * @ingroup Elm_Scrolling 535 */ 536 EAPI double elm_config_scroll_thumbscroll_sensitivity_friction_get(void); 537 538 /** 539 * Set the sensitivity amount which is be multiplied by the length of 540 * mouse dragging. 541 * 542 * @param friction the thumb scroll sensitivity friction. @c 0.1 for 543 * minimum sensitivity, @c 1.0 for maximum sensitivity. 0.25 544 * is proper. 545 * 546 * @see elm_config_thumbscroll_sensitivity_friction_get() 547 * @note parameter value will get bound to 0.1 - 1.0 interval, always 548 * 549 * @ingroup Elm_Scrolling 550 */ 551 EAPI void elm_config_scroll_thumbscroll_sensitivity_friction_set(double friction); 552 553 /** 554 * Get the smooth start mode for scrolling with your finger 555 * 556 * @return smooth scroll flag 557 * 558 * @see elm_config_scroll_thumbscroll_smooth_start_set() 559 * 560 * @since 1.16 561 * @ingroup Elm_Scrolling 562 */ 563 EAPI Eina_Bool elm_config_scroll_thumbscroll_smooth_start_get(void); 564 565 /** 566 * Set the smooth start mode for scrolling with your finger 567 * 568 * This enabled finger scrolling to scroll from the currunt point rather than 569 * jumping and playing catch-up to make start of scrolling look smoother once 570 * the finger or mouse goes past the threshold. 571 * 572 * @param enable The enabled state of the smooth scroller 573 * 574 * @see elm_config_scroll_thumbscroll_smooth_start_get() 575 * 576 * @since 1.16 577 * @ingroup Elm_Scrolling 578 */ 579 EAPI void elm_config_scroll_thumbscroll_smooth_start_set(Eina_Bool enable); 580 581 /** 582 * Get the value of this option 583 * 584 * @return State of this option 585 * 586 * @see elm_config_scroll_animation_disabled_set() 587 * 588 * @since 1.18 589 * @ingroup Elm_Scrolling 590 */ 591 EAPI Eina_Bool elm_config_scroll_animation_disabled_get(void); 592 593 /** 594 * Set the value for this option 595 * 596 * This option disables timed animations during scrolling and forces scroll actions 597 * to be performed immediately. 598 * 599 * @param disable The state of this option 600 * 601 * @see elm_config_scroll_animation_disabled_get() 602 * 603 * @since 1.18 604 * @ingroup Elm_Scrolling 605 */ 606 EAPI void elm_config_scroll_animation_disabled_set(Eina_Bool disable); 607 608 /** 609 * Get the value of this option 610 * 611 * @return State of this option 612 * 613 * @see elm_config_scroll_accel_factor_set() 614 * 615 * @since 1.18 616 * @ingroup Elm_Scrolling 617 */ 618 EAPI double elm_config_scroll_accel_factor_get(void); 619 620 /** 621 * Set the value for this option 622 * 623 * Using a mouse wheel or touchpad to scroll will result in events 624 * being processed. If events occur quickly, the scroll amount will 625 * be multiplied by this value to accelerate the scrolling. 626 * 627 * @param factor The value of this option from 0.0 to 10.0 628 * 629 * @see elm_config_scroll_accel_factor_get() 630 * @note Set 0.0 to disable acceleration 631 * 632 * @since 1.18 633 * @ingroup Elm_Scrolling 634 */ 635 EAPI void elm_config_scroll_accel_factor_set(double factor); 636 637 /** 638 * Get the amount of smoothing to apply to scrolling 639 * 640 * @return the amount of smoothing to apply from 0.0 to 1.0 641 * 642 * @see elm_config_scroll_thumbscroll_smooth_amount_set() 643 * 644 * @since 1.16 645 * @ingroup Elm_Scrolling 646 */ 647 EAPI double elm_config_scroll_thumbscroll_smooth_amount_get(void); 648 649 /** 650 * Set the amount of smoothing to apply to scrolling 651 * 652 * Scrolling with your finger can be smoothed out and the amount to smooth 653 * is determined by this parameter. 0.0 means to not smooth at all and 654 * 1.0 is to smooth as much as possible. 655 * 656 * @param amount the amount to smooth from 0.0 to 1.0 with 0.0 being none 657 * 658 * @see elm_config_thumbscroll_acceleration_threshold_set() 659 * 660 * @since 1.16 661 * @ingroup Elm_Scrolling 662 */ 663 EAPI void elm_config_scroll_thumbscroll_smooth_amount_set(double amount); 664 665 /** 666 * Get the time window to look back at for events for smoothing 667 * 668 * @return the time window in seconds (between 0.0 and 1.0) 669 * 670 * @see elm_config_scroll_thumbscroll_smooth_time_window_set() 671 * 672 * @since 1.16 673 * @ingroup Elm_Scrolling 674 */ 675 EAPI double elm_config_scroll_thumbscroll_smooth_time_window_get(void); 676 677 /** 678 * Set the time window to look back at for events for smoothing 679 * 680 * Scrolling with your finger can be smoothed out and the window of time 681 * to look at is determined by this config. The value is in seconds and 682 * is from 0.0 to 1.0 683 * 684 * @param amount the time window in seconds (between 0.0 and 1.0) 685 * 686 * @see elm_config_scroll_thumbscroll_smooth_time_window_get() 687 * 688 * @since 1.16 689 * @ingroup Elm_Scrolling 690 */ 691 EAPI void elm_config_scroll_thumbscroll_smooth_time_window_set(double amount); 692 693 /** 694 * Get the minimum speed of mouse cursor movement which will accelerate 695 * scrolling velocity after a mouse up event 696 * (pixels/second). 697 * 698 * @return the thumb scroll acceleration threshold 699 * 700 * @ingroup Elm_Scrolling 701 */ 702 EAPI double elm_config_scroll_thumbscroll_acceleration_threshold_get(void); 703 704 /** 705 * Set the minimum speed of mouse cursor movement which will accelerate 706 * scrolling velocity after a mouse up event 707 * (pixels/second). 708 * 709 * @param threshold the thumb scroll acceleration threshold 710 * 711 * @see elm_config_thumbscroll_acceleration_threshold_get() 712 * @ingroup Elm_Scrolling 713 */ 714 EAPI void elm_config_scroll_thumbscroll_acceleration_threshold_set(double threshold); 715 716 /** 717 * Get the time limit for accelerating velocity. 718 * 719 * @return the thumb scroll acceleration time limit 720 * 721 * @ingroup Elm_Scrolling 722 */ 723 EAPI double elm_config_scroll_thumbscroll_acceleration_time_limit_get(void); 724 725 /** 726 * Set the time limit for accelerating velocity. 727 * 728 * @param time_limit the thumb scroll acceleration time limit 729 * 730 * @see elm_config_thumbscroll_acceleration_time_limit_get() 731 * @ingroup Elm_Scrolling 732 */ 733 EAPI void elm_config_scroll_thumbscroll_acceleration_time_limit_set(double time_limit); 734 735 /** 736 * Get the weight for the acceleration. 737 * 738 * @return the thumb scroll acceleration weight 739 * 740 * @ingroup Elm_Scrolling 741 */ 742 EAPI double elm_config_scroll_thumbscroll_acceleration_weight_get(void); 743 744 /** 745 * Set the weight for the acceleration. 746 * 747 * @param weight the thumb scroll acceleration weight 748 * 749 * @see elm_config_thumbscroll_acceleration_weight_get() 750 * @ingroup Elm_Scrolling 751 */ 752 EAPI void elm_config_scroll_thumbscroll_acceleration_weight_set(double weight); 753 754 /** 755 * Get the min limit for the momentum animation duration(unit:second) 756 * 757 * @return the thumb scroll momentum animation duration min limit 758 * 759 * @ingroup Elm_Scrolling 760 */ 761 EAPI double elm_config_scroll_thumbscroll_momentum_animation_duration_min_limit_get(void); 762 763 /** 764 * Set the min limit for the momentum animation duration(unit:second) 765 * 766 * @param min the thumb scroll momentum animation duration min limit 767 * 768 * @see elm_config_scroll_thumbscroll_acceleration_weight_set() 769 * @ingroup Elm_Scrolling 770 */ 771 EAPI void elm_config_scroll_thumbscroll_momentum_animation_duration_min_limit_set(double min); 772 773 /** 774 * Get the max limit for the momentum animation duration(unit:second) 775 * 776 * @return the thumb scroll momentum animation duration max limit 777 * 778 * @ingroup Elm_Scrolling 779 */ 780 EAPI double elm_config_scroll_thumbscroll_momentum_animation_duration_max_limit_get(void); 781 782 /** 783 * Set the max limit for the momentum animation duration(unit:second) 784 * 785 * @param max the thumb scroll momentum animation duration max limit 786 * 787 * @see elm_config_scroll_thumbscroll_momentum_animation_duration_max_limit_get() 788 * @ingroup Elm_Scrolling 789 */ 790 EAPI void elm_config_scroll_thumbscroll_momentum_animation_duration_max_limit_set(double max); 791 792 /** 793 * Get the min amount of inertia a scroller will impose at self scrolling 794 * animations. 795 * 796 * @return the thumb scroll min friction 797 * 798 * @deprecated 799 * 800 * @ingroup Elm_Scrolling 801 */ 802 EAPI double elm_config_scroll_thumbscroll_min_friction_get(void); 803 804 /** 805 * Set the min amount of inertia a scroller will impose at self scrolling 806 * animations. 807 * 808 * @param friction the thumb scroll min friction 809 * 810 * @deprecated 811 * 812 * @see elm_config_thumbscroll_min_friction_get() 813 * @ingroup Elm_Scrolling 814 */ 815 EAPI void elm_config_scroll_thumbscroll_min_friction_set(double friction); 816 817 /** 818 * Get the standard velocity of the scroller. The scroll animation time is 819 * same with thumbscroll friction, if the velocity is same with standard 820 * velocity. 821 * 822 * @return the thumb scroll friction 823 * 824 * @deprecated 825 * 826 * @ingroup Elm_Scrolling 827 */ 828 EAPI double elm_config_scroll_thumbscroll_friction_standard_get(void); 829 830 /** 831 * Set the standard velocity of the scroller. The scroll animation time is 832 * same with thumbscroll friction, if the velocity is same with standard 833 * velocity. 834 * 835 * @param standard the thumb scroll friction standard 836 * 837 * @deprecated 838 * 839 * @see elm_config_thumbscroll_friction_standard_get() 840 * @ingroup Elm_Scrolling 841 */ 842 EAPI void elm_config_scroll_thumbscroll_friction_standard_set(double standard); 843 844 /** 845 * Get the number of pixels the maximum distance which can be flicked. 846 * If it is flicked more than this, 847 * the flick distance is same with maximum distance. 848 * 849 * @return the thumb scroll maximum flick distance 850 * 851 * @deprecated 852 * 853 * @ingroup Elm_Scrolling 854 */ 855 EAPI unsigned int elm_config_scroll_thumbscroll_flick_distance_tolerance_get(void); 856 857 /** 858 * Set the number of pixels the maximum distance which can be flicked. 859 * If it is flicked more than this, 860 * the flick distance is same with maximum distance. 861 * 862 * @param distance the thumb scroll maximum flick distance 863 * 864 * @deprecated 865 * 866 * @see elm_config_thumbscroll_flick_distance_tolerance_get() 867 * @ingroup Elm_Scrolling 868 */ 869 EAPI void elm_config_scroll_thumbscroll_flick_distance_tolerance_set(unsigned int distance); 870 871 /** 872 * Get the amount of inertia a scroller will impose at self scrolling 873 * animations. 874 * 875 * @return the thumb scroll friction 876 * 877 * @deprecated 878 * 879 * @ingroup Elm_Scrolling 880 */ 881 EAPI double elm_config_scroll_thumbscroll_friction_get(void); 882 883 /** 884 * Set the amount of inertia a scroller will impose at self scrolling 885 * animations. 886 * 887 * @param friction the thumb scroll friction 888 * 889 * @deprecated 890 * 891 * @see elm_config_thumbscroll_friction_get() 892 * @ingroup Elm_Scrolling 893 */ 894 EAPI void elm_config_scroll_thumbscroll_friction_set(double friction); 895 896 /** 897 * Get focus auto scroll mode. 898 * 899 * When a region or an item is focused and it resides inside any scroller, 900 * elementary will automatically scroll the focused area to the visible 901 * viewport. 902 * 903 * @return ELM_FOCUS_AUTOSCROLL_MODE_SHOW if directly show the focused region or item automatically. 904 * ELM_FOCUS_AUTOSCROLL_MODE_NONE if do not show the focused region or item automatically. 905 * ELM_FOCUS_AUTOSCROLL_MODE_BRING_IN if bring_in the focused region or item automatically which might invole the scrolling. 906 * 907 * @see elm_config_focus_autoscroll_mode_set() 908 * @ingroup Elm_Focus 909 * @since 1.10 910 */ 911 EAPI Elm_Focus_Autoscroll_Mode elm_config_focus_autoscroll_mode_get(void); 912 913 /** 914 * Set focus auto scroll mode. 915 * 916 * @param mode focus auto scroll mode. This can be one of the 917 * Elm_Focus_Autoscroll_Mode enum values. 918 * 919 * When a region or an item is focused and it resides inside any scroller, 920 * elementary will automatically scroll the focused area to the visible 921 * viewport. 922 * Focus auto scroll mode is set to #ELM_FOCUS_AUTOSCROLL_MODE_SHOW by 923 * default historically. 924 * 925 * @see elm_config_focus_autoscroll_mode_get() 926 * @ingroup Elm_Focus 927 * @since 1.10 928 */ 929 EAPI void elm_config_focus_autoscroll_mode_set(Elm_Focus_Autoscroll_Mode mode); 930 931 /** 932 * Sets the slider's indicator visible mode. 933 * 934 * @param mode Elm_Slider_Indicator_Visible_Mode. 935 * viewport. 936 * 937 * @ingroup Elm_Slider 938 * @since 1.13 939 */ 940 EAPI void elm_config_slider_indicator_visible_mode_set(Elm_Slider_Indicator_Visible_Mode mode); 941 942 /** 943 * Get the slider's indicator visible mode. 944 * 945 * @return @c ELM_SLIDER_INDICATOR_VISIBLE_MODE_DEFAULT if not set anything by the user. 946 * @c ELM_SLIDER_INDICATOR_VISIBLE_MODE_ALWAYS, ELM_SLIDER_INDICATOR_VISIBLE_MODE_ON_FOCUS, 947 * ELM_SLIDER_INDICATOR_VISIBLE_MODE_NONE if any of the above is set by user. 948 * 949 * @ingroup Elm_Slider 950 * @since 1.13 951 */ 952 EAPI Elm_Slider_Indicator_Visible_Mode elm_config_slider_indicator_visible_mode_get(void); 953 954 /** 955 * @} 956 */ 957 958 /** 959 * @defgroup longpress_group Longpress 960 * @ingroup Elementary 961 * 962 * @brief Configuration for longpress events. 963 * 964 * @{ 965 */ 966 967 /** 968 * Get the duration for occurring long press event. 969 * 970 * @return Timeout for long press event 971 * @ingroup Longpress 972 */ 973 EAPI double elm_config_longpress_timeout_get(void); 974 975 /** 976 * Set the duration for occurring long press event. 977 * 978 * @param longpress_timeout Timeout for long press event 979 * @ingroup Longpress 980 */ 981 EAPI void elm_config_longpress_timeout_set(double longpress_timeout); 982 983 /** 984 * @} 985 */ 986 987 /** 988 * @defgroup softcursor_group SotfCursor 989 * @ingroup Elementary 990 * 991 * @brief Configuration for softcursor. 992 * 993 * @{ 994 */ 995 996 /** 997 * Set the mode used for software provided mouse cursors inline in the window 998 * canvas. 999 * 1000 * A software rendered cursor can be provided for rendering inline inside the 1001 * canvas windows in the event the native display system does not provide one 1002 * or the native one is not wanted. 1003 * 1004 * @param mode The mode for software cursors 1005 * @ingroup Softcursor 1006 * 1007 * @see elm_config_softcursor_mode_get() 1008 * @since 1.7 1009 */ 1010 EAPI void elm_config_softcursor_mode_set(Elm_Softcursor_Mode mode); 1011 1012 /** 1013 * Get the software cursor mode 1014 * 1015 * @return The mode used for software cursors 1016 * @ingroup Softcursor 1017 * 1018 * @see elm_config_softcursor_mode_set() 1019 * @since 1.7 1020 */ 1021 EAPI Elm_Softcursor_Mode elm_config_softcursor_mode_get(void); 1022 1023 /** 1024 * @} 1025 */ 1026 1027 /** 1028 * @ingroup Elm_Tooltips 1029 * @{ 1030 */ 1031 1032 /** 1033 * Get the duration after which tooltip will be shown. 1034 * 1035 * @return Duration after which tooltip will be shown. 1036 */ 1037 EAPI double elm_config_tooltip_delay_get(void); 1038 1039 /** 1040 * Set the duration after which tooltip will be shown. 1041 * 1042 * @return @c EINA_TRUE if value is set. 1043 */ 1044 EAPI void elm_config_tooltip_delay_set(double delay); 1045 1046 /** 1047 * @} 1048 */ 1049 1050 /** 1051 * Get the configured cursor engine only usage 1052 * 1053 * This gets the globally configured exclusive usage of engine cursors. 1054 * 1055 * @return 1 if only engine cursors should be used 1056 * @ingroup Elm_Cursors 1057 */ 1058 EAPI Eina_Bool elm_config_cursor_engine_only_get(void); 1059 1060 /** 1061 * Set the configured cursor engine only usage 1062 * 1063 * This sets the globally configured exclusive usage of engine cursors. 1064 * It won't affect cursors set before changing this value. 1065 * 1066 * @param engine_only If 1 only engine cursors will be enabled, if 0 will 1067 * look for them on theme before. 1068 * @ingroup Elm_Cursors 1069 */ 1070 EAPI void elm_config_cursor_engine_only_set(Eina_Bool engine_only); 1071 1072 /** 1073 * Get the global scaling factor 1074 * 1075 * This gets the globally configured scaling factor that is applied to all 1076 * objects. 1077 * 1078 * @return The scaling factor 1079 * @ingroup Elm_Scaling 1080 */ 1081 EAPI double elm_config_scale_get(void); 1082 1083 /** 1084 * Set the global scaling factor 1085 * 1086 * This sets the globally configured scaling factor that is applied to all 1087 * objects. 1088 * 1089 * @param scale The scaling factor to set 1090 * @ingroup Elm_Scaling 1091 */ 1092 EAPI void elm_config_scale_set(double scale); 1093 1094 /** 1095 * Get the icon theme the user has set. 1096 * 1097 * This gets the global icon theme currently set or the default value 1098 * #ELM_CONFIG_ICON_THEME_ELEMENTARY. 1099 * 1100 * @return the icon theme to use 1101 * @ingroup Elm_Icon 1102 * @since 1.18 1103 */ 1104 EAPI const char *elm_config_icon_theme_get(void); 1105 1106 /** 1107 * Set the icon theme for all elementary apps. 1108 * 1109 * This method will set the icon theme for all elm_icon_standard_set calls. 1110 * Valid parameters are the name of an installed freedesktop.org icon theme 1111 * or #ELM_CONFIG_ICON_THEME_ELEMENTARY for the built in theme. 1112 * 1113 * @param theme the name of a freedesktop.org icon theme or #ELM_CONFIG_ICON_THEME_ELEMENTARY 1114 * @ingroup Elm_Icon 1115 * @since 1.18 1116 */ 1117 EAPI void elm_config_icon_theme_set(const char *theme); 1118 1119 /** 1120 * @defgroup Elm_Password_last_show Password show last 1121 * @ingroup Elementary 1122 * 1123 * Show last feature of password mode enables user to view 1124 * the last input entered for few seconds before masking it. 1125 * These functions allow to set this feature in password mode 1126 * of entry widget and also allow to manipulate the duration 1127 * for which the input has to be visible. 1128 * 1129 * @{ 1130 */ 1131 1132 /** 1133 * Get the "show last" setting of password mode. 1134 * 1135 * This gets the "show last" setting of password mode which might be 1136 * enabled or disabled. 1137 * 1138 * @return @c EINA_TRUE, if the "show last" setting is enabled, 1139 * @c EINA_FALSE if it's disabled. 1140 * 1141 * @ingroup Elm_Password_last_show 1142 */ 1143 EAPI Eina_Bool elm_config_password_show_last_get(void); 1144 1145 /** 1146 * Set show last setting in password mode. 1147 * 1148 * This enables or disables show last setting of password mode. 1149 * 1150 * @param password_show_last If @c EINA_TRUE, enables "show last" in password mode. 1151 * @see elm_config_password_show_last_timeout_set() 1152 * @ingroup Elm_Password_last_show 1153 */ 1154 EAPI void elm_config_password_show_last_set(Eina_Bool password_show_last); 1155 1156 /** 1157 * Get the timeout value in "show last" password mode. 1158 * 1159 * This gets the time out value for which the last input entered in password 1160 * mode will be visible. 1161 * 1162 * @return The timeout value of "show last" password mode. 1163 * @ingroup Elm_Password_last_show 1164 */ 1165 EAPI double elm_config_password_show_last_timeout_get(void); 1166 1167 /** 1168 * Set's the timeout value in "show last" password mode. 1169 * 1170 * This sets the time out value for which the last input entered in password 1171 * mode will be visible. 1172 * 1173 * @param password_show_last_timeout The timeout value. 1174 * @see elm_config_password_show_last_set() 1175 * @ingroup Elm_Password_last_show 1176 */ 1177 EAPI void elm_config_password_show_last_timeout_set(double password_show_last_timeout); 1178 1179 /** 1180 * @} 1181 */ 1182 1183 /** 1184 * @defgroup Elm_Engine Elementary Engine 1185 * @ingroup Elementary 1186 * 1187 * These are functions setting and querying which rendering engine 1188 * Elementary will use for drawing its windows' pixels. 1189 * 1190 * The following are the available engines: 1191 * @li "fb" (Framebuffer) 1192 * @li "buffer" (Pixel Memory Buffer) 1193 * @li "ews" (Ecore + Evas Single Process Windowing System) 1194 * @li NULL - no engine config 1195 * 1196 * @deprecated Please use elm_config_accel_preference_override_set() instead 1197 * 1198 * @{ 1199 */ 1200 1201 /** 1202 * @brief Get Elementary's rendering engine in use. 1203 * 1204 * @return The rendering engine's name 1205 * @note there's no need to free the returned string, here. 1206 * 1207 * This gets the global rendering engine that is applied to all Elementary 1208 * applications. 1209 * 1210 * @see elm_config_engine_set() 1211 * @deprecated use elm_config_accel_preference_get() + elm_config_accel_preference_set() 1212 */ 1213 EINA_DEPRECATED EAPI const char *elm_config_engine_get(void); 1214 1215 /** 1216 * @brief Set Elementary's rendering engine for use. 1217 * 1218 * @param engine The rendering engine's name 1219 * 1220 * Note that it will take effect only to Elementary windows created after 1221 * this is called. 1222 * 1223 * @see elm_win_add() 1224 * @deprecated use elm_config_accel_preference_get() + elm_config_accel_preference_set() 1225 */ 1226 EINA_DEPRECATED EAPI void elm_config_engine_set(const char *engine); 1227 1228 /** 1229 * @brief Get Elementary's preferred engine to use. 1230 * 1231 * @return The rendering engine's name 1232 * @note there's no need to free the returned string, here. 1233 * 1234 * This gets the global rendering engine that is applied to all Elementary 1235 * applications and is PREFERRED by the application. This can (and will) 1236 * override the engine configured for all applications which. It is rare to 1237 * explicitly ask for an engine (likely need is the buffer engine and not 1238 * much more), so use elm_config_accel_preference_get() and 1239 * elm_config_accel_preference_set() normally. 1240 * 1241 * @see elm_config_preferred_engine_set() 1242 */ 1243 EAPI const char *elm_config_preferred_engine_get(void); 1244 1245 /** 1246 * @brief Set Elementary's preferred rendering engine for use. 1247 * 1248 * @param engine The rendering engine's name 1249 * 1250 * Note that it will take effect only to Elementary windows created after 1251 * this is called. This overrides the engine set by configuration at 1252 * application startup. Note that it is a hint and may not be honored. 1253 * It is rare to explicitly ask for an engine (likely need is the buffer 1254 * engine and not much more), so use elm_config_accel_preference_get() and 1255 * elm_config_accel_preference_set() normally. 1256 * 1257 * @see elm_win_add() 1258 * @see elm_config_accel_preference_set() 1259 * @see elm_config_engine_set() 1260 */ 1261 EAPI void elm_config_preferred_engine_set(const char *engine); 1262 1263 /** 1264 * @brief Get Elementary's preferred engine to use. 1265 * 1266 * @return The acceleration preference hint string 1267 * @note there's no need to free the returned string, here. 1268 * 1269 * See elm_config_accel_preference_set() for more information, but this simply 1270 * returns what was set by this call, nothing more. 1271 * 1272 * @see elm_config_accel_preference_set() 1273 * @since 1.10 1274 */ 1275 EAPI const char *elm_config_accel_preference_get(void); 1276 1277 /** 1278 * @brief Set Elementary's acceleration preferences for new windows. 1279 * 1280 * @param pref The preference desired as a normal C string 1281 * 1282 * Note that it will take effect only to Elementary windows created after 1283 * this is called. The @p pref string is a freeform C string that indicates 1284 * what kind of acceleration is preferred. Here "acceleration" majorly 1285 * means to rendering and which hardware unit application renders GUIs with. 1286 * This may or may not be honored, but a best attempt will 1287 * be made. Known strings are as follows: 1288 * 1289 * "gl", "opengl" - try use OpenGL. 1290 * "3d" - try and use a 3d acceleration unit. 1291 * "hw", "hardware", "accel" - try any acceleration unit (best possible) 1292 * "none" - use no acceleration. try use software (since 1.16) 1293 * 1294 * Since 1.14, it is also possible to specify some GL properties for the GL 1295 * window surface. This allows applications to use GLView with depth, stencil 1296 * and MSAA buffers with direct rendering. The new accel preference string 1297 * format is thus "{HW Accel}[:depth{value}[:stencil{value}[:msaa{str}]]]". 1298 * 1299 * Accepted values for depth are for instance "depth", "depth16", "depth24". 1300 * Accepted values for stencil are "stencil", "stencil1", "stencil8". 1301 * For MSAA, only predefined strings are accepted: "msaa", "msaa_low", 1302 * "msaa_mid" and "msaa_high". The selected configuration is not guaranteed 1303 * and is only valid in case of GL acceleration. Only the base acceleration 1304 * string will be saved (e.g. "gl" or "hw"). 1305 * 1306 * Full examples include: 1307 * 1308 * "gl", - try to use OpenGL 1309 * "hw:depth:stencil", - use HW acceleration with default depth and stencil buffers 1310 * "opengl:depth24:stencil8:msaa_mid" - use OpenGL with 24-bit depth, 1311 * 8-bit stencil and a medium number of MSAA samples in the backbuffer. 1312 * 1313 * This takes precedence over engine preferences set with 1314 * elm_config_preferred_engine_set(). 1315 * 1316 * @see elm_win_add() 1317 * @see elm_config_accel_preference_override_set() 1318 * 1319 * @since 1.10 1320 */ 1321 EAPI void elm_config_accel_preference_set(const char *pref); 1322 1323 1324 typedef struct _Elm_Text_Class 1325 { 1326 const char *name; 1327 const char *desc; 1328 } Elm_Text_Class; 1329 1330 typedef struct _Elm_Font_Overlay 1331 { 1332 const char *text_class; 1333 const char *font; 1334 Evas_Font_Size size; 1335 } Elm_Font_Overlay; 1336 1337 /** 1338 * Get Elementary's list of supported text classes. 1339 * 1340 * @return The text classes list, with @c Elm_Text_Class blobs as data. 1341 * @ingroup Elm_Fonts 1342 * 1343 * Release the list with elm_text_classes_list_free(). 1344 */ 1345 EAPI Eina_List *elm_config_text_classes_list_get(void); 1346 1347 /** 1348 * Free Elementary's list of supported text classes. 1349 * 1350 * @param list The text classes list. 1351 * @ingroup Elm_Fonts 1352 * 1353 * @see elm_config_text_classes_list_get(). 1354 */ 1355 EAPI void elm_config_text_classes_list_free(Eina_List *list); 1356 1357 /** 1358 * Get Elementary's list of font overlays, set with 1359 * elm_config_font_overlay_set(). 1360 * 1361 * @return The font overlays list, with @c Elm_Font_Overlay blobs as 1362 * data. 1363 * 1364 * @ingroup Elm_Fonts 1365 * 1366 * For each text class, one can set a <b>font overlay</b> for it, 1367 * overriding the default font properties for that class coming from 1368 * the theme in use. There is no need to free this list. 1369 * 1370 * @see elm_config_font_overlay_set() and elm_config_font_overlay_unset(). 1371 */ 1372 EAPI const Eina_List *elm_config_font_overlay_list_get(void); 1373 1374 /** 1375 * Set a font overlay for a given Elementary text class. 1376 * 1377 * @param text_class Text class name 1378 * @param font Font name and style string 1379 * @param size Font size. 1380 * 1381 * @note If the @p size is lower than zero, the value will be the amount of the size percentage. ex) -50: half of the current size, -100: current size, -10: 1/10 size. 1382 * 1383 * @ingroup Elm_Fonts 1384 * 1385 * @p font has to be in the format returned by elm_font_fontconfig_name_get(). 1386 * @see elm_config_font_overlay_list_get() 1387 * @see elm_config_font_overlay_unset() 1388 * @see edje_object_text_class_set() 1389 */ 1390 EAPI void elm_config_font_overlay_set(const char *text_class, const char *font, Evas_Font_Size size); 1391 1392 /** 1393 * Get access mode 1394 * 1395 * @return the access mode bouncing state 1396 * 1397 * @since 1.7 1398 * 1399 * @ingroup Access 1400 * 1401 * @see elm_config_access_set() 1402 */ 1403 EAPI Eina_Bool elm_config_access_get(void); 1404 1405 /** 1406 * Set access mode 1407 * 1408 * @param is_access If @c EINA_TRUE, enables access mode 1409 * 1410 * @note Elementary objects may have information (e.g. label on the elm_button) 1411 * to be read. This information is read by access module when an object 1412 * receives EVAS_CALLBACK_MOUSE_IN event 1413 * 1414 * @since 1.7 1415 * 1416 * @ingroup Access 1417 * 1418 * @see elm_config_access_get() 1419 */ 1420 EAPI void elm_config_access_set(Eina_Bool is_access); 1421 1422 /** 1423 * Get whether selection should be cleared when entry widget is unfocused. 1424 * 1425 * @return if the selection would be cleared on unfocus. 1426 * 1427 * @since 1.7 1428 * 1429 * @ingroup Selection 1430 * 1431 * @see elm_config_selection_unfocused_clear_set() 1432 */ 1433 EAPI Eina_Bool elm_config_selection_unfocused_clear_get(void); 1434 1435 /** 1436 * Set whether selection should be cleared when entry widget is unfocused. 1437 * 1438 * @param enabled If @c EINA_TRUE, clear selection when unfocus, 1439 * otherwise does not clear selection when unfocus. 1440 * 1441 * @since 1.7 1442 * 1443 * @ingroup Selection 1444 * 1445 * @see elm_config_selection_unfocused_clear_get() 1446 */ 1447 EAPI void elm_config_selection_unfocused_clear_set(Eina_Bool enabled); 1448 1449 /** 1450 * Unset a font overlay for a given Elementary text class. 1451 * 1452 * @param text_class Text class name 1453 * 1454 * @ingroup Elm_Fonts 1455 * 1456 * This will bring back text elements belonging to text class 1457 * @p text_class back to their default font settings. 1458 */ 1459 EAPI void elm_config_font_overlay_unset(const char *text_class); 1460 1461 /** 1462 * Apply the changes made with elm_config_font_overlay_set() and 1463 * elm_config_font_overlay_unset() on the current Elementary window. 1464 * 1465 * @ingroup Elm_Fonts 1466 * 1467 * This applies all font overlays set to all objects in the UI. 1468 */ 1469 EAPI void elm_config_font_overlay_apply(void); 1470 1471 /** 1472 * Apply the specified font hinting type. 1473 * EVAS_FONT_HINTING_NONE < No font hinting 1474 * EVAS_FONT_HINTING_AUTO < Automatic font hinting 1475 * EVAS_FONT_HINTING_BYTECODE < Bytecode font hinting 1476 * 1477 * @param type The font hinting type 1478 * @ingroup Elm_Fonts 1479 * 1480 * This applies font hint changes to all windows of the current application. 1481 * 1482 * @since 1.13 1483 */ 1484 EAPI void elm_config_font_hint_type_set(int type); 1485 1486 /** 1487 * Get the configured "finger size" 1488 * 1489 * @return The finger size 1490 * 1491 * This gets the globally configured finger size, <b>in pixels</b> 1492 * 1493 * @ingroup Elm_Fingers 1494 */ 1495 EAPI Evas_Coord elm_config_finger_size_get(void); 1496 1497 /** 1498 * Set the configured finger size 1499 * 1500 * This sets the globally configured finger size in pixels 1501 * 1502 * @param size The finger size 1503 * @ingroup Elm_Fingers 1504 */ 1505 EAPI void elm_config_finger_size_set(Evas_Coord size); 1506 1507 /** 1508 * Get the configured cache flush interval time 1509 * 1510 * This gets the globally configured cache flush interval time, in 1511 * ticks 1512 * 1513 * @return The cache flush interval time 1514 * @ingroup Elm_Caches 1515 * 1516 * @see elm_cache_all_flush() 1517 */ 1518 EAPI int elm_config_cache_flush_interval_get(void); 1519 1520 /** 1521 * Set the configured cache flush interval time 1522 * 1523 * This sets the globally configured cache flush interval time, in ticks 1524 * 1525 * @param size The cache flush interval time 1526 * 1527 * @note The @p size must be greater than 0. if not, the cache flush will be 1528 * ignored. 1529 * 1530 * @ingroup Elm_Caches 1531 * 1532 * @see elm_cache_all_flush() 1533 */ 1534 EAPI void elm_config_cache_flush_interval_set(int size); 1535 1536 /** 1537 * Get the configured cache flush enabled state 1538 * 1539 * This gets the globally configured cache flush state - if it is enabled 1540 * or not. When cache flushing is enabled, elementary will regularly 1541 * (see elm_config_cache_flush_interval_get() ) flush caches and dump data out of 1542 * memory and allow usage to re-seed caches and data in memory where it 1543 * can do so. An idle application will thus minimize its memory usage as 1544 * data will be freed from memory and not be re-loaded as it is idle and 1545 * not rendering or doing anything graphically right now. 1546 * 1547 * @return The cache flush state 1548 * @ingroup Elm_Caches 1549 * 1550 * @see elm_cache_all_flush() 1551 */ 1552 EAPI Eina_Bool elm_config_cache_flush_enabled_get(void); 1553 1554 /** 1555 * Set the configured cache flush enabled state 1556 * 1557 * This sets the globally configured cache flush enabled state. 1558 * 1559 * @param enabled The cache flush enabled state 1560 * @ingroup Elm_Caches 1561 * 1562 * @see elm_cache_all_flush() 1563 */ 1564 EAPI void elm_config_cache_flush_enabled_set(Eina_Bool enabled); 1565 1566 /** 1567 * Get the configured font cache size 1568 * 1569 * This gets the globally configured font cache size, in kilo bytes. 1570 * 1571 * @return The font cache size 1572 * @ingroup Elm_Caches 1573 */ 1574 EAPI int elm_config_cache_font_cache_size_get(void); 1575 1576 /** 1577 * Set the configured font cache size 1578 * 1579 * This sets the globally configured font cache size, in kilo bytes 1580 * 1581 * @param size The font cache size 1582 * @ingroup Elm_Caches 1583 */ 1584 EAPI void elm_config_cache_font_cache_size_set(int size); 1585 1586 /** 1587 * Get the configured image cache size 1588 * 1589 * This gets the globally configured image cache size, in kilo bytes 1590 * 1591 * @return The image cache size 1592 * @ingroup Elm_Caches 1593 */ 1594 EAPI int elm_config_cache_image_cache_size_get(void); 1595 1596 /** 1597 * Set the configured image cache size 1598 * 1599 * This sets the globally configured image cache size, in kilo bytes 1600 * 1601 * @param size The image cache size 1602 * @ingroup Elm_Caches 1603 */ 1604 EAPI void elm_config_cache_image_cache_size_set(int size); 1605 1606 /** 1607 * Get the configured edje file cache size. 1608 * 1609 * This gets the globally configured edje file cache size, in number 1610 * of files. 1611 * 1612 * @return The edje file cache size 1613 * @ingroup Elm_Caches 1614 */ 1615 EAPI int elm_config_cache_edje_file_cache_size_get(void); 1616 1617 /** 1618 * Set the configured edje file cache size 1619 * 1620 * This sets the globally configured edje file cache size, in number 1621 * of files. 1622 * 1623 * @param size The edje file cache size 1624 * @ingroup Elm_Caches 1625 */ 1626 EAPI void elm_config_cache_edje_file_cache_size_set(int size); 1627 1628 /** 1629 * Get the configured edje collections (groups) cache size. 1630 * 1631 * This gets the globally configured edje collections cache size, in 1632 * number of collections. 1633 * 1634 * @return The edje collections cache size 1635 * @ingroup Elm_Caches 1636 */ 1637 EAPI int elm_config_cache_edje_collection_cache_size_get(void); 1638 1639 /** 1640 * Set the configured edje collections (groups) cache size 1641 * 1642 * This sets the globally configured edje collections cache size, in 1643 * number of collections. 1644 * 1645 * @param size The edje collections cache size 1646 * @ingroup Elm_Caches 1647 */ 1648 EAPI void elm_config_cache_edje_collection_cache_size_set(int size); 1649 1650 /** 1651 * Get the configured vsync flag 1652 * 1653 * This gets the globally configured vsync flag that asks some backend 1654 * engines to use vsync display if possible. 1655 * 1656 * @return If vsync is enabled 1657 * 1658 * @since 1.11 1659 */ 1660 EAPI Eina_Bool elm_config_vsync_get(void); 1661 1662 /** 1663 * Set the configured vsync flag 1664 * 1665 * This sets the globally configured vsync flag that asks some backend 1666 * engines to use vsync display if possible. 1667 * 1668 * @param enabled This should be @c EINA_TRUE if enabled, or @c EINA_FALSE if 1669 * not. 1670 * 1671 * @since 1.11 1672 */ 1673 EAPI void elm_config_vsync_set(Eina_Bool enabled); 1674 1675 /** 1676 * Get the configure flag that will define if a window aggressively drop its 1677 * resources when minimized. 1678 * 1679 * @return if it does. 1680 * 1681 * @since 1.21 1682 */ 1683 EAPI Eina_Bool elm_config_agressive_withdrawn_get(void); 1684 1685 /** 1686 * Set the configure flag that will make a window aggressively drop its 1687 * resources when minimized. 1688 * 1689 * @param enabled This should be @c EINA_TRUE if enabled, or @c EINA_FALSE if 1690 * not. 1691 * @since 1.21 1692 */ 1693 EAPI void elm_config_agressive_withdrawn_set(Eina_Bool enabled); 1694 1695 /** 1696 * Get the acceleration override preference flag 1697 * 1698 * This gets the acceleration override preference. This is a flag that 1699 * has the global system acceleration preference configuration forcibly 1700 * override whatever acceleration preference the application may want. 1701 * 1702 * @return If acceleration override is enabled 1703 * 1704 * @since 1.11 1705 */ 1706 EAPI Eina_Bool elm_config_accel_preference_override_get(void); 1707 1708 /** 1709 * Set the acceleration override preference flag 1710 * 1711 * This sets the acceleration override preference. This is a flag that 1712 * has the global system acceleration preference configuration forcibly 1713 * override whatever acceleration preference the application may want. 1714 * 1715 * @param enabled This should be @c EINA_TRUE if enabled, or @c EINA_FALSE if 1716 * not. 1717 * 1718 * @see elm_config_accel_preference_set() 1719 * 1720 * @since 1.11 1721 */ 1722 EAPI void elm_config_accel_preference_override_set(Eina_Bool enabled); 1723 1724 /** 1725 * Get the enable status of the focus highlight 1726 * 1727 * This gets whether the highlight on focused objects is enabled or not 1728 * 1729 * @return enable @c EINA_TRUE if the focus highlight is enabled, @c EINA_FALSE 1730 * otherwise. 1731 * 1732 * @see elm_config_focus_highlight_enabled_set() 1733 * @ingroup Elm_Focus 1734 */ 1735 EAPI Eina_Bool elm_config_focus_highlight_enabled_get(void); 1736 1737 /** 1738 * Set the enable status of the focus highlight 1739 * 1740 * @param enable Enable highlight if @c EINA_TRUE, disable otherwise 1741 * 1742 * Set whether to show or not the highlight on focused objects 1743 * 1744 * Note that it will take effect only to Elementary windows created after 1745 * this is called. 1746 * 1747 * @see elm_config_focus_highlight_enabled_get() 1748 * @ingroup Elm_Focus 1749 */ 1750 EAPI void elm_config_focus_highlight_enabled_set(Eina_Bool enable); 1751 1752 /** 1753 * Get the enable status of the focus highlight animation 1754 * 1755 * @return animate @c EINA_TRUE if the focus highlight animation is enabled, @c 1756 * EINA_FALSE otherwise. 1757 * 1758 * Get whether the focus highlight, if enabled, will animate its switch from 1759 * one object to the next 1760 * 1761 * @see elm_config_focus_highlight_animate_set() 1762 * @ingroup Elm_Focus 1763 */ 1764 EAPI Eina_Bool elm_config_focus_highlight_animate_get(void); 1765 1766 /** 1767 * Set the enable status of the highlight animation 1768 * 1769 * @param animate Enable animation if @c EINA_TRUE, disable otherwise 1770 * 1771 * Set whether the focus highlight, if enabled, will animate its switch from 1772 * one object to the next 1773 * 1774 * Note that it will take effect only to Elementary windows created after 1775 * this is called. 1776 * 1777 * @see elm_config_focus_highlight_animate_get() 1778 * @ingroup Elm_Focus 1779 */ 1780 EAPI void elm_config_focus_highlight_animate_set(Eina_Bool animate); 1781 1782 /** 1783 * Get the disable status of the focus highlight clip feature. 1784 * 1785 * @return The focus highlight clip disable status 1786 * 1787 * Get whether the focus highlight clip feature is disabled. If disabled return 1788 * @c EINA_TRUE, else return @c EINA_FALSE. If the return is @c EINA_TRUE, focus 1789 * highlight clip feature is not disabled so the focus highlight can be clipped. 1790 * 1791 * @see elm_config_focus_highlight_clip_disabled_set() 1792 * @since 1.10 1793 * @ingroup Elm_Focus 1794 */ 1795 EAPI Eina_Bool elm_config_focus_highlight_clip_disabled_get(void); 1796 1797 /** 1798 * Set the disable status of the focus highlight clip feature. 1799 * 1800 * @param disable Disable focus highlight clip feature if @c EINA_TRUE, enable 1801 * it otherwise. 1802 * 1803 * @see elm_config_focus_highlight_clip_disabled_get() 1804 * @since 1.10 1805 * @ingroup Elm_Focus 1806 */ 1807 EAPI void elm_config_focus_highlight_clip_disabled_set(Eina_Bool disable); 1808 1809 /** 1810 * Get the focus movement policy 1811 * 1812 * @return The focus movement policy 1813 * 1814 * Get how the focus is moved to another object. It can be 1815 * #ELM_FOCUS_MOVE_POLICY_CLICK or #ELM_FOCUS_MOVE_POLICY_IN. The first means 1816 * elementary focus is moved on elementary object click. The second means 1817 * elementary focus is moved on elementary object mouse in. 1818 * 1819 * @see elm_config_focus_move_policy_set() 1820 * @since 1.10 1821 * @ingroup Elm_Focus 1822 */ 1823 EAPI Elm_Focus_Move_Policy elm_config_focus_move_policy_get(void); 1824 1825 /** 1826 * Set elementary focus movement policy 1827 * 1828 * @param policy A policy to apply for the focus movement 1829 * 1830 * @see elm_config_focus_move_policy_get() 1831 * @since 1.10 1832 * @ingroup Elm_Focus 1833 */ 1834 EAPI void elm_config_focus_move_policy_set(Elm_Focus_Move_Policy policy); 1835 1836 /** 1837 * Get disable status of item select on focus feature. 1838 * 1839 * @return The item select on focus disable status 1840 * 1841 * @see elm_config_item_select_on_focus_disabled_set 1842 * @since 1.10 1843 * @ingroup Elm_Focus 1844 */ 1845 EAPI Eina_Bool elm_config_item_select_on_focus_disabled_get(void); 1846 1847 /** 1848 * Set the disable status of the item select on focus feature. 1849 * 1850 * @param disabled Disable item select on focus if @c EINA_TRUE, enable otherwise 1851 * 1852 * @see elm_config_item_select_on_focus_disabled_get 1853 * @since 1.10 1854 * @ingroup Elm_Focus 1855 */ 1856 EAPI void elm_config_item_select_on_focus_disabled_set(Eina_Bool disabled); 1857 1858 /** 1859 * Get status of first item focus on first focusin feature. 1860 * 1861 * @return The first item focus on first focusin status 1862 * 1863 * @see elm_config_first_item_focus_on_first_focusin_set 1864 * @since 1.11 1865 * @ingroup Elm_Focus 1866 */ 1867 EAPI Eina_Bool elm_config_first_item_focus_on_first_focusin_get(void); 1868 1869 /** 1870 * Set the first item focus on first focusin feature. 1871 * 1872 * @param enabled first_item_focus_on_first_focusin if @c EINA_TRUE, enable otherwise 1873 * 1874 * @see elm_config_first_item_focus_on_first_focusin_get 1875 * @since 1.11 1876 * @ingroup Elm_Focus 1877 */ 1878 EAPI void elm_config_first_item_focus_on_first_focusin_set(Eina_Bool enabled); 1879 1880 /** 1881 * Get the system mirrored mode. This determines the default mirrored mode 1882 * of widgets. 1883 * 1884 * @return @c EINA_TRUE if mirrored is set, @c EINA_FALSE otherwise 1885 */ 1886 EAPI Eina_Bool elm_config_mirrored_get(void); 1887 1888 /** 1889 * Set the system mirrored mode. This determines the default mirrored mode 1890 * of widgets. 1891 * 1892 * @param mirrored @c EINA_TRUE to set mirrored mode, @c EINA_FALSE to unset it. 1893 */ 1894 EAPI void elm_config_mirrored_set(Eina_Bool mirrored); 1895 1896 /** 1897 * Get the clouseau state. @c EINA_TRUE if clouseau was tried to be run. 1898 * 1899 * @since 1.8 1900 * @return @c EINA_TRUE if clouseau was tried to run, @c EINA_FALSE otherwise 1901 */ 1902 EAPI Eina_Bool elm_config_clouseau_enabled_get(void); 1903 1904 /** 1905 * Get the clouseau state. @c EINA_TRUE if clouseau should be attempted to be run. 1906 * 1907 * @since 1.8 1908 * @param enabled @c EINA_TRUE to try and run clouseau, @c EINA_FALSE otherwise. 1909 */ 1910 EAPI void elm_config_clouseau_enabled_set(Eina_Bool enabled); 1911 1912 /** 1913 * Get the indicator service name according to the rotation degree. 1914 * 1915 * @param rotation The rotation which related with the indicator service name, 1916 * in degrees (0-360), 1917 * 1918 * @return The indicator service name according to the rotation degree. The 1919 * indicator service name can be either @c "elm_indicator_portrait" or 1920 * @c "elm_indicator_landscape". 1921 * 1922 * @note Do not free the return string. 1923 */ 1924 EAPI const char *elm_config_indicator_service_get(int rotation); 1925 1926 /** 1927 * Get the duration for occurring long tap event of gesture layer. 1928 * 1929 * @return Timeout for long tap event of gesture layer. 1930 * @ingroup Elm_Gesture_Layer_Group 1931 * @since 1.8 1932 */ 1933 EAPI double elm_config_glayer_long_tap_start_timeout_get(void); 1934 1935 /** 1936 * Set the duration for occurring long tap event of gesture layer. 1937 * 1938 * @param long_tap_timeout Timeout for long tap event of gesture layer. 1939 * @ingroup Elm_Gesture_Layer_Group 1940 * @since 1.8 1941 */ 1942 EAPI void elm_config_glayer_long_tap_start_timeout_set(double long_tap_timeout); 1943 1944 /** 1945 * Get the duration for occurring double tap event of gesture layer. 1946 * 1947 * @return Timeout for double tap event of gesture layer. 1948 * @ingroup Elm_Gesture_Layer_Group 1949 * @since 1.8 1950 */ 1951 EAPI double elm_config_glayer_double_tap_timeout_get(void); 1952 1953 /** 1954 * Set the duration for occurring double tap event of gesture layer. 1955 * 1956 * @param double_tap_timeout Timeout for double tap event of gesture layer. 1957 * @ingroup Elm_Gesture_Layer_Group 1958 * @since 1.8 1959 */ 1960 EAPI void elm_config_glayer_double_tap_timeout_set(double double_tap_timeout); 1961 1962 typedef struct _Elm_Color_Class 1963 { 1964 const char *name; 1965 const char *desc; 1966 } Elm_Color_Class; 1967 1968 typedef struct _Elm_Color_Overlay 1969 { 1970 const char *color_class; 1971 struct { 1972 unsigned char r, g, b, a; 1973 } color, outline, shadow; 1974 } Elm_Color_Overlay; 1975 1976 /** 1977 * Get Elementary's list of supported color classes. 1978 * 1979 * @return The color classes list, with @c Elm_Color_Class blobs as data. 1980 * @ingroup Colors 1981 * @since 1.10 1982 * 1983 * Release the list with elm_color_classes_list_free(). 1984 */ 1985 EAPI Eina_List *elm_config_color_classes_list_get(void); 1986 1987 /** 1988 * Free Elementary's list of supported color classes. 1989 * 1990 * @param list The list of color classes to freed 1991 * @ingroup Colors 1992 * @since 1.10 1993 * 1994 * @see elm_config_color_classes_list_get(). 1995 */ 1996 EAPI void elm_config_color_classes_list_free(Eina_List *list); 1997 1998 /** 1999 * Get Elementary's list of color overlays, set with 2000 * elm_config_color_overlay_set(). 2001 * 2002 * @return The color overlays list, with @c Elm_Color_Overlay blobs as 2003 * data. 2004 * 2005 * @ingroup Colors 2006 * @since 1.10 2007 * 2008 * For each color class, one can set a <b>color overlay</b> for it, 2009 * overriding the default color properties for that class coming from 2010 * the theme in use. There is no need to free this list. 2011 * 2012 * @see elm_config_color_overlay_set() 2013 * @see elm_config_color_overlay_unset(). 2014 */ 2015 EAPI const Eina_List *elm_config_color_overlay_list_get(void); 2016 2017 /** 2018 * Set a color overlay for a given Elementary color class. 2019 * 2020 * @param color_class Color class name 2021 * @param r Object Red value 2022 * @param g Object Green value 2023 * @param b Object Blue value 2024 * @param a Object Alpha value 2025 * @param r2 Text outline Red value 2026 * @param g2 Text outline Green value 2027 * @param b2 Text outline Blue value 2028 * @param a2 Text outline Alpha value 2029 * @param r3 Text shadow Red value 2030 * @param g3 Text shadow Green value 2031 * @param b3 Text shadow Blue value 2032 * @param a3 Text shadow Alpha value 2033 * 2034 * @ingroup Colors 2035 * @since 1.10 2036 2037 * The first color is for the object itself, the second color is for the text 2038 * outline, and the third color is for the text shadow. 2039 * 2040 * @note The second two color are only for texts. 2041 2042 * Setting color emits a signal "color_class,set" with source being 2043 * the given color class in all edje objects. 2044 * 2045 * @see elm_config_color_overlay_list_get() 2046 * @see elm_config_color_overlay_unset() 2047 * @see edje_color_class_set() 2048 2049 * @note unlike Evas, Edje colors are @b not pre-multiplied. That is, 2050 * half-transparent white is 255 255 255 128. 2051 */ 2052 EAPI void elm_config_color_overlay_set(const char *color_class, 2053 int r, int g, int b, int a, 2054 int r2, int g2, int b2, int a2, 2055 int r3, int g3, int b3, int a3); 2056 2057 /** 2058 * Unset a color overlay for a given Elementary color class. 2059 * 2060 * @param color_class Color class name 2061 * 2062 * @ingroup Colors 2063 * @since 1.10 2064 * 2065 * This will bring back color elements belonging to color class 2066 * @p color_class back to their default color settings. 2067 */ 2068 EAPI void elm_config_color_overlay_unset(const char *color_class); 2069 2070 /** 2071 * Apply the changes made with elm_config_color_overlay_set() and 2072 * elm_config_color_overlay_unset() on the current Elementary window. 2073 * 2074 * @ingroup Colors 2075 * @since 1.10 2076 * 2077 * This applies all color overlays set to all objects in the UI. 2078 */ 2079 EAPI void elm_config_color_overlay_apply(void); 2080 2081 /** 2082 * Get the desktop style entry enabled state 2083 * 2084 * @return The desktop style enabled state for entries 2085 * @since 1.23 2086 */ 2087 EAPI Eina_Bool elm_config_desktop_entry_get(void); 2088 2089 /** 2090 * Set the desktop style entry enabled state 2091 * 2092 * @param enable The desktop style enabled state for entries 2093 * @since 1.23 2094 */ 2095 EAPI void elm_config_desktop_entry_set(Eina_Bool enable); 2096 2097 /** 2098 * Get the magnifier enabled state for entries 2099 * 2100 * @return The enabled state for magnifier 2101 * @since 1.9 2102 */ 2103 EAPI Eina_Bool elm_config_magnifier_enable_get(void); 2104 2105 /** 2106 * Set the magnifier enabled state for entires 2107 * 2108 * @param enable The magnifier config state 2109 * @since 1.9 2110 */ 2111 EAPI void elm_config_magnifier_enable_set(Eina_Bool enable); 2112 2113 /** 2114 * Get the amount of scaling the magnifer does 2115 * 2116 * @return The scaling amount (1.0 is none, 2.0 is twice as big etc.) 2117 * @since 1.9 2118 */ 2119 EAPI double elm_config_magnifier_scale_get(void); 2120 2121 /** 2122 * Set the amount of scaling the magnifier does 2123 * 2124 * @param scale The scaling amount for magnifiers 2125 * @since 1.9 2126 */ 2127 EAPI void elm_config_magnifier_scale_set(double scale); 2128 2129 /** 2130 * Get the mute state of an audio channel for effects 2131 * 2132 * @param channel The channel to get the mute state of 2133 * @return The mute state 2134 * @since 1.9 2135 */ 2136 EAPI Eina_Bool elm_config_audio_mute_get(Edje_Channel channel); 2137 2138 /** 2139 * Set the mute state of the specified channel 2140 * 2141 * @param channel The channel to set the mute state of 2142 * @param mute The mute state to set 2143 * @since 1.9 2144 */ 2145 EAPI void elm_config_audio_mute_set(Edje_Channel channel, Eina_Bool mute); 2146 2147 /** 2148 * Get the auto focus enable flag 2149 * 2150 * This determines if elementary will show a focus box indicating the focused 2151 * widget automatically if keyboard controls like "Tab" are used to switch 2152 * focus between widgets. Mouse or touch control will hide this auto shown 2153 * focus, unless focus display has been explicitly forced on for the window. 2154 * 2155 * @return The enabled state for auto focus display 2156 * @since 1.14 2157 */ 2158 EAPI Eina_Bool elm_config_window_auto_focus_enable_get(void); 2159 2160 /** 2161 * Set the auto focus enabled state 2162 * 2163 * This determines if elementary will show a focus box indicating the focused 2164 * widget automatically if keyboard controls like "Tab" are used to switch 2165 * focus between widgets. Mouse or touch control will hide this auto shown 2166 * focus, unless focus display has been explicitly forced on for the window. 2167 * 2168 * @param enable the auto focus display enabled state 2169 * @since 1.14 2170 */ 2171 EAPI void elm_config_window_auto_focus_enable_set(Eina_Bool enable); 2172 2173 /** 2174 * Get the auto focus animate flag 2175 * 2176 * If auto focus - see elm_config_window_auto_focus_enable_set() , is enabled 2177 * then this will determine if the focus display will be animated or not. 2178 * 2179 * @return The enabled state for auto focus animation 2180 * @since 1.14 2181 */ 2182 EAPI Eina_Bool elm_config_window_auto_focus_animate_get(void); 2183 2184 /** 2185 * Set the auto focus animation flag 2186 * 2187 * If auto focus - see elm_config_window_auto_focus_enable_set() , is enabled 2188 * then this will determine if the focus display will be animated or not. 2189 * 2190 * @param enable the auto focus animation state 2191 * @since 1.14 2192 */ 2193 EAPI void elm_config_window_auto_focus_animate_set(Eina_Bool enable); 2194 2195 /** 2196 * Get the popup scrollable flag 2197 * 2198 * If scrollable is true, popup's contents is wrapped in a scroller container 2199 * in order to popup shouldn't be larger than its parent. 2200 * 2201 * @return The enabled state for popup scroll 2202 * @since 1.18 2203 */ 2204 EAPI Eina_Bool elm_config_popup_scrollable_get(void); 2205 2206 /** 2207 * Set the popup scrollable flag 2208 * 2209 * If scrollable is true, popup's contents is wrapped in a scroller container 2210 * in order to popup shouldn't be larger than its parent. 2211 * 2212 * @param scrollable enable the popup scroll 2213 * @since 1.18 2214 */ 2215 EAPI void elm_config_popup_scrollable_set(Eina_Bool scrollable); 2216 2217 /** 2218 * @defgroup ATSPI AT-SPI2 Accessibility 2219 * @ingroup Elementary 2220 * 2221 * Elementary widgets support Linux Accessibility standard. For more 2222 * information please visit: 2223 * http://www.linuxfoundation.org/collaborate/workgroups/accessibility/atk/at-spi/at-spi_on_d-bus 2224 * 2225 * @{ 2226 */ 2227 2228 /** 2229 * Gets ATSPI mode 2230 * 2231 * @return the ATSPI mode 2232 * 2233 * @since 1.10 2234 * 2235 * @ingroup ATSPI 2236 * 2237 * @see elm_config_atspi_mode_set() 2238 */ 2239 EAPI Eina_Bool elm_config_atspi_mode_get(void); 2240 2241 /** 2242 * Sets ATSPI mode 2243 * 2244 * @param is_atspi If @c EINA_TRUE, enables ATSPI2 mode 2245 * 2246 * @note Enables Linux Accessibility support for Elementary widgets. 2247 * 2248 * @since 1.10 2249 * 2250 * @ingroup ATSPI 2251 * 2252 * @see elm_config_atspi_mode_get() 2253 */ 2254 EAPI void elm_config_atspi_mode_set(Eina_Bool is_atspi); 2255 2256 /** 2257 * @} 2258 */ 2259 2260 /** 2261 * Set the transition duration factor 2262 * 2263 * This function sets the edje transition duration factor 2264 * It will affect the duration of edje transitions 2265 * 2266 * @param factor The duration factor for transition in edje 2267 * 2268 * @note This value affect duration of transitions in edje 2269 * 2270 * @since 1.15 2271 * 2272 * @see edje_transition_duration_set() for more details 2273 */ 2274 EAPI void elm_config_transition_duration_factor_set(double factor); 2275 2276 /** 2277 * Get the duration factor of transitions 2278 * 2279 * @return The duration factor of transition in edje 2280 * 2281 * @since 1.15 2282 */ 2283 EAPI double elm_config_transition_duration_factor_get(void); 2284 2285 /** 2286 * Set the backend engine used by Elm_Web widget 2287 * 2288 * This function set the name of the external module used by 2289 * elm_web to render web page. 2290 * 2291 * @param backend The new backend to use. 2292 * 2293 * @since 1.18 2294 * @see elm_config_web_backend_get() 2295 */ 2296 EAPI void elm_config_web_backend_set(const char *backend); 2297 2298 /** 2299 * Get the currently set backend engine used by Elm_Web widget 2300 * 2301 * This function get the name of the external module used by 2302 * elm_web to render web page. 2303 * 2304 * @return The new backend to use. 2305 * 2306 * @since 1.18 2307 * @see elm_config_web_backend_set() 2308 */ 2309 EAPI const char *elm_config_web_backend_get(void); 2310 2311 /** 2312 * Get whether the system is offline 2313 * 2314 * @return True only if the system config is set as offline 2315 * 2316 * @since 1.21 2317 * @see elm_config_offline_set() 2318 */ 2319 EAPI Eina_Bool elm_config_offline_get(void); 2320 2321 /** 2322 * Set whether the system is offline 2323 * 2324 * @param set True only if the system is offline 2325 * 2326 * @since 1.21 2327 * @see elm_config_offline_get() 2328 */ 2329 EAPI void elm_config_offline_set(Eina_Bool set); 2330 2331 /** 2332 * Get whether the system should be conserving power 2333 * 2334 * @return Values greater than 0 if power is being conserved; higher numbers indicate greater conservation 2335 * 2336 * @since 1.21 2337 * @see elm_config_powersave_set() 2338 */ 2339 EAPI int elm_config_powersave_get(void); 2340 2341 /** 2342 * Set whether the system should be conserving power 2343 * 2344 * @param set Values greater than 0 if power is being conserved; higher numbers indicate greater conservation 2345 * 2346 * @since 1.21 2347 * @see elm_config_powersave_set() 2348 */ 2349 EAPI void elm_config_powersave_set(int set); 2350 2351 /** 2352 * Get the animation duration for container objects 2353 * 2354 * @return Animation duration 2355 * 2356 * @since 1.21 2357 * @see elm_config_drag_anim_duration_set() 2358 */ 2359 EAPI double elm_config_drag_anim_duration_get(void); 2360 2361 /** 2362 * Set the animation duration for container objects 2363 * 2364 * @param set Animation duration 2365 * 2366 * @since 1.21 2367 * @see elm_config_drag_anim_duration_get() 2368 */ 2369 EAPI void elm_config_drag_anim_duration_set(double set); 2370 2371 2372 /** 2373 * @} 2374 */ 2375