src/lib/elm_config.h

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