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