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