kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[elementary] Documenting the general, top-level 

functions.



SVN revision: 60594
This commit is contained in:
Gustavo Lima Chaves 2011-06-22 14:51:55 +00:00
parent 13fbc620f4
commit 60214462de
3 changed files with 580 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
legacy/elementary/src/examples/bg_example_01.c
View File

@ -45,8 +45,11 @@ elm_main(int argc __UNUSED__, char **argv __UNUSED__)
/* and show the window */
evas_object_show(win);
elm_run();
elm_run(); /* and run the program now, starting to handle all
* events, etc. */
elm_shutdown(); /* clean up and shut down */
/* exit code */
return 0;
}

595
legacy/elementary/src/lib/Elementary.h.in
View File

@ -213,6 +213,22 @@ extern "C" {
#define ELM_RECTS_INTERSECT(x, y, w, h, xx, yy, ww, hh) (((x) < ((xx) + (ww))) && ((y) < ((yy) + (hh))) && (((x) + (w)) > (xx)) && (((y) + (h)) > (yy)))
#define ELM_PI 3.14159265358979323846
/**
* @defgroup General General
*
* @brief General Elementary API. Functions that don't relate to
* Elementary objects specifically.
*
* Here are documented functions which init/shutdown the library,
* that apply to generic Elementary objects, that deal with
* configuration, et cetera.
*/
/**
* @addtogroup General
* @{
*/
/**
* Defines couple of standard Evas_Object layers to be used
* with evas_object_layer_set().
@ -233,36 +249,51 @@ extern "C" {
/**************************************************************************/
EAPI extern int ELM_ECORE_EVENT_ETHUMB_CONNECT;
/* Objects */
/**
* Emitted when policy value changed.
* Emitted when any Elementary's policy value is changed.
*/
EAPI extern int ELM_EVENT_POLICY_CHANGED;
typedef struct _Elm_Event_Policy_Changed
/**
* @typedef Elm_Event_Policy_Changed
*
* Data on the event when an Elementary policy has changed
*/
typedef struct _Elm_Event_Policy_Changed Elm_Event_Policy_Changed;
/**
* @struct _Elm_Event_Policy_Changed
*
* Data on the event when an Elementary policy has changed
*/
struct _Elm_Event_Policy_Changed
{
unsigned int policy;
int new_value;
int old_value;
} Elm_Event_Policy_Changed;
unsigned int policy; /**< the policy identifier */
int new_value; /**< value the policy had before the change */
int old_value; /**< new value the policy got */
};
/**
* Policy identifiers.
*
* @see elm_policy_set()
*/
typedef enum _Elm_Policy
{
ELM_POLICY_QUIT, /**< when should quit application automatically.
* @see Elm_Policy_Quit.
typedef enum _Elm_Policy
{
ELM_POLICY_QUIT, /**< under which circunstances the application
* should quit automatically. @see
* Elm_Policy_Quit.
*/
ELM_POLICY_LAST
} Elm_Policy;
} Elm_Policy; /**< Elementary policy identifiers/groups enumeration. @see elm_policy_set()
*/
typedef enum _Elm_Policy_Quit
{
ELM_POLICY_QUIT_NONE = 0, /**< never quit application automatically */
ELM_POLICY_QUIT_LAST_WINDOW_CLOSED /**< quit when last window is closed */
} Elm_Policy_Quit;
ELM_POLICY_QUIT_NONE = 0, /**< never quit the application
* automatically */
ELM_POLICY_QUIT_LAST_WINDOW_CLOSED /**< quit when the
* application's last
* window is closed */
} Elm_Policy_Quit; /**< Possible values for the #ELM_POLICY_QUIT policy */
typedef enum _Elm_Focus_Direction
{
@ -308,27 +339,280 @@ extern "C" {
typedef Eina_Bool (*Elm_Event_Cb) (void *data, Evas_Object *obj, Evas_Object *src, Evas_Callback_Type type, void *event_info);
#ifndef ELM_LIB_QUICKLAUNCH
#define ELM_MAIN() int main(int argc, char **argv) {elm_init(argc, argv); return elm_main(argc, argv);}
#define ELM_MAIN() int main(int argc, char **argv) {elm_init(argc, argv); return elm_main(argc, argv);} /**< macro to be used after the elm_main() function */
#else
#define ELM_MAIN() int main(int argc, char **argv) {return elm_quicklaunch_fallback(argc, argv);}
#define ELM_MAIN() int main(int argc, char **argv) {return elm_quicklaunch_fallback(argc, argv);} /**< macro to be used after the elm_main() function */
#endif
/**************************************************************************/
/* General calls */
/**
* Initialize Elementary
*
* @param[in] argc System's argument count value
* @param[in] argv System's pointer to array of argument strings
* @return The init counter value.
*
* This function initializes Elementary and increments a counter of
* the number of calls to it. It returs the new counter's value.
*
* @warning This call is exported only for use by the @c ELM_MAIN()
* macro. There is no need to use this if you use this macro (which
* is highly advisable). An elm_main() should contain the entry
* point code for your application, having the same prototype as
* elm_init(), and @b not being static (putting the @c EAPI symbol
* in front of its type declaration is advisable). The @c
* ELM_MAIN() call should be placed just after it.
*
* Example:
* @dontinclude bg_example_01.c
* @skip static void
* @until ELM_MAIN
*
* See the full @ref bg_example_01_c "example".
*
* @see elm_shutdown().
* @ingroup General
*/
EAPI int elm_init(int argc, char **argv);
/**
* Shut down Elementary
*
* @return The init counter value.
*
* This should be called at the end of your application, just
* before it ceases to do any more processing. This will clean up
* any permanent resources your application may have allocated via
* Elementary that would otherwise persist.
*
* @see elm_init() for an example
*
* @ingroup General
*/
EAPI int elm_shutdown(void);
/**
* Run Elementary's main loop
*
* This call should be issued just after all initialization is
* completed. This function will not return until elm_exit() is
* called. It will keep looping, running the main
* (event/processing) loop for Elementary.
*
* @see elm_init() for an example
*
* @ingroup General
*/
EAPI void elm_run(void);
/**
* Exit Elementary's main loop
*
* If this call is issued, it will flag the main loop to cease
* processing and return back to its parent function (usually your
* elm_main() function).
*
* @see elm_init() for an example. There, just after a request to
* close the window comes, the main loop will be left.
*
* @ingroup General
*/
EAPI void elm_exit(void);
/**
* Provide information in order to make Elementary determine the @b
* run time location of the software in question, so other data files
* such as images, sound files, executable utilities, libraries,
* modules and locale files can be found.
*
* @param mainfunc This is your application's main function name,
* whose binary's location is to be found. Providing @c NULL
* will make Elementary not to use it
* @param dom This will be used as the application's "domain", in the
* form of a prefix to any environment variables that may
* override prefix detection and the directory name, inside the
* standard share or data directories, where the software's
* data files will be looked for.
* @param checkfile This is an (optional) magic file's path to check
* for existence (and it must be located in the data directory,
* under the share directory provided above). Its presence will
* help determine the prefix found was correct. Pass @c NULL if
* the check is not to be done.
*
* This function allows one to re-locate the application somewhere
* else after compilation, if the developer wishes for easier
* distribution of pre-compiled binaries.
*
* The prefix system is designed to locate where the given software is
* installed (under a common path prefix) at run time and then report
* specific locations of this prefix and common directories inside
* this prefix like the binary, library, data and locale directories,
* through the @c elm_app_*_get() family of functions.
*
* Call elm_app_info_set() early on before you change working
* directory or anything about @c argv[0], so it gets accurate
* information.
*
* It will then try and trace back which file @p mainfunc comes from,
* if provided, to determine the application's prefix directory.
*
* The @p dom parameter provides a string prefix to prepend before
* environment variables, allowing a fallback to @b specific
* environment variables to locate the software. You would most
* probably provide a lowercase string there, because it will also
* serve as directory domain, explained next. For environment
* variables purposes, this string is made uppercase. For example if
* @c "myapp" is provided as the prefix, then the program would expect
* @c "MYAPP_PREFIX" as a master environment variable to specify the
* exact install prefix for the software, or more specific environment
* variables like @c "MYAPP_BIN_DIR", @c "MYAPP_LIB_DIR", @c
* "MYAPP_DATA_DIR" and @c "MYAPP_LOCALE_DIR", which could be set by
* the user or scripts before launching. If not provided (@c NULL),
* environment variables will not be used to override compiled-in
* defaults or auto detections.
*
* The @p dom string also provides a subdirectory inside the system
* shared data directory for data files. For example, if the system
* directory is @c /usr/local/share, then this directory name is
* appended, creating @c /usr/local/share/myapp, if it @p was @c
* "myapp". It is expected the application installs data files in
* this directory.
*
* The @p checkfile is a file name or path of something inside the
* share or data directory to be used to test that the prefix
* detection worked. For example, your app will install a wallpaper
* image as @c /usr/local/share/myapp/images/wallpaper.jpg and so to
* check that this worked, provide @c "images/wallpaper.jpg" as the @p
* checkfile string.
*
* @see elm_app_compile_bin_dir_set()
* @see elm_app_compile_lib_dir_set()
* @see elm_app_compile_data_dir_set()
* @see elm_app_compile_locale_set()
* @see elm_app_prefix_dir_get()
* @see elm_app_bin_dir_get()
* @see elm_app_lib_dir_get()
* @see elm_app_data_dir_get()
* @see elm_app_locale_dir_get()
*/
EAPI void elm_app_info_set(void *mainfunc, const char *dom, const char *checkfile);
/**
* Provide information on the @b fallback application's binaries
* directory, on scenarios where they get overriden by
* elm_app_info_set().
*
* @param dir The path to the default binaries directory (compile time
* one)
*
* @note Elementary will as well use this path to determine actual
* names of binaries' directory paths, maybe changing it to be @c
* something/local/bin instead of @c something/bin, only, for
* example.
*
* @warning You should call this function @b before
* elm_app_info_set().
*/
EAPI void elm_app_compile_bin_dir_set(const char *dir);
/**
* Provide information on the @b fallback application's libraries
* directory, on scenarios where they get overriden by
* elm_app_info_set().
*
* @param dir The path to the default libraries directory (compile
* time one)
*
* @note Elementary will as well use this path to determine actual
* names of libraries' directory paths, maybe changing it to be @c
* something/lib32 or @c something/lib64 instead of @c something/lib,
* only, for example.
*
* @warning You should call this function @b before
* elm_app_info_set().
*/
EAPI void elm_app_compile_lib_dir_set(const char *dir);
/**
* Provide information on the @b fallback application's data
* directory, on scenarios where they get overriden by
* elm_app_info_set().
*
* @param dir The path to the default data directory (compile time
* one)
*
* @note Elementary will as well use this path to determine actual
* names of data directory paths, maybe changing it to be @c
* something/local/share instead of @c something/share, only, for
* example.
*
* @warning You should call this function @b before
* elm_app_info_set().
*/
EAPI void elm_app_compile_data_dir_set(const char *dir);
/**
* Provide information on the @b fallback application's locale
* directory, on scenarios where they get overriden by
* elm_app_info_set().
*
* @param dir The path to the default locale directory (compile time
* one)
*
* @warning You should call this function @b before
* elm_app_info_set().
*/
EAPI void elm_app_compile_locale_set(const char *dir);
/**
* Retrieve the application's run time prefix directory, as set by
* elm_app_info_set() and the way (environment) the application was
* run from.
*
* @return The directory prefix the application is actually using
*/
EAPI const char *elm_app_prefix_dir_get(void);
/**
* Retrieve the application's run time binaries prefix directory, as
* set by elm_app_info_set() and the way (environment) the application
* was run from.
*
* @return The binaries directory prefix the application is actually
* using
*/
EAPI const char *elm_app_bin_dir_get(void);
/**
* Retrieve the application's run time libraries prefix directory, as
* set by elm_app_info_set() and the way (environment) the application
* was run from.
*
* @return The libraries directory prefix the application is actually
* using
*/
EAPI const char *elm_app_lib_dir_get(void);
/**
* Retrieve the application's run time data prefix directory, as
* set by elm_app_info_set() and the way (environment) the application
* was run from.
*
* @return The data directory prefix the application is actually
* using
*/
EAPI const char *elm_app_data_dir_get(void);
/**
* Retrieve the application's run time locale prefix directory, as
* set by elm_app_info_set() and the way (environment) the application
* was run from.
*
* @return The locale directory prefix the application is actually
* using
*/
EAPI const char *elm_app_locale_dir_get(void);
EAPI void elm_quicklaunch_mode_set(Eina_Bool ql_on);
@ -348,9 +632,43 @@ extern "C" {
EAPI Eina_Bool elm_need_e_dbus(void);
EAPI Eina_Bool elm_need_ethumb(void);
/**
* Set a new policy's value (for a given policy group/identifier).
*
* @param policy policy identifier, as in @ref Elm_Policy.
* @param value policy value, which depends on the identifier
*
* @return @c EINA_TRUE on success or @c EINA_FALSE, on error.
*
* Elementary policies define applications' behavior,
* somehow. These behaviors are divided in policy groups (see
* #Elm_Policy enumeration). This call will emit the Ecore event
* #ELM_EVENT_POLICY_CHANGED, which can be hooked at with
* handlers. An #Elm_Event_Policy_Changed struct will be passed,
* then.
*
* @note Currently, we have only one policy identifier/group
* (#ELM_POLICY_QUIT), which has two possible values.
*
* @ingroup General
*/
EAPI Eina_Bool elm_policy_set(unsigned int policy, int value);
/**
* Gets the policy value set for given policy identifier.
*
* @param policy policy identifier, as in #Elm_Policy.
* @return The currently set policy value, for that
* identifier. Will be @c 0 if @p policy passed is invalid.
*
* @ingroup General
*/
EAPI int elm_policy_get(unsigned int policy);
/**
* @}
*/
EAPI void elm_all_flush(void);
EAPI int elm_cache_flush_interval_get(void);
EAPI void elm_cache_flush_interval_set(int size);
@ -371,7 +689,37 @@ extern "C" {
EAPI void elm_edje_collection_cache_set(int size);
EAPI void elm_edje_collection_cache_all_set(int size);
/**
* @defgroup Scaling Selective Widget Scaling
*
* Different widgets can be scaled independently. These functions
* allow you to manipulate this scaling on a per-widget basis. The
* object and all its children get their scaling factors multiplied
* by the scale factor set. This is multiplicative, in that if a
* child also has a scale size set it is in turn multiplied by its
* parent's scale size. @c 1.0 means “don't scale”, @c 2.0 is
* double size, @c 0.5 is half, etc.
*/
/**
* Set the scaling factor for a given Elementary object
*
* @param obj The Elementary to operate on
* @param scale Scale factor (from @c 0.0 up, with @c 1.0 meaning
* no scaling)
*
* @ingroup Scaling
*/
EAPI void elm_object_scale_set(Evas_Object *obj, double scale) EINA_ARG_NONNULL(1);
/**
* Get the scaling factor for a given Elementary object
*
* @param obj The object
* @return The scaling factor set by elm_object_scale_set()
*
* @ingroup Scaling
*/
EAPI double elm_object_scale_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
EAPI Eina_Bool elm_object_mirrored_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
EAPI void elm_object_mirrored_set(Evas_Object *obj, Eina_Bool mirrored) EINA_ARG_NONNULL(1);
@ -379,10 +727,76 @@ extern "C" {
EAPI void elm_object_mirrored_automatic_set(Evas_Object *obj, Eina_Bool automatic) EINA_ARG_NONNULL(1);
EAPI void elm_object_style_set(Evas_Object *obj, const char *style) EINA_ARG_NONNULL(1);
EAPI const char *elm_object_style_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
/**
* @defgroup Styles Styles
*
* Widgets can have different styles of look. These generic API's
* set styles of widgets, if they support them (and if the theme(s)
* do).
*/
/**
* Set the disabled state of an Elementary object.
*
* @param obj The Elementary object to operate on
* @param disabled The state to put in in: @c EINA_TRUE for
* disabled, @c EINA_FALSE for enabled
*
* Elementary objects can be @b disabled, in which state they won't
* receive input and, in general, will be themed differently from
* their normal state, usually greyed out. Useful for contexts
* where you don't want your users to interact with some of the
* parts of you interface.
*
* This sets the state for the widget, either disabling it or
* enabling it back.
*
* @ingroup Styles
*/
EAPI void elm_object_disabled_set(Evas_Object *obj, Eina_Bool disabled) EINA_ARG_NONNULL(1);
/**
* Get the disabled state of an Elementary object.
*
* @param obj The Elementary object to operate on
* @return @c EINA_TRUE, if the widget is disabled, @c EINA_FALSE
* if it's enabled (or on errors)
*
* This gets the state of the widget, which might be enabled or disabled.
*
* @ingroup Styles
*/
EAPI Eina_Bool elm_object_disabled_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
/**
* @defgroup WidgetNavigation Widget Tree Navigation.
*
* How to check if an Evas Object is an Elementary widget? How to
* get the first elementary widget that is parent of the given
* object? These are all covered in widget tree navigation.
*/
EAPI Eina_Bool elm_object_widget_check(const Evas_Object *obj) EINA_ARG_NONNULL(1);
/**
* Get the first parent of the given object that is an Elementary
* widget.
*
* @param obj the Elementary object to query parent from.
* @return the parent object that is an Elementary widget, or @c
* NULL, if it was not found.
*
* Use this to query for an object's parent widget.
*
* @note Most of Elementary users wouldn't be mixing non-Elementary
* smart objects in the objects tree of an application, as this is
* an advanced usage of Elementary with Evas. So, except for the
* application's window, which is the root of that tree, all other
* objects would have valid Elementary widget parents.
*
* @ingroup WidgetNavigation
*/
EAPI Evas_Object *elm_object_parent_widget_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
EAPI Evas_Object *elm_object_top_widget_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
EAPI const char *elm_object_widget_type_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
@ -443,19 +857,140 @@ extern "C" {
EAPI Eina_Hash *elm_font_available_hash_add(Eina_List *list);
EAPI void elm_font_available_hash_del(Eina_Hash *hash);
/**
* @defgroup Fingers Fingers
*
* Elementary is designed to be finger-friendly for touchscreens,
* and so in addition to scaling for display resolution, it can
* also scale based on finger "resolution" (or size). You can then
* customize the granularity of the areas meant to receive clicks
* on touchscreens.
*
* Different profiles may have pre-set values for finger sizes.
*/
/**
* Get the configured "finger size"
*
* @return The finger size
*
* This gets the globally configured finger size, <b>in pixels</b>
*
* @ingroup Fingers
*/
EAPI Evas_Coord elm_finger_size_get(void);
EAPI void elm_finger_size_set(Evas_Coord size);
EAPI void elm_finger_size_all_set(Evas_Coord size);
/**
* @defgroup Focus Focus
*
* An Elementary application has, at all times, one (and only one)
* @b focused object. This is what determines where the input
* events go to within the application's window. Also, focused
* objects can be decorated differently, in order to signal to the
* user where the input is, at a given moment.
*
* Elementary applications also have the concept of <b>focus
* chain</b>: one can cycle through all the windows' focusable
* objects by input (tab key) or programmatically. The default
* focus chain for an application is the one define by the order in
* which the widgets where added in code. One will cycle through
* top level widgets, and, for each one containg sub-objects, cycle
* through them all, before returning to the level
* above. Elementary also allows one to set @b custom focus chains
* for their applications.
*
* Besides the focused decoration a widget may exhibit, when it
* gets focus, Elementary has a @b global focus highlight object
* that can be enabled for a window. If one chooses to do so, this
* extra highlight effect will surround the current focused object,
* too.
*
* @note Some Elementary widgets are @b unfocusable, after
* creation, by their very nature: they are not meant to be
* interacted with input events, but are there just for visual
* purposes.
*/
EAPI Eina_Bool elm_focus_highlight_enabled_get(void);
EAPI void elm_focus_highlight_enabled_set(Eina_Bool enable);
EAPI Eina_Bool elm_focus_highlight_animate_get(void);
EAPI void elm_focus_highlight_animate_set(Eina_Bool animate);
/**
* Get the whether an Elementary object has the focus or not.
*
* @param obj The Elementary object to get the information from
* @return @c EINA_TRUE, if the object is focused, @c EINA_FALSE if
* not (and on errors).
*
* @see elm_object_focus()
*
* @ingroup Focus
*/
EAPI Eina_Bool elm_object_focus_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
/**
* Make a given Elementary object the focused one.
*
* @param obj The Elementary object to make focused.
*
* @note This object, if it can handle focus, will take the focus
* away from the one who had it previously and will, for now on, be
* the one receiving input events.
*
* @see elm_object_focus_get()
*
* @ingroup Focus
*/
EAPI void elm_object_focus(Evas_Object *obj) EINA_ARG_NONNULL(1);
/**
* Remove the focus from an Elementary object
*
* @param obj The Elementary to take focus from
*
* This removes the focus from @p obj, passing it back to the
* previous element in the focus chain list.
*
* @see elm_object_focus() and elm_object_focus_custom_chain_get()
*
* @ingroup Focus
*/
EAPI void elm_object_unfocus(Evas_Object *obj) EINA_ARG_NONNULL(1);
/**
* Set the ability for an Element object to be focused
*
* @param obj The Elementary object to operate on
* @param enable @c EINA_TRUE if the object can be focused, @c
* EINA_FALSE if not (and on errors)
*
* This sets whether the object @p obj is able to take focus or
* not. Unfocusable objects do nothing when programmatically
* focused, being the nearest focusable parent object the one
* really getting focus. Also, when they receive mouse input, they
* will get the event, but not take away the focus from where it
* was previously.
*
* @ingroup Focus
*/
EAPI void elm_object_focus_allow_set(Evas_Object *obj, Eina_Bool enable) EINA_ARG_NONNULL(1);
/**
* Get whether an Elementary object is focusable or not
*
* @param obj The Elementary object to operate on
* @return @c EINA_TRUE if the object is allowed to be focused, @c
* EINA_FALSE if not (and on errors)
*
* @note Objects which are meant to be interacted with by input
* events are created able to be focused, by default. All the
* others are not.
*
* @ingroup Focus
*/
EAPI Eina_Bool elm_object_focus_allow_get(const Evas_Object *obj) EINA_ARG_NONNULL(1);
EAPI void elm_object_focus_custom_chain_set(Evas_Object *obj, Eina_List *objs) EINA_ARG_NONNULL(1);
@ -513,6 +1048,28 @@ extern "C" {
EAPI void elm_object_event_callback_add(Evas_Object *obj, Elm_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
EAPI void *elm_object_event_callback_del(Evas_Object *obj, Elm_Event_Cb func, const void *data) EINA_ARG_NONNULL(1, 2);
/**
* Adjust size of an element for finger usage.
*
* @param times_w How many fingers should fit horizontally
* @param w Pointer to the width size to adjust
* @param times_h How many fingers should fit vertically
* @param h Pointer to the height size to adjust
*
* This takes width and height sizes (in pixels) as input and a
* size multiple (which is how many fingers you want to place
* within the area, being "finger" the size set by
* elm_finger_size_set()), and adjusts the size to be large enough
* to accommodate the resulting size -- if it doesn't already
* accommodate it. On return the @p w and @p h sizes pointed to by
* these parameters will be modified, on those conditions.
*
* @note This is kind of a low level Elementary call, most useful
* on size evaluation times for widgets. An external user wouldn't
* be calling, most of the time.
*
* @ingroup Fingers
*/
EAPI void elm_coords_finger_size_adjust(int times_w, Evas_Coord *w, int times_h, Evas_Coord *h);
EAPI double elm_longpress_timeout_get(void);

214
legacy/elementary/src/lib/elm_main.c
View File

@ -402,19 +402,6 @@ _prefix_shutdown(void)
app_pfx = NULL;
}
/**
* @defgroup General General
*/
/**
* Inititalise Elementary
*
* @return The init counter value.
*
* This call is exported only for use by the ELM_MAIN() macro. There is no
* need to use this if you use this macro (which is highly advisable).
* @ingroup General
*/
EAPI int
elm_init(int argc,
char **argv)
@ -427,17 +414,6 @@ elm_init(int argc,
return _elm_init_count;
}
/**
* Shut down Elementary
*
* @return The init counter value.
*
* This should be called at the end of your application just before it ceases
* to do any more processing. This will clean up any permanent resources your
* application may have allocated via Elementary that would otherwise persist
* on an exit without this call.
* @ingroup General
*/
EAPI int
elm_shutdown(void)
{
@ -1084,51 +1060,18 @@ elm_quicklaunch_exe_path_get(const char *exe)
return NULL;
}
/**
* Run the main loop
*
* This call should be called just after all initialization is complete. This
* function will not return until elm_exit() is called. It will keep looping
* running the main event/processing loop for Elementary.
* @ingroup General
*/
EAPI void
elm_run(void)
{
ecore_main_loop_begin();
}
/**
* Exit the main loop
*
* If this call is called, it will flag the main loop to cease processing and
* return back to its parent function.
* @ingroup General
*/
EAPI void
elm_exit(void)
{
ecore_main_loop_quit();
}
/**
* Set new policy value.
*
* This will emit the ecore event ELM_EVENT_POLICY_CHANGED in the main
* loop giving the event information Elm_Event_Policy_Changed with
* policy identifier, new and old values.
*
* @param policy policy identifier as in Elm_Policy.
* @param value policy value, depends on identifiers, usually there is
* an enumeration with the same prefix as the policy name, for
* example: ELM_POLICY_QUIT and Elm_Policy_Quit
* (ELM_POLICY_QUIT_NONE, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED).
* @ingroup General
*
* @return @c EINA_TRUE on success or @c EINA_FALSE on error (right
* now just invalid policy identifier, but in future policy
* value might be enforced).
*/
EAPI Eina_Bool
elm_policy_set(unsigned int policy,
int value)
@ -1155,14 +1098,6 @@ elm_policy_set(unsigned int policy,
return EINA_TRUE;
}
/**
* Gets the policy value set for given identifier.
*
* @param policy policy identifier as in Elm_Policy.
* @ingroup General
*
* @return policy value. Will be 0 if policy identifier is invalid.
*/
EAPI int
elm_policy_get(unsigned int policy)
{
@ -1237,24 +1172,6 @@ elm_object_mirrored_automatic_set(Evas_Object *obj, Eina_Bool automatic)
elm_widget_mirrored_automatic_set(obj, automatic);
}
/**
* @defgroup Scaling Selective Widget Scaling
*
* Different widgets can be scaled independently. These functions allow you to
* manipulate this scaling on a per-widget basis. The object and all its
* children get their scaling factors multiplied by the scale factor set.
* This is multiplicative, in that if a child also has a scale size set it is
* in turn multiplied by its parent's scale size. 1.0 means “don't scale”,
* 2.0 is double size, 0.5 is half etc.
*/
/**
* Set the scaling factor
*
* @param obj The object
* @param scale Scale factor (from 0.0 up, with 1.0 == no scaling)
* @ingroup Scaling
*/
EAPI void
elm_object_scale_set(Evas_Object *obj,
double scale)
@ -1263,13 +1180,6 @@ elm_object_scale_set(Evas_Object *obj,
elm_widget_scale_set(obj, scale);
}
/**
* Get the scaling factor
*
* @param obj The object
* @return The scaling factor set by elm_object_scale_set()
* @ingroup Scaling
*/
EAPI double
elm_object_scale_get(const Evas_Object *obj)
{
@ -1330,13 +1240,6 @@ elm_scale_all_set(double scale)
#endif
}
/**
* @defgroup Styles Styles
*
* Widgets can have different styles of look. These generic API's set
* styles of widgets, if they support them (and if the theme(s) do).
*/
/**
* Set the style
*
@ -1371,15 +1274,6 @@ elm_object_style_get(const Evas_Object *obj)
return elm_widget_style_get(obj);
}
/**
* Set the disable state
*
* This sets the disable state for the widget.
*
* @param obj The object
* @param disabled The state
* @ingroup Styles
*/
EAPI void
elm_object_disabled_set(Evas_Object *obj,
Eina_Bool disabled)
@ -1388,15 +1282,6 @@ elm_object_disabled_set(Evas_Object *obj,
elm_widget_disabled_set(obj, disabled);
}
/**
* Get the disable state
*
* This gets the disable state for the widget.
*
* @param obj The object
* @return True, if the widget is disabled
* @ingroup Styles
*/
EAPI Eina_Bool
elm_object_disabled_get(const Evas_Object *obj)
{
@ -1903,22 +1788,6 @@ elm_font_available_hash_del(Eina_Hash *hash)
_elm_font_available_hash_del(hash);
}
/**
* @defgroup Fingers Fingers
*
* Elementary is designed to be finger-friendly for touchscreens, and so in
* addition to scaling for display resolution, it can also scale based on
* finger "resolution" (or size).
*/
/**
* Get the configured finger size
*
* This gets the globally configured finger size in pixels
*
* @return The finger size
* @ingroup Fingers
*/
EAPI Evas_Coord
elm_finger_size_get(void)
{
@ -1963,20 +1832,6 @@ elm_finger_size_all_set(Evas_Coord size)
#endif
}
/**
* Adjust size of an element for finger usage
*
* This takes width and height sizes (in pixels) as input and a size multiple
* (which is how many fingers you want to place within the area), and adjusts
* the size tobe large enough to accommodate finger. On return the w and h
* sizes poiner do by these parameters will be modified.
*
* @param times_w How many fingers should fit horizontally
* @param w Pointer to the width size to adjust
* @param times_h How many fingers should fit vertically
* @param h Pointer to the height size to adjust
* @ingroup Fingers
*/
EAPI void
elm_coords_finger_size_adjust(int times_w,
Evas_Coord *w,
@ -2364,22 +2219,6 @@ elm_edje_collection_cache_all_set(int size)
#endif
}
/**
* @defgroup Focus Focus
*
* Objects have focus. This is what determines where the keyboard input goes to
* within the application window.
*/
/**
* Get the focus of the object
*
* This gets the focused property of the object.
*
* @param obj The object
* @return 1 if the object is focused, 0 if not.
* @ingroup Focus
*/
EAPI Eina_Bool
elm_object_focus_get(const Evas_Object *obj)
{
@ -2387,14 +2226,6 @@ elm_object_focus_get(const Evas_Object *obj)
return elm_widget_focus_get(obj);
}
/**
* Set the focus to the object
*
* This sets the focus target for keyboard input to be the object indicated.
*
* @param obj The object
* @ingroup Focus
*/
EAPI void
elm_object_focus(Evas_Object *obj)
{
@ -2405,15 +2236,6 @@ elm_object_focus(Evas_Object *obj)
elm_widget_focus_cycle(obj, ELM_FOCUS_NEXT);
}
/**
* Remove the focus from the object
*
* This removes the focus target for keyboard input from be the object
* indicated.
*
* @param obj The object
* @ingroup Focus
*/
EAPI void
elm_object_unfocus(Evas_Object *obj)
{
@ -2422,16 +2244,6 @@ elm_object_unfocus(Evas_Object *obj)
elm_widget_focused_object_clear(obj);
}
/**
* Set the ability for the object to focus
*
* This sets the ability for the object to be able to get keyboard focus or
* not. By default all objects are able to be focused.
*
* @param obj The object
* @param enable 1 if the object can be focused, 0 if not
* @ingroup Focus
*/
EAPI void
elm_object_focus_allow_set(Evas_Object *obj,
Eina_Bool enable)
@ -2440,16 +2252,6 @@ elm_object_focus_allow_set(Evas_Object *obj,
elm_widget_can_focus_set(obj, enable);
}
/**
* Get the ability for the object to focus
*
* This gets the ability for the object to be able to get keyboard focus or
* not. By default all objects are able to be focused.
*
* @param obj The object
* @return 1 if the object is allowed to be focused, 0 if not.
* @ingroup Focus
*/
EAPI Eina_Bool
elm_object_focus_allow_get(const Evas_Object *obj)
{
@ -3348,14 +3150,6 @@ elm_object_scroll_freeze_pop(Evas_Object *obj)
elm_widget_scroll_freeze_pop(obj);
}
/**
* @defgroup WidgetNavigation Widget Tree Navigation.
*
* How to check if an Evas Object is an Elementary widget? How to get
* the first elementary widget that is parent of the given object?
* These are all covered in widget tree navigation.
*/
/**
* Check if the given Evas Object is an Elementary widget.
*
@ -3371,14 +3165,6 @@ elm_object_widget_check(const Evas_Object *obj)
return elm_widget_is(obj);
}
/**
* Get the first parent of the given object that is an Elementary widget.
*
* @param obj the object to query.
* @return the parent object that is an Elementary widget, or @c NULL
* if no parent is, or no parents at all.
* @ingroup WidgetNavigation
*/
EAPI Evas_Object *
elm_object_parent_widget_get(const Evas_Object *obj)
{