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 EAPI double elm_scale_get(void);
 471
 472 /**
 473  * Set the global scaling factor
 474  *
 475  * This sets the globally configured scaling factor that is applied to all
 476  * objects.
 477  *
 478  * @param scale The scaling factor to set
 479  * @ingroup Scaling
 480  */
 481 EAPI void   elm_config_scale_set(double scale);
 482 EAPI void elm_scale_set(double scale);
 483
 484 /**
 485  * @defgroup Password_last_show Password show last
 486  * @ingroup Elementary
 487  *
 488  * Show last feature of password mode enables user to view
 489  * the last input entered for few seconds before masking it.
 490  * These functions allow to set this feature in password mode
 491  * of entry widget and also allow to manipulate the duration
 492  * for which the input has to be visible.
 493  *
 494  * @{
 495  */
 496
 497 /**
 498  * Get the "show last" setting of password mode.
 499  *
 500  * This gets the "show last" setting of password mode which might be
 501  * enabled or disabled.
 502  *
 503  * @return @c EINA_TRUE, if the "show last" setting is enabled,
 504  * @c EINA_FALSE  if it's disabled.
 505  *
 506  * @ingroup Password_last_show
 507  */
 508 EAPI Eina_Bool elm_config_password_show_last_get(void);
 509
 510 /**
 511  * Set show last setting in password mode.
 512  *
 513  * This enables or disables show last setting of password mode.
 514  *
 515  * @param password_show_last If EINA_TRUE enables "show last" in password mode.
 516  * @see elm_config_password_show_last_timeout_set()
 517  * @ingroup Password_last_show
 518  */
 519 EAPI void      elm_config_password_show_last_set(Eina_Bool password_show_last);
 520
 521 /**
 522  * Gets the timeout value in "show last" password mode.
 523  *
 524  * This gets the time out value for which the last input entered in password
 525  * mode will be visible.
 526  *
 527  * @return The timeout value of "show last" password mode.
 528  * @ingroup Password_last_show
 529  */
 530 EAPI double    elm_config_password_show_last_timeout_get(void);
 531
 532 /**
 533  * Set's the timeout value in "show last" password mode.
 534  *
 535  * This sets the time out value for which the last input entered in password
 536  * mode will be visible.
 537  *
 538  * @param password_show_last_timeout The timeout value.
 539  * @see elm_config_password_show_last_set()
 540  * @ingroup Password_last_show
 541  */
 542 EAPI void      elm_config_password_show_last_timeout_set(double password_show_last_timeout);
 543
 544 /**
 545  * @}
 546  */
 547
 548 /**
 549  * @defgroup Engine Elementary Engine
 550  * @ingroup Elementary
 551  *
 552  * These are functions setting and querying which rendering engine
 553  * Elementary will use for drawing its windows' pixels.
 554  *
 555  * The following are the available engines:
 556  * @li "software_x11"
 557  * @li "fb"
 558  * @li "directfb"
 559  * @li "software_16_x11"
 560  * @li "software_8_x11"
 561  * @li "xrender_x11"
 562  * @li "opengl_x11"
 563  * @li "software_gdi"
 564  * @li "software_16_wince_gdi"
 565  * @li "sdl"
 566  * @li "software_16_sdl"
 567  * @li "opengl_sdl"
 568  * @li "buffer"
 569  * @li "ews"
 570  * @li "opengl_cocoa"
 571  * @li "psl1ght"
 572  *
 573  * @{
 574  */
 575
 576 /**
 577  * @brief Get Elementary's rendering engine in use.
 578  *
 579  * @return The rendering engine's name
 580  * @note there's no need to free the returned string, here.
 581  *
 582  * This gets the global rendering engine that is applied to all Elementary
 583  * applications.
 584  *
 585  * @see elm_config_engine_set()
 586  */
 587 EAPI const char *elm_config_engine_get(void);
 588
 589 /**
 590  * @brief Set Elementary's rendering engine for use.
 591  *
 592  * @param engine The rendering engine's name
 593  *
 594  * Note that it will take effect only to Elementary windows created after
 595  * this is called.
 596  *
 597  * @see elm_win_add()
 598  */
 599 EAPI void        elm_config_engine_set(const char *engine);
 600
 601 /**
 602  * @brief Get Elementary's preferred engine to use.
 603  *
 604  * @return The rendering engine's name
 605  * @note there's no need to free the returned string, here.
 606  *
 607  * This gets the global rendering engine that is applied to all Elementary
 608  * applications and is PREFERRED by the application. This can (and will)
 609  * override the engine configured for all applications which.
 610  *
 611  * @see elm_config_preferred_engine_set()
 612  */
 613 EAPI const char *elm_config_preferred_engine_get(void);
 614
 615 /**
 616  * @brief Set Elementary's preferred rendering engine for use.
 617  *
 618  * @param engine The rendering engine's name
 619  *
 620  * Note that it will take effect only to Elementary windows created after
 621  * this is called. This overrides the engine set by configuration at
 622  * application startup. Note that it is a hint and may not be honored.
 623  *
 624  * @see elm_win_add()
 625  */
 626 EAPI void        elm_config_preferred_engine_set(const char *engine);
 627
 628 typedef struct _Elm_Text_Class
 629 {
 630    const char *name;
 631    const char *desc;
 632 } Elm_Text_Class;
 633
 634 typedef struct _Elm_Font_Overlay
 635 {
 636    const char    *text_class;
 637    const char    *font;
 638    Evas_Font_Size size;
 639 } Elm_Font_Overlay;
 640
 641 /**
 642  * Get Elementary's list of supported text classes.
 643  *
 644  * @return The text classes list, with @c Elm_Text_Class blobs as data.
 645  * @ingroup Fonts
 646  *
 647  * Release the list with elm_text_classes_list_free().
 648  */
 649 EAPI Eina_List *elm_config_text_classes_list_get(void);
 650
 651 /**
 652  * Free Elementary's list of supported text classes.
 653  *
 654  * @ingroup Fonts
 655  *
 656  * @see elm_config_text_classes_list_get().
 657  */
 658 EAPI void elm_config_text_classes_list_free(Eina_List *list);
 659
 660 /**
 661  * Get Elementary's list of font overlays, set with
 662  * elm_config_font_overlay_set().
 663  *
 664  * @return The font overlays list, with @c Elm_Font_Overlay blobs as
 665  * data.
 666  *
 667  * @ingroup Fonts
 668  *
 669  * For each text class, one can set a <b>font overlay</b> for it,
 670  * overriding the default font properties for that class coming from
 671  * the theme in use. There is no need to free this list.
 672  *
 673  * @see elm_config_font_overlay_set() and elm_config_font_overlay_unset().
 674  */
 675 EAPI const Eina_List *elm_config_font_overlay_list_get(void);
 676
 677 /**
 678  * Set a font overlay for a given Elementary text class.
 679  *
 680  * @param text_class Text class name
 681  * @param font Font name and style string
 682  * @param size Font size
 683  *
 684  * @ingroup Fonts
 685  *
 686  * @p font has to be in the format returned by
 687  * elm_font_fontconfig_name_get(). @see elm_config_font_overlay_list_get()
 688  * and elm_config_font_overlay_unset().
 689  */
 690 EAPI void             elm_config_font_overlay_set(const char *text_class, const char *font, Evas_Font_Size size);
 691
 692 /**
 693  * Unset a font overlay for a given Elementary text class.
 694  *
 695  * @param text_class Text class name
 696  *
 697  * @ingroup Fonts
 698  *
 699  * This will bring back text elements belonging to text class
 700  * @p text_class back to their default font settings.
 701  */
 702 EAPI void             elm_config_font_overlay_unset(const char *text_class);
 703
 704 /**
 705  * Apply the changes made with elm_config_font_overlay_set() and
 706  * elm_config_font_overlay_unset() on the current Elementary window.
 707  *
 708  * @ingroup Fonts
 709  *
 710  * This applies all font overlays set to all objects in the UI.
 711  */
 712 EAPI void             elm_config_font_overlay_apply(void);
 713
 714 /**
 715  * Get the configured "finger size"
 716  *
 717  * @return The finger size
 718  *
 719  * This gets the globally configured finger size, <b>in pixels</b>
 720  *
 721  * @ingroup Fingers
 722  */
 723 EAPI Evas_Coord elm_config_finger_size_get(void);
 724 // WRAPPER: Temperary Added.
 725 EAPI Evas_Coord elm_finger_size_get(void);
 726
 727 /**
 728  * Set the configured finger size
 729  *
 730  * This sets the globally configured finger size in pixels
 731  *
 732  * @param size The finger size
 733  * @ingroup Fingers
 734  */
 735 EAPI void       elm_config_finger_size_set(Evas_Coord size);
 736 // WRAPPER: Temperary Added.
 737 EAPI void       elm_finger_size_set(Evas_Coord size);
 738
 739
 740 /**
 741  * Get the configured cache flush interval time
 742  *
 743  * This gets the globally configured cache flush interval time, in
 744  * ticks
 745  *
 746  * @return The cache flush interval time
 747  * @ingroup Caches
 748  *
 749  * @see elm_cache_all_flush()
 750  */
 751 EAPI int       elm_config_cache_flush_interval_get(void);
 752
 753 /**
 754  * Set the configured cache flush interval time
 755  *
 756  * This sets the globally configured cache flush interval time, in ticks
 757  *
 758  * @param size The cache flush interval time
 759  * @ingroup Caches
 760  *
 761  * @see elm_cache_all_flush()
 762  */
 763 EAPI void      elm_config_cache_flush_interval_set(int size);
 764
 765 /**
 766  * Get the configured cache flush enabled state
 767  *
 768  * This gets the globally configured cache flush state - if it is enabled
 769  * or not. When cache flushing is enabled, elementary will regularly
 770  * (see elm_config_cache_flush_interval_get() ) flush caches and dump data out of
 771  * memory and allow usage to re-seed caches and data in memory where it
 772  * can do so. An idle application will thus minimize its memory usage as
 773  * data will be freed from memory and not be re-loaded as it is idle and
 774  * not rendering or doing anything graphically right now.
 775  *
 776  * @return The cache flush state
 777  * @ingroup Caches
 778  *
 779  * @see elm_cache_all_flush()
 780  */
 781 EAPI Eina_Bool elm_config_cache_flush_enabled_get(void);
 782
 783 /**
 784  * Set the configured cache flush enabled state
 785  *
 786  * This sets the globally configured cache flush enabled state.
 787  *
 788  * @param enabled The cache flush enabled state
 789  * @ingroup Caches
 790  *
 791  * @see elm_cache_all_flush()
 792  */
 793 EAPI void      elm_config_cache_flush_enabled_set(Eina_Bool enabled);
 794
 795 /**
 796  * Get the configured font cache size
 797  *
 798  * This gets the globally configured font cache size, in bytes.
 799  *
 800  * @return The font cache size
 801  * @ingroup Caches
 802  */
 803 EAPI int       elm_config_cache_font_cache_size_get(void);
 804
 805 /**
 806  * Set the configured font cache size
 807  *
 808  * This sets the globally configured font cache size, in bytes
 809  *
 810  * @param size The font cache size
 811  * @ingroup Caches
 812  */
 813 EAPI void      elm_config_cache_font_cache_size_set(int size);
 814
 815 /**
 816  * Get the configured image cache size
 817  *
 818  * This gets the globally configured image cache size, in bytes
 819  *
 820  * @return The image cache size
 821  * @ingroup Caches
 822  */
 823 EAPI int       elm_config_cache_image_cache_size_get(void);
 824
 825 /**
 826  * Set the configured image cache size
 827  *
 828  * This sets the globally configured image cache size, in bytes
 829  *
 830  * @param size The image cache size
 831  * @ingroup Caches
 832  */
 833 EAPI void       elm_config_cache_image_cache_size_set(int size);
 834
 835
 836 /**
 837  * Get the configured edje file cache size.
 838  *
 839  * This gets the globally configured edje file cache size, in number
 840  * of files.
 841  *
 842  * @return The edje file cache size
 843  * @ingroup Caches
 844  */
 845 EAPI int       elm_config_cache_edje_file_cache_size_get(void);
 846
 847 /**
 848  * Set the configured edje file cache size
 849  *
 850  * This sets the globally configured edje file cache size, in number
 851  * of files.
 852  *
 853  * @param size The edje file cache size
 854  * @ingroup Caches
 855  */
 856 EAPI void       elm_config_cache_edje_file_cache_size_set(int size);
 857
 858 /**
 859  * Get the configured edje collections (groups) cache size.
 860  *
 861  * This gets the globally configured edje collections cache size, in
 862  * number of collections.
 863  *
 864  * @return The edje collections cache size
 865  * @ingroup Caches
 866  */
 867 EAPI int       elm_config_cache_edje_collection_cache_size_get(void);
 868
 869 /**
 870  * Set the configured edje collections (groups) cache size
 871  *
 872  * This sets the globally configured edje collections cache size, in
 873  * number of collections.
 874  *
 875  * @param size The edje collections cache size
 876  * @ingroup Caches
 877  */
 878 EAPI void       elm_config_cache_edje_collection_cache_size_set(int size);
 879
 880 /**
 881  * Get the enable status of the focus highlight
 882  *
 883  * This gets whether the highlight on focused objects is enabled or not
 884  *
 885  * @see elm_config_focus_highlight_enabled_set()
 886  * @ingroup Focus
 887  */
 888 EAPI Eina_Bool            elm_config_focus_highlight_enabled_get(void);
 889
 890 /**
 891  * Set the enable status of the focus highlight
 892  *
 893  * @param enable Enable highlight if EINA_TRUE, disable otherwise
 894  *
 895  * Set whether to show or not the highlight on focused objects
 896  *
 897  * Note that it will take effect only to Elementary windows created after
 898  * this is called.
 899  *
 900  * @see elm_win_add()
 901  *
 902  * @ingroup Focus
 903  */
 904 EAPI void                 elm_config_focus_highlight_enabled_set(Eina_Bool enable);
 905
 906 /**
 907  * Get the enable status of the highlight animation
 908  *
 909  * @return The focus highlight mode set
 910  *
 911  * Get whether the focus highlight, if enabled, will animate its switch from
 912  * one object to the next
 913  *
 914  * @ingroup Focus
 915  */
 916 EAPI Eina_Bool            elm_config_focus_highlight_animate_get(void);
 917
 918 /**
 919  * Set the enable status of the highlight animation
 920  *
 921  * @param animate Enable animation if EINA_TRUE, disable otherwise
 922  *
 923  * Set whether the focus highlight, if enabled, will animate its switch from
 924  * one object to the next
 925  *
 926  * Note that it will take effect only to Elementary windows created after
 927  * this is called.
 928  *
 929  * @see elm_win_add()
 930  *
 931  * @ingroup Focus
 932  */
 933 EAPI void                 elm_config_focus_highlight_animate_set(Eina_Bool animate);
 934
 935 /**
 936  * Get the system mirrored mode. This determines the default mirrored mode
 937  * of widgets.
 938  *
 939  * @return EINA_TRUE if mirrored is set, EINA_FALSE otherwise
 940  */
 941 EAPI Eina_Bool elm_config_mirrored_get(void);
 942
 943 /**
 944  * Set the system mirrored mode. This determines the default mirrored mode
 945  * of widgets.
 946  *
 947  * @param mirrored EINA_TRUE to set mirrored mode, EINA_FALSE to unset it.
 948  */
 949 EAPI void      elm_config_mirrored_set(Eina_Bool mirrored);
 950
 951 /**
 952  * @}
 953  */