src/lib/elm_config.h

   1 /**
   2  * @defgroup Config Elementary Config
   3  *
   4  * Elementary configuration is formed by a set options bounded to a
   5  * given @ref Profile profile, like @ref Theme theme, @ref Fingers
   6  * "finger size", etc. These are functions with which one synchronizes
   7  * changes made to those values to the configuration storing files, de
   8  * facto. You most probably don't want to use the functions in this
   9  * group unless you're writing an elementary configuration manager.
  10  *
  11  * @{
  12  */
  13
  14 /**
  15  * Save back Elementary's configuration, so that it will persist on
  16  * future sessions.
  17  *
  18  * @return @c EINA_TRUE, when successful. @c EINA_FALSE, otherwise.
  19  * @ingroup Config
  20  *
  21  * This function will take effect -- thus, do I/O -- immediately. Use
  22  * it when you want to save all configuration changes at once. The
  23  * current configuration set will get saved onto the current profile
  24  * configuration file.
  25  *
  26  */
  27 EAPI Eina_Bool elm_config_save(void);
  28
  29 /**
  30  * Reload Elementary's configuration, bounded to current selected
  31  * profile.
  32  *
  33  * @return @c EINA_TRUE, when successful. @c EINA_FALSE, otherwise.
  34  * @ingroup Config
  35  *
  36  * Useful when you want to force reloading of configuration values for
  37  * a profile. If one removes user custom configuration directories,
  38  * for example, it will force a reload with system values instead.
  39  *
  40  */
  41 EAPI void      elm_config_reload(void);
  42
  43 /**
  44  * Flush all config settings then apply those settings to all applications
  45  * using elementary on the current display.
  46  * Following functions will update the config settings
  47  * @li elm_cache_flush_interval_set()
  48  * @li elm_cache_flush_enabled_set()
  49  * @li elm_edje_file_cache_set()
  50  * @li elm_edje_collection_cache_set()
  51  * @li elm_finger_size_set()
  52  * @li elm_focus_highlight_enabled_set()
  53  * @li elm_focus_highlight_animate_set()
  54  * @li elm_font_overlay_set()
  55  * @li elm_font_cache_set()
  56  * @li elm_image_cache_set()
  57  * @li elm_profile_set()
  58  * @li elm_scale_set()
  59  * @li elm_scroll_bounce_enabled_set()
  60  * @li elm_scroll_bounce_friction_set()
  61  * @li elm_scroll_page_scroll_friction_set()
  62  * @li elm_scroll_bring_in_scroll_friction_set()
  63  * @li elm_scroll_zoom_friction_set()
  64  * @li elm_scroll_thumbscroll_enabled_set()
  65  * @li elm_scroll_thumbscroll_threshold_set()
  66  * @li elm_scroll_thumbscroll_momentum_threshold_set()
  67  * @li elm_scroll_thumbscroll_friction_set()
  68  * @li elm_scroll_thumbscroll_border_friction_set()
  69  * @li elm_scroll_thumbscroll_sensitivity_friction_set()
  70  * @li elm_theme_set()
  71  *
  72  * @ingroup Config
  73  *
  74  */
  75 EAPI void      elm_config_all_flush(void);
  76
  77 /**
  78  * @}
  79  */
  80
  81 /**
  82  * @defgroup Profile Elementary Profile
  83  *
  84  * Profiles are pre-set options that affect the whole look-and-feel of
  85  * Elementary-based applications. There are, for example, profiles
  86  * aimed at desktop computer applications and others aimed at mobile,
  87  * touchscreen-based ones. You most probably don't want to use the
  88  * functions in this group unless you're writing an elementary
  89  * configuration manager.
  90  *
  91  * @{
  92  */
  93
  94 /**
  95  * Get Elementary's profile in use.
  96  *
  97  * This gets the global profile that is applied to all Elementary
  98  * applications.
  99  *
 100  * @return The profile's name
 101  * @ingroup Profile
 102  */
 103 EAPI const char *elm_profile_current_get(void);
 104
 105 /**
 106  * Get an Elementary's profile directory path in the filesystem. One
 107  * may want to fetch a system profile's dir or a user one (fetched
 108  * inside $HOME).
 109  *
 110  * @param profile The profile's name
 111  * @param is_user Whether to lookup for a user profile (@c EINA_TRUE)
 112  *                or a system one (@c EINA_FALSE)
 113  * @return The profile's directory path.
 114  * @ingroup Profile
 115  *
 116  * @note You must free it with elm_profile_dir_free().
 117  */
 118 EAPI const char *elm_profile_dir_get(const char *profile, Eina_Bool is_user);
 119
 120 /**
 121  * Free an Elementary's profile directory path, as returned by
 122  * elm_profile_dir_get().
 123  *
 124  * @param p_dir The profile's path
 125  * @ingroup Profile
 126  *
 127  */
 128 EAPI void        elm_profile_dir_free(const char *p_dir);
 129
 130 /**
 131  * Get Elementary's list of available profiles.
 132  *
 133  * @return The profiles list. List node data are the profile name
 134  *         strings.
 135  * @ingroup Profile
 136  *
 137  * @note One must free this list, after usage, with the function
 138  *       elm_profile_list_free().
 139  */
 140 EAPI Eina_List  *elm_profile_list_get(void);
 141
 142 /**
 143  * Free Elementary's list of available profiles.
 144  *
 145  * @param l The profiles list, as returned by elm_profile_list_get().
 146  * @ingroup Profile
 147  *
 148  */
 149 EAPI void        elm_profile_list_free(Eina_List *l);
 150
 151 /**
 152  * Set Elementary's profile.
 153  *
 154  * This sets the global profile that is applied to Elementary
 155  * applications. Just the process the call comes from will be
 156  * affected.
 157  *
 158  * @param profile The profile's name
 159  * @ingroup Profile
 160  *
 161  */
 162 EAPI void        elm_profile_set(const char *profile);
 163
 164 /**
 165  * @}
 166  */
 167
 168 /**
 169  * @defgroup Scrolling Scrolling
 170  *
 171  * These are functions setting how scrollable views in Elementary
 172  * widgets should behave on user interaction.
 173  *
 174  * @{
 175  */
 176
 177 /**
 178  * Get whether scrollers should bounce when they reach their
 179  * viewport's edge during a scroll.
 180  *
 181  * @return the thumb scroll bouncing state
 182  *
 183  * This is the default behavior for touch screens, in general.
 184  * @ingroup Scrolling
 185  */
 186 EAPI Eina_Bool    elm_scroll_bounce_enabled_get(void);
 187
 188 /**
 189  * Set whether scrollers should bounce when they reach their
 190  * viewport's edge during a scroll.
 191  *
 192  * @param enabled the thumb scroll bouncing state
 193  *
 194  * @see elm_thumbscroll_bounce_enabled_get()
 195  * @ingroup Scrolling
 196  */
 197 EAPI void         elm_scroll_bounce_enabled_set(Eina_Bool enabled);
 198
 199 /**
 200  * Get the amount of inertia a scroller will impose at bounce
 201  * animations.
 202  *
 203  * @return the thumb scroll bounce friction
 204  *
 205  * @ingroup Scrolling
 206  */
 207 EAPI double       elm_scroll_bounce_friction_get(void);
 208
 209 /**
 210  * Set the amount of inertia a scroller will impose at bounce
 211  * animations.
 212  *
 213  * @param friction the thumb scroll bounce friction
 214  *
 215  * @see elm_thumbscroll_bounce_friction_get()
 216  * @ingroup Scrolling
 217  */
 218 EAPI void         elm_scroll_bounce_friction_set(double friction);
 219
 220 /**
 221  * Get the amount of inertia a <b>paged</b> scroller will impose at
 222  * page fitting animations.
 223  *
 224  * @return the page scroll friction
 225  *
 226  * @ingroup Scrolling
 227  */
 228 EAPI double       elm_scroll_page_scroll_friction_get(void);
 229
 230 /**
 231  * Set the amount of inertia a <b>paged</b> scroller will impose at
 232  * page fitting animations.
 233  *
 234  * @param friction the page scroll friction
 235  *
 236  * @see elm_thumbscroll_page_scroll_friction_get()
 237  * @ingroup Scrolling
 238  */
 239 EAPI void         elm_scroll_page_scroll_friction_set(double friction);
 240
 241 /**
 242  * Get the amount of inertia a scroller will impose at region bring
 243  * animations.
 244  *
 245  * @return the bring in scroll friction
 246  *
 247  * @ingroup Scrolling
 248  */
 249 EAPI double       elm_scroll_bring_in_scroll_friction_get(void);
 250
 251 /**
 252  * Set the amount of inertia a scroller will impose at region bring
 253  * animations.
 254  *
 255  * @param friction the bring in scroll friction
 256  *
 257  * @see elm_thumbscroll_bring_in_scroll_friction_get()
 258  * @ingroup Scrolling
 259  */
 260 EAPI void         elm_scroll_bring_in_scroll_friction_set(double friction);
 261
 262 /**
 263  * Get the amount of inertia scrollers will impose at animations
 264  * triggered by Elementary widgets' zooming API.
 265  *
 266  * @return the zoom friction
 267  *
 268  * @ingroup Scrolling
 269  */
 270 EAPI double       elm_scroll_zoom_friction_get(void);
 271
 272 /**
 273  * Set the amount of inertia scrollers will impose at animations
 274  * triggered by Elementary widgets' zooming API.
 275  *
 276  * @param friction the zoom friction
 277  *
 278  * @see elm_thumbscroll_zoom_friction_get()
 279  * @ingroup Scrolling
 280  */
 281 EAPI void         elm_scroll_zoom_friction_set(double friction);
 282
 283 /**
 284  * Get whether scrollers should be draggable from any point in their
 285  * views.
 286  *
 287  * @return the thumb scroll state
 288  *
 289  * @note This is the default behavior for touch screens, in general.
 290  * @note All other functions namespaced with "thumbscroll" will only
 291  *       have effect if this mode is enabled.
 292  *
 293  * @ingroup Scrolling
 294  */
 295 EAPI Eina_Bool    elm_scroll_thumbscroll_enabled_get(void);
 296
 297 /**
 298  * Set whether scrollers should be draggable from any point in their
 299  * views.
 300  *
 301  * @param enabled the thumb scroll state
 302  *
 303  * @see elm_thumbscroll_enabled_get()
 304  * @ingroup Scrolling
 305  */
 306 EAPI void         elm_scroll_thumbscroll_enabled_set(Eina_Bool enabled);
 307
 308 /**
 309  * Get the number of pixels one should travel while dragging a
 310  * scroller's view to actually trigger scrolling.
 311  *
 312  * @return the thumb scroll threshold
 313  *
 314  * One would use higher values for touch screens, in general, because
 315  * of their inherent imprecision.
 316  * @ingroup Scrolling
 317  */
 318 EAPI unsigned int elm_scroll_thumbscroll_threshold_get(void);
 319
 320 /**
 321  * Set the number of pixels one should travel while dragging a
 322  * scroller's view to actually trigger scrolling.
 323  *
 324  * @param threshold the thumb scroll threshold
 325  *
 326  * @see elm_thumbscroll_threshold_get()
 327  * @ingroup Scrolling
 328  */
 329 EAPI void         elm_scroll_thumbscroll_threshold_set(unsigned int threshold);
 330
 331 /**
 332  * Get the minimum speed of mouse cursor movement which will trigger
 333  * list self scrolling animation after a mouse up event
 334  * (pixels/second).
 335  *
 336  * @return the thumb scroll momentum threshold
 337  *
 338  * @ingroup Scrolling
 339  */
 340 EAPI double       elm_scroll_thumbscroll_momentum_threshold_get(void);
 341
 342 /**
 343  * Set the minimum speed of mouse cursor movement which will trigger
 344  * list self scrolling animation after a mouse up event
 345  * (pixels/second).
 346  *
 347  * @param threshold the thumb scroll momentum threshold
 348  *
 349  * @see elm_thumbscroll_momentum_threshold_get()
 350  * @ingroup Scrolling
 351  */
 352 EAPI void         elm_scroll_thumbscroll_momentum_threshold_set(double threshold);
 353
 354 /**
 355  * Get the amount of inertia a scroller will impose at self scrolling
 356  * animations.
 357  *
 358  * @return the thumb scroll friction
 359  *
 360  * @ingroup Scrolling
 361  */
 362 EAPI double       elm_scroll_thumbscroll_friction_get(void);
 363
 364 /**
 365  * Set the amount of inertia a scroller will impose at self scrolling
 366  * animations.
 367  *
 368  * @param friction the thumb scroll friction
 369  *
 370  * @see elm_thumbscroll_friction_get()
 371  * @ingroup Scrolling
 372  */
 373 EAPI void         elm_scroll_thumbscroll_friction_set(double friction);
 374
 375 /**
 376  * Get the amount of lag between your actual mouse cursor dragging
 377  * movement and a scroller's view movement itself, while pushing it
 378  * into bounce state manually.
 379  *
 380  * @return the thumb scroll border friction
 381  *
 382  * @ingroup Scrolling
 383  */
 384 EAPI double       elm_scroll_thumbscroll_border_friction_get(void);
 385
 386 /**
 387  * Set the amount of lag between your actual mouse cursor dragging
 388  * movement and a scroller's view movement itself, while pushing it
 389  * into bounce state manually.
 390  *
 391  * @param friction the thumb scroll border friction. @c 0.0 for
 392  *        perfect synchrony between two movements, @c 1.0 for maximum
 393  *        lag.
 394  *
 395  * @see elm_thumbscroll_border_friction_get()
 396  * @note parameter value will get bound to 0.0 - 1.0 interval, always
 397  *
 398  * @ingroup Scrolling
 399  */
 400 EAPI void         elm_scroll_thumbscroll_border_friction_set(double friction);
 401
 402 /**
 403  * Get the sensitivity amount which is be multiplied by the length of
 404  * mouse dragging.
 405  *
 406  * @return the thumb scroll sensitivity friction
 407  *
 408  * @ingroup Scrolling
 409  */
 410 EAPI double       elm_scroll_thumbscroll_sensitivity_friction_get(void);
 411
 412 /**
 413  * Set the sensitivity amount which is be multiplied by the length of
 414  * mouse dragging.
 415  *
 416  * @param friction the thumb scroll sensitivity friction. @c 0.1 for
 417  *        minimum sensitivity, @c 1.0 for maximum sensitivity. 0.25
 418  *        is proper.
 419  *
 420  * @see elm_thumbscroll_sensitivity_friction_get()
 421  * @note parameter value will get bound to 0.1 - 1.0 interval, always
 422  *
 423  * @ingroup Scrolling
 424  */
 425 EAPI void         elm_scroll_thumbscroll_sensitivity_friction_set(double friction);
 426
 427 /**
 428  * @}
 429  */
 430
 431 /**
 432  * Get the duration for occurring long press event.
 433  *
 434  * @return Timeout for long press event
 435  * @ingroup Longpress
 436  */
 437 EAPI double       elm_longpress_timeout_get(void);
 438
 439 /**
 440  * Set the duration for occurring long press event.
 441  *
 442  * @param lonpress_timeout Timeout for long press event
 443  * @ingroup Longpress
 444  */
 445 EAPI void         elm_longpress_timeout_set(double longpress_timeout);
 446
 447 /**
 448  * Get the duration after which tooltip will be shown.
 449  *
 450  * @return Duration after which tooltip will be shown.
 451  */
 452 EAPI double      elm_config_tooltip_delay_get(void);
 453
 454 /**
 455  * Set the duration after which tooltip will be shown.
 456  *
 457  * @return EINA_TRUE if value is set.
 458  */
 459 EAPI void        elm_config_tooltip_delay_set(double delay);
 460
 461 /**
 462  * Get the configured cursor engine only usage
 463  *
 464  * This gets the globally configured exclusive usage of engine cursors.
 465  *
 466  * @return 1 if only engine cursors should be used
 467  * @ingroup Cursors
 468  */
 469 EAPI Eina_Bool   elm_cursor_engine_only_get(void);
 470
 471 /**
 472  * Set the configured cursor engine only usage
 473  *
 474  * This sets the globally configured exclusive usage of engine cursors.
 475  * It won't affect cursors set before changing this value.
 476  *
 477  * @param engine_only If 1 only engine cursors will be enabled, if 0 will
 478  * look for them on theme before.
 479  * @ingroup Cursors
 480  */
 481 EAPI void        elm_cursor_engine_only_set(Eina_Bool engine_only);
 482
 483 /**
 484  * Get the global scaling factor
 485  *
 486  * This gets the globally configured scaling factor that is applied to all
 487  * objects.
 488  *
 489  * @return The scaling factor
 490  * @ingroup Scaling
 491  */
 492 EAPI double elm_scale_get(void);
 493
 494 /**
 495  * Set the global scaling factor
 496  *
 497  * This sets the globally configured scaling factor that is applied to all
 498  * objects.
 499  *
 500  * @param scale The scaling factor to set
 501  * @ingroup Scaling
 502  */
 503 EAPI void   elm_scale_set(double scale);
 504
 505 /**
 506  * @defgroup Password_last_show Password show last
 507  *
 508  * Show last feature of password mode enables user to view
 509  * the last input entered for few seconds before masking it.
 510  * These functions allow to set this feature in password mode
 511  * of entry widget and also allow to manipulate the duration
 512  * for which the input has to be visible.
 513  *
 514  * @{
 515  */
 516
 517 /**
 518  * Get the "show last" setting of password mode.
 519  *
 520  * This gets the "show last" setting of password mode which might be
 521  * enabled or disabled.
 522  *
 523  * @return @c EINA_TRUE, if the "show last" setting is enabled,
 524  * @c EINA_FALSE  if it's disabled.
 525  *
 526  * @ingroup Password_last_show
 527  */
 528 EAPI Eina_Bool elm_password_show_last_get(void);
 529
 530 /**
 531  * Set show last setting in password mode.
 532  *
 533  * This enables or disables show last setting of password mode.
 534  *
 535  * @param password_show_last If EINA_TRUE enables "show last" in password mode.
 536  * @see elm_password_show_last_timeout_set()
 537  * @ingroup Password_last_show
 538  */
 539 EAPI void      elm_password_show_last_set(Eina_Bool password_show_last);
 540
 541 /**
 542  * Gets the timeout value in "show last" password mode.
 543  *
 544  * This gets the time out value for which the last input entered in password
 545  * mode will be visible.
 546  *
 547  * @return The timeout value of "show last" password mode.
 548  * @ingroup Password_last_show
 549  */
 550 EAPI double    elm_password_show_last_timeout_get(void);
 551
 552 /**
 553  * Set's the timeout value in "show last" password mode.
 554  *
 555  * This sets the time out value for which the last input entered in password
 556  * mode will be visible.
 557  *
 558  * @param password_show_last_timeout The timeout value.
 559  * @see elm_password_show_last_set()
 560  * @ingroup Password_last_show
 561  */
 562 EAPI void      elm_password_show_last_timeout_set(double password_show_last_timeout);
 563
 564 /**
 565  * @}
 566  */
 567
 568 /**
 569  * @defgroup Engine Elementary Engine
 570  *
 571  * These are functions setting and querying which rendering engine
 572  * Elementary will use for drawing its windows' pixels.
 573  *
 574  * The following are the available engines:
 575  * @li "software_x11"
 576  * @li "fb"
 577  * @li "directfb"
 578  * @li "software_16_x11"
 579  * @li "software_8_x11"
 580  * @li "xrender_x11"
 581  * @li "opengl_x11"
 582  * @li "software_gdi"
 583  * @li "software_16_wince_gdi"
 584  * @li "sdl"
 585  * @li "software_16_sdl"
 586  * @li "opengl_sdl"
 587  * @li "buffer"
 588  * @li "ews"
 589  * @li "opengl_cocoa"
 590  * @li "psl1ght"
 591  *
 592  * @{
 593  */
 594
 595 /**
 596  * @brief Get Elementary's rendering engine in use.
 597  *
 598  * @return The rendering engine's name
 599  * @note there's no need to free the returned string, here.
 600  *
 601  * This gets the global rendering engine that is applied to all Elementary
 602  * applications.
 603  *
 604  * @see elm_engine_set()
 605  */
 606 EAPI const char *elm_engine_get(void);
 607
 608 /**
 609  * @brief Set Elementary's rendering engine for use.
 610  *
 611  * @param engine The rendering engine's name
 612  *
 613  * Note that it will take effect only to Elementary windows created after
 614  * this is called.
 615  *
 616  * @see elm_win_add()
 617  */
 618 EAPI void        elm_engine_set(const char *engine);
 619
 620 /**
 621  * @brief Get Elementary's preferred engine to use.
 622  *
 623  * @return The rendering engine's name
 624  * @note there's no need to free the returned string, here.
 625  *
 626  * This gets the global rendering engine that is applied to all Elementary
 627  * applications and is PREFERRED by the application. This can (and will)
 628  * override the engine configured for all applications which.
 629  *
 630  * @see elm_preferred_engine_set()
 631  */
 632 EAPI const char *elm_preferred_engine_get(void);
 633
 634 /**
 635  * @brief Set Elementary's preferred rendering engine for use.
 636  *
 637  * @param engine The rendering engine's name
 638  *
 639  * Note that it will take effect only to Elementary windows created after
 640  * this is called. This overrides the engine set by configuration at
 641  * application startup. Note that it is a hint and may not be honored.
 642  *
 643  * @see elm_win_add()
 644  */
 645 EAPI void        elm_preferred_engine_set(const char *engine);
 646
 647 typedef struct _Elm_Text_Class
 648 {
 649    const char *name;
 650    const char *desc;
 651 } Elm_Text_Class;
 652
 653 typedef struct _Elm_Font_Overlay
 654 {
 655    const char    *text_class;
 656    const char    *font;
 657    Evas_Font_Size size;
 658 } Elm_Font_Overlay;
 659
 660 /**
 661  * Get Elementary's list of supported text classes.
 662  *
 663  * @return The text classes list, with @c Elm_Text_Class blobs as data.
 664  * @ingroup Fonts
 665  *
 666  * Release the list with elm_text_classes_list_free().
 667  */
 668 EAPI Eina_List *elm_text_classes_list_get(void);
 669
 670 /**
 671  * Free Elementary's list of supported text classes.
 672  *
 673  * @ingroup Fonts
 674  *
 675  * @see elm_text_classes_list_get().
 676  */
 677 EAPI void elm_text_classes_list_free(Eina_List *list);
 678
 679 /**
 680  * Get Elementary's list of font overlays, set with
 681  * elm_font_overlay_set().
 682  *
 683  * @return The font overlays list, with @c Elm_Font_Overlay blobs as
 684  * data.
 685  *
 686  * @ingroup Fonts
 687  *
 688  * For each text class, one can set a <b>font overlay</b> for it,
 689  * overriding the default font properties for that class coming from
 690  * the theme in use. There is no need to free this list.
 691  *
 692  * @see elm_font_overlay_set() and elm_font_overlay_unset().
 693  */
 694 EAPI const Eina_List *elm_font_overlay_list_get(void);
 695
 696 /**
 697  * Set a font overlay for a given Elementary text class.
 698  *
 699  * @param text_class Text class name
 700  * @param font Font name and style string
 701  * @param size Font size
 702  *
 703  * @ingroup Fonts
 704  *
 705  * @p font has to be in the format returned by
 706  * elm_font_fontconfig_name_get(). @see elm_font_overlay_list_get()
 707  * and elm_font_overlay_unset().
 708  */
 709 EAPI void             elm_font_overlay_set(const char *text_class, const char *font, Evas_Font_Size size);
 710
 711 /**
 712  * Unset a font overlay for a given Elementary text class.
 713  *
 714  * @param text_class Text class name
 715  *
 716  * @ingroup Fonts
 717  *
 718  * This will bring back text elements belonging to text class
 719  * @p text_class back to their default font settings.
 720  */
 721 EAPI void             elm_font_overlay_unset(const char *text_class);
 722
 723 /**
 724  * Apply the changes made with elm_font_overlay_set() and
 725  * elm_font_overlay_unset() on the current Elementary window.
 726  *
 727  * @ingroup Fonts
 728  *
 729  * This applies all font overlays set to all objects in the UI.
 730  */
 731 EAPI void             elm_font_overlay_apply(void);
 732
 733 /**
 734  * Get the configured "finger size"
 735  *
 736  * @return The finger size
 737  *
 738  * This gets the globally configured finger size, <b>in pixels</b>
 739  *
 740  * @ingroup Fingers
 741  */
 742 EAPI Evas_Coord elm_finger_size_get(void);
 743
 744 /**
 745  * Set the configured finger size
 746  *
 747  * This sets the globally configured finger size in pixels
 748  *
 749  * @param size The finger size
 750  * @ingroup Fingers
 751  */
 752 EAPI void       elm_finger_size_set(Evas_Coord size);
 753
 754
 755 /**
 756  * Get the configured cache flush interval time
 757  *
 758  * This gets the globally configured cache flush interval time, in
 759  * ticks
 760  *
 761  * @return The cache flush interval time
 762  * @ingroup Caches
 763  *
 764  * @see elm_cache_all_flush()
 765  */
 766 EAPI int       elm_cache_flush_interval_get(void);
 767
 768 /**
 769  * Set the configured cache flush interval time
 770  *
 771  * This sets the globally configured cache flush interval time, in ticks
 772  *
 773  * @param size The cache flush interval time
 774  * @ingroup Caches
 775  *
 776  * @see elm_cache_all_flush()
 777  */
 778 EAPI void      elm_cache_flush_interval_set(int size);
 779
 780 /**
 781  * Get the configured cache flush enabled state
 782  *
 783  * This gets the globally configured cache flush state - if it is enabled
 784  * or not. When cache flushing is enabled, elementary will regularly
 785  * (see elm_cache_flush_interval_get() ) flush caches and dump data out of
 786  * memory and allow usage to re-seed caches and data in memory where it
 787  * can do so. An idle application will thus minimize its memory usage as
 788  * data will be freed from memory and not be re-loaded as it is idle and
 789  * not rendering or doing anything graphically right now.
 790  *
 791  * @return The cache flush state
 792  * @ingroup Caches
 793  *
 794  * @see elm_cache_all_flush()
 795  */
 796 EAPI Eina_Bool elm_cache_flush_enabled_get(void);
 797
 798 /**
 799  * Set the configured cache flush enabled state
 800  *
 801  * This sets the globally configured cache flush enabled state.
 802  *
 803  * @param enabled The cache flush enabled state
 804  * @ingroup Caches
 805  *
 806  * @see elm_cache_all_flush()
 807  */
 808 EAPI void      elm_cache_flush_enabled_set(Eina_Bool enabled);
 809
 810 /**
 811  * Get the configured font cache size
 812  *
 813  * This gets the globally configured font cache size, in bytes.
 814  *
 815  * @return The font cache size
 816  * @ingroup Caches
 817  */
 818 EAPI int       elm_cache_font_cache_size_get(void);
 819
 820 /**
 821  * Set the configured font cache size
 822  *
 823  * This sets the globally configured font cache size, in bytes
 824  *
 825  * @param size The font cache size
 826  * @ingroup Caches
 827  */
 828 EAPI void      elm_cache_font_cache_size_set(int size);
 829
 830 /**
 831  * Get the configured image cache size
 832  *
 833  * This gets the globally configured image cache size, in bytes
 834  *
 835  * @return The image cache size
 836  * @ingroup Caches
 837  */
 838 EAPI int       elm_cache_image_cache_size_get(void);
 839
 840 /**
 841  * Set the configured image cache size
 842  *
 843  * This sets the globally configured image cache size, in bytes
 844  *
 845  * @param size The image cache size
 846  * @ingroup Caches
 847  */
 848 EAPI void       elm_cache_image_cache_size_set(int size);
 849
 850
 851 /**
 852  * Get the configured edje file cache size.
 853  *
 854  * This gets the globally configured edje file cache size, in number
 855  * of files.
 856  *
 857  * @return The edje file cache size
 858  * @ingroup Caches
 859  */
 860 EAPI int       elm_cache_edje_file_cache_size_get(void);
 861
 862 /**
 863  * Set the configured edje file cache size
 864  *
 865  * This sets the globally configured edje file cache size, in number
 866  * of files.
 867  *
 868  * @param size The edje file cache size
 869  * @ingroup Caches
 870  */
 871 EAPI void       elm_cache_edje_file_cache_size_set(int size);
 872
 873 /**
 874  * Get the configured edje collections (groups) cache size.
 875  *
 876  * This gets the globally configured edje collections cache size, in
 877  * number of collections.
 878  *
 879  * @return The edje collections cache size
 880  * @ingroup Caches
 881  */
 882 EAPI int       elm_cache_edje_collection_cache_size_get(void);
 883
 884 /**
 885  * Set the configured edje collections (groups) cache size
 886  *
 887  * This sets the globally configured edje collections cache size, in
 888  * number of collections.
 889  *
 890  * @param size The edje collections cache size
 891  * @ingroup Caches
 892  */
 893 EAPI void       elm_cache_edje_collection_cache_size_set(int size);
 894
 895 /**
 896  * Get the enable status of the focus highlight
 897  *
 898  * This gets whether the highlight on focused objects is enabled or not
 899  *
 900  * @see elm_focus_highlight_enabled_set()
 901  * @ingroup Focus
 902  */
 903 EAPI Eina_Bool            elm_focus_highlight_enabled_get(void);
 904
 905 /**
 906  * Set the enable status of the focus highlight
 907  *
 908  * @param enable Enable highlight if EINA_TRUE, disable otherwise
 909  *
 910  * Set whether to show or not the highlight on focused objects
 911  *
 912  * Note that it will take effect only to Elementary windows created after
 913  * this is called.
 914  *
 915  * @see elm_win_add()
 916  *
 917  * @ingroup Focus
 918  */
 919 EAPI void                 elm_focus_highlight_enabled_set(Eina_Bool enable);
 920
 921 /**
 922  * Get the enable status of the highlight animation
 923  *
 924  * @return The focus highlight mode set
 925  *
 926  * Get whether the focus highlight, if enabled, will animate its switch from
 927  * one object to the next
 928  *
 929  * @ingroup Focus
 930  */
 931 EAPI Eina_Bool            elm_focus_highlight_animate_get(void);
 932
 933 /**
 934  * Set the enable status of the highlight animation
 935  *
 936  * @param animate Enable animation if EINA_TRUE, disable otherwise
 937  *
 938  * Set whether the focus highlight, if enabled, will animate its switch from
 939  * one object to the next
 940  *
 941  * Note that it will take effect only to Elementary windows created after
 942  * this is called.
 943  *
 944  * @see elm_win_add()
 945  *
 946  * @ingroup Focus
 947  */
 948 EAPI void                 elm_focus_highlight_animate_set(Eina_Bool animate);
 949
 950 /**
 951  * @}
 952  */
 953