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