diff --git a/legacy/elementary/src/examples/bg_example_01.c b/legacy/elementary/src/examples/bg_example_01.c
index 540e0564eb..0d9995de25 100644
--- a/legacy/elementary/src/examples/bg_example_01.c
+++ b/legacy/elementary/src/examples/bg_example_01.c
@@ -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;
 }
 
diff --git a/legacy/elementary/src/lib/Elementary.h.in b/legacy/elementary/src/lib/Elementary.h.in
index 1cecdb378c..ad1fd1e4e1 100644
--- a/legacy/elementary/src/lib/Elementary.h.in
+++ b/legacy/elementary/src/lib/Elementary.h.in
@@ -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);
diff --git a/legacy/elementary/src/lib/elm_main.c b/legacy/elementary/src/lib/elm_main.c
index a1d2ae534f..52c19053fa 100644
--- a/legacy/elementary/src/lib/elm_main.c
+++ b/legacy/elementary/src/lib/elm_main.c
@@ -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)
 {