enlightenment/python-efl
enlightenment
/
python-efl
7
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Documentation: Fix invalid references and minor issues.

This commit is contained in:
Kai Huuhko 2013-12-05 08:29:55 +02:00
parent 0a03a272e7
commit 4e4b8e2fea
34 changed files with 211 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
doc/conf.py
View File

@ -125,6 +125,29 @@ pygments_style = 'sphinx'
# Setting this True will show missing references as warnings.
#nitpicky = True
# nitpick_ignore = [
# ('py:obj', 'int'),
# ('py:obj', 'float'),
# ('py:obj', 'double'),
# ('py:obj', 'callable'),
# ('py:obj', 'function'),
# ('py:obj', 'str'),
# ('py:exc', 'RuntimeError'),
# ('py:exc', 'RuntimeWarning'),
# ('py:exc', 'ValueError'),
# ('py:exc', 'TypeError'),
# ('py:obj', 'Evas_Coord (int)'),
# ('py:obj', 'string'),
# ('py:obj', 'list'),
# ('py:class', 'object'),
# ('py:obj', 'unicode'),
# ('py:obj', 'bool'),
# ('py:obj', 'tuple of ints'),
# ('py:class', 'efl.eo.Eo'),
# ('py:attr', 'efl.eo.Eo.data'),
# ('py:obj', 'datetime.date'),
# ]
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for

5
efl/elementary/calendar_elm.pyx
View File

@ -274,8 +274,9 @@ cdef class CalendarMark(object):
Delete a mark from the calendar.
If deleting all calendar marks is required, ``del`` :py:attr:`marks`
should be used instead of getting marks list and deleting each one.
If deleting all calendar marks is required, ``del``
:py:attr:`Calendar.marks` should be used instead of getting marks list
and deleting each one.
.. seealso:: :py:meth:`Calendar.mark_add`

2
efl/elementary/ctxpopup.pyx
View File

@ -122,7 +122,7 @@ cdef class CtxpopupItem(ObjectItem):
removed.
:param icon: Icon to be set on new item
:type icon: :py:class:`evas.object.Object`
:type icon: :py:class:`~efl.evas.Object`
:param label: The Label of the new item
:type label: string
:param func: Convenience function called when item selected

6
efl/elementary/diskselector.pyx
View File

@ -116,9 +116,9 @@ cdef class DiskselectorItem(ObjectItem):
disk.item_append("label", ic)
.. seealso::
:py:func:`elementary.object_item.ObjectItem.delete()`
:py:func:`clear()`
:py:class:`elementary.image.Image`
:py:meth:`~efl.elementary.object_item.ObjectItem.delete`
:py:meth:`Diskselector.clear`
:py:class:`~efl.elementary.image.Image`
"""

30
efl/elementary/flipselector.pyx
View File

@ -208,28 +208,26 @@ cdef class FlipSelectorItem(ObjectItem):
return bool(elm_flipselector_item_selected_get(self.item))
property prev:
"""Gets the item before ``item`` in a flip selector widget's internal list of
items.
"""Gets the item before ``item`` in a flip selector widget's internal
list of items.
:type: :py:class:`FlipSelectorItem`
.. seealso:: :py:func:`item_next_get`
"""
def __get__(self):
return _object_item_to_python(elm_flipselector_item_prev_get(self.item))
return _object_item_to_python(
elm_flipselector_item_prev_get(self.item))
property next:
"""Gets the item after ``item`` in a flip selector widget's
internal list of items.
"""Gets the item after ``item`` in a flip selector widget's internal
list of items.
:type: :py:class:`FlipSelectorItem`
.. seealso:: :py:func:`item_prev_get`
"""
def __get__(self):
return _object_item_to_python(elm_flipselector_item_next_get(self.item))
return _object_item_to_python(
elm_flipselector_item_next_get(self.item))
cdef class FlipSelector(Object):
@ -345,7 +343,8 @@ cdef class FlipSelector(Object):
"""
def __get__(self):
return tuple(_object_item_list_to_python(elm_flipselector_items_get(self.obj)))
return tuple(_object_item_list_to_python(
elm_flipselector_items_get(self.obj)))
property first_item:
"""Get the first item in the given flip selector widget's list of
@ -358,7 +357,8 @@ cdef class FlipSelector(Object):
"""
def __get__(self):
return _object_item_to_python(elm_flipselector_first_item_get(self.obj))
return _object_item_to_python(
elm_flipselector_first_item_get(self.obj))
property last_item:
"""Get the last item in the given flip selector widget's list of
@ -371,7 +371,8 @@ cdef class FlipSelector(Object):
"""
def __get__(self):
return _object_item_to_python(elm_flipselector_last_item_get(self.obj))
return _object_item_to_python(
elm_flipselector_last_item_get(self.obj))
property selected_item:
"""Get the currently selected item in a flip selector widget.
@ -380,7 +381,8 @@ cdef class FlipSelector(Object):
"""
def __get__(self):
return _object_item_to_python(elm_flipselector_selected_item_get(self.obj))
return _object_item_to_python(
elm_flipselector_selected_item_get(self.obj))
property first_interval:
"""The interval on time updates for a user mouse button hold on a

33
efl/elementary/general.pyx
View File

@ -18,13 +18,40 @@
"""
.. _General:
General
=======
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.
.. _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.
Enumerations
------------
============
.. _Elm_Policy:
Policy types
============
------------
.. data:: ELM_POLICY_QUIT
@ -34,7 +61,7 @@ Policy types
.. _Elm_Policy_Quit:
Quit policy types
=================
-----------------
.. data:: ELM_POLICY_QUIT_NONE

7
efl/elementary/gengrid_item.pxi
View File

@ -241,12 +241,10 @@ cdef class GengridItem(ObjectItem):
elm_gengrid_item_update(self.item)
property selected:
"""This sets the selected state of an item. If multi-selection is
"""The selected state of an item. If multi-selection is
not enabled on the containing gengrid and *selected* is ``True``,
any other previously selected items will get unselected in favor of
this new one.
.. seealso:: :py:func:`item_selected_get()`
a new one.
"""
def __get__(self):
@ -317,6 +315,7 @@ cdef class GengridItem(ObjectItem):
<const_char *>text if text is not None else NULL)
def tooltip_text_set(self, text):
# TODO: document this
if isinstance(text, unicode): text = PyUnicode_AsUTF8String(text)
elm_gengrid_item_tooltip_text_set(self.item,
<const_char *>text if text is not None else NULL)

2
efl/elementary/gengrid_widget.pxi
View File

@ -266,7 +266,7 @@ cdef class Gengrid(Object):
property item_size:
"""A gengrid, after creation, has still no information on the size
to give to each of its cells. So, you most probably will end up
with squares one :ref:`Fingers` "finger" wide, the default
with squares one :ref:`finger <Fingers>` wide, the default
size. Use this property to force a custom size for you items,
making them as big as you wish.

8
efl/elementary/genlist_item.pxi
View File

@ -696,14 +696,14 @@ cdef class GenlistItem(ObjectItem):
mode is activated on an item, any other selected item is immediately
unselected. This feature provides an easy way of implementing a new
kind of animation for selecting an item, without having to entirely
rewrite the item style theme. However, the elm_genlist_selected_*
rewrite the item style theme. However, the Genlist.selected_*
API can't be used to get what item is activate for a mode.
The current item style will still be used, but applying a genlist
mode to an item will select it using a different kind of animation.
The current active item for a mode can be found by
elm_genlist_decorated_item_get().
The current active item for a mode can be found at
:py:attr:`Genlist.decorated_item`.
The characteristics of genlist mode are:
@ -724,7 +724,7 @@ cdef class GenlistItem(ObjectItem):
:type: (unicode **decorate_it_type**, bool **decorate_it_set**)
.. seealso:: :py:attr:`mode` :py:attr:`decorated_item`
.. seealso:: :py:attr:`Genlist.mode`
"""
def __set__(self, value):

4
efl/elementary/genlist_widget.pxi
View File

@ -394,9 +394,9 @@ cdef class Genlist(Object):
the original item data has changed and the changes are desired to be
reflected.
To update just one item, use elm_genlist_item_update().
To update just one item, use :py:meth:`Genlist.item_update`.
.. seealso:: :py:attr:`realized_items` :py:func:`item_update()`
.. seealso:: :py:attr:`realized_items`
"""
elm_genlist_realized_items_update(self.obj)

4
efl/elementary/gesture_layer.pyx
View File

@ -65,7 +65,7 @@ on ``Elm_Gesture_Type``:
Note that we consider a flick as a line-gesture that should be completed
in flick-time-limit as defined in
:py:class:`elementary.configuration.Configuration`.
:py:class:`~efl.elementary.configuration.Configuration`.
``Elm_Gesture_Zoom_Info`` is the info reported for ``ELM_GESTURE_ZOOM``
gesture.
@ -80,7 +80,7 @@ fingers from surface. When user fingers rests on same-spot gesture is
ended and starts again when fingers moved.
Setting glayer_continues_enable to false in
:py:class:`elementary.configuration.Configuration` will change this
:py:class:`~efl.elementary.configuration.Configuration` will change this
behavior so gesture starts when user touches (a *DOWN* event)
touch-surface and ends when no fingers touches surface (a *UP* event).

2
efl/elementary/hover.pyx
View File

@ -190,7 +190,7 @@ cdef class Hover(LayoutClass):
ELM_HOVER_AXIS_BOTH or ELM_HOVER_AXIS_NONE has the same effect and
the returned position may be in either axis.
.. seealso:: :py:func:`part_content_set()`
.. seealso:: :py:meth:`~efl.elementary.object.Object.part_content_set`
:param pref_axis: The preferred orientation axis for the hover
object to use

4
efl/elementary/hoversel.pyx
View File

@ -317,7 +317,7 @@ cdef class Hoversel(Button):
.. warning:: Should **not** be called while the hoversel is active;
use :py:attr:`expanded` to check first.
.. seealso:: :py:func:`HoverselItem.delete()`
.. seealso:: :py:meth:`~efl.elementary.object_item.ObjectItem.delete`
"""
elm_hoversel_clear(self.obj)
@ -325,7 +325,7 @@ cdef class Hoversel(Button):
property items:
"""Get the list of items within the given hoversel.
.. seealso:: :py:func:`HoverselItem.add()`
.. seealso:: :py:func:`HoverselItem.add_to()`
:type: tuple of :py:class:`HoverselItem`'s

22
efl/elementary/index.pyx
View File

@ -454,17 +454,18 @@ cdef class Index(LayoutClass):
"""
return IndexItem(letter, callback, *args, **kargs).insert_before(before)
#def item_sorted_insert(self, letter, callback = None, *args, **kargs):
"""Insert a new item into the given index widget, using ``cmp_func``
function to sort items (by item handles).
# TODO:
# def item_sorted_insert(self, letter, callback = None, *args, **kargs):
# """Insert a new item into the given index widget, using ``cmp_func``
# function to sort items (by item handles).
A constructor for :py:class:`IndexItem`
# A constructor for :py:class:`IndexItem`
:see: :py:func:`IndexItem.insert_sorted`
# :see: :py:func:`IndexItem.insert_sorted`
"""
#return IndexItem(ELM_INDEX_ITEM_INSERT_SORTED, self, letter,
#None, callback, *args, **kargs)
# """
# return IndexItem(ELM_INDEX_ITEM_INSERT_SORTED, self, letter,
# None, callback, *args, **kargs)
def item_find(self, data):
"""item_find(data) -> IndexItem
@ -485,8 +486,9 @@ cdef class Index(LayoutClass):
Removes **all** items from a given index widget.
If deletion callbacks are set, via :py:func:`delete_cb_set()`,
that callback function will be called for each item.
If deletion callbacks are set, via
:py:meth:`efl.elementary.object_item.ObjectItem.delete_cb_set`, that
callback function will be called for each item.
"""
elm_index_item_clear(self.obj)

7
efl/elementary/innerwindow.pyx
View File

@ -62,9 +62,10 @@ cdef class InnerWindow(LayoutClass):
Activates an inwin object, ensuring its visibility
This function will make sure that the inwin is completely visible
by calling :py:func:`show()` and :py:func:`raise_()` on it, to bring it
to the front. It also sets the keyboard focus to it, which will be passed
This function will make sure that the inwin is completely visible by
calling :py:meth:`~efl.evas.Object.show` and
:py:meth:`~efl.evas.Object.raise_` on it, to bring it to
the front. It also sets the keyboard focus to it, which will be passed
onto its content.
The object's theme will also receive the signal "elm,action,show" with

8
efl/elementary/layout.pyx
View File

@ -68,10 +68,10 @@ Content (SWALLOW part)
Box (BOX part)
An Edje ``BOX`` part is very similar to the Elementary
:py:class:`elementary.box.Box` widget. It allows one to add objects to the
box and have them distributed along its area, accordingly to the specified
``layout`` property (now by ``layout`` we mean the chosen layouting design
of the Box, not the Layout widget itself).
:py:class:`~efl.elementary.box.Box` widget. It allows one to add objects to
the box and have them distributed along its area, accordingly to the
specified ``layout`` property (now by ``layout`` we mean the chosen
layouting design of the Box, not the Layout widget itself).
A similar effect for having a box with its position, size and other things
controlled by the Layout theme would be to create an Elementary

15
efl/elementary/layout_class.pyx
View File

@ -45,10 +45,10 @@ cdef class LayoutClass(Object):
with some more logic on top.
The idea is to make the creation of that widgets as easy as possible,
factorizing code on this common base. For example, a button is a
layout (that looks like push button) that happens to react on
clicks and keyboard events in a special manner, calling its user
back on those events. That's no surprise, then, that the :py:class:`Button`
factorizing code on this common base. For example, a button is a layout
(that looks like push button) that happens to react on clicks and keyboard
events in a special manner, calling its user back on those events. That's no
surprise, then, that the :py:class:`efl.elementary.button.Button`
implementation relies on LayoutClass, if you go to check it.
Container parts, here, map directly to Edje parts from the layout's Edje
@ -64,6 +64,7 @@ cdef class LayoutClass(Object):
Elm_Layout_Part_Alias_Description, where it's explained in detail.
"""
def content_set(self, swallow=None, evasObject content=None):
"""content_set(unicode swallow, Object content)
@ -226,7 +227,7 @@ cdef class LayoutClass(Object):
theme that will be used as layout.
Note that ``style`` will be the new style too, as in setting
:py:attr:`style`.
:py:attr:`~efl.elementary.object.Object.style`.
:type: tuple of strings
:raise RuntimeError: when setting the theme fails
@ -543,7 +544,7 @@ cdef class LayoutClass(Object):
Once the object is inserted, it will become child of the table. Its
lifetime will be bound to the layout, and whenever the layout dies the
child will be deleted automatically. One should use
:py:meth:`table_remove` to make this layout forget about the object.
:py:meth:`table_unpack` to make this layout forget about the object.
If ``colspan`` or ``rowspan`` are bigger than 1, that object will occupy
more space than a single cell.
@ -555,7 +556,7 @@ cdef class LayoutClass(Object):
:param part: the box part to pack child.
:type part: string
:param child_obj: the child object to pack into table.
:type child_obj: :py:class:`efl.evas.Object`
:type child_obj: :py:class:`~efl.evas.Object`
:param col: the column to which the child should be added. (>= 0)
:type col: int
:param row: the row to which the child should be added. (>= 0)

7
efl/elementary/list.pyx
View File

@ -205,10 +205,11 @@ cdef class ListItem(ObjectItem):
:param string label: The label of the list item.
:param icon: The icon object to use for the left side of the item. An
icon can be any Evas object, but usually it is an :py:class:`Icon`.
icon can be any Evas object, but usually it is an
:py:class:`~efl.elementary.icon.Icon`.
:type icon: :py:class:`~efl.evas.Object`
:param end: The icon object to use for the right side of the item. An
icon can be any Evas object.
icon can be any Evas object.
:type end: :py:class:`~efl.evas.Object`
:param callable callback: The function to call when the item is clicked.
:param cb_data: An object associated with the callback.
@ -255,7 +256,7 @@ cdef class ListItem(ObjectItem):
be set as **last** item.
Items created with this method can be deleted with
:py:meth:`~elementary.object_item.ObjectItem.delete`.
:py:meth:`~efl.elementary.object_item.ObjectItem.delete`.
If a function is passed as argument, it will be called every time this item
is selected, i.e., the user clicks over an unselected item.

2
efl/elementary/map.pyx
View File

@ -190,7 +190,7 @@ Map zoom modes
.. data:: ELM_MAP_ZOOM_MODE_MANUAL
Zoom controlled manually by :py:attr:`zoom_set`
Zoom controlled manually by :py:attr:`~Map.zoom`
It's set by default.

6
efl/elementary/notify.pyx
View File

@ -24,9 +24,9 @@ Widget description
Display a container in a particular region of the parent.
A timeout can be set to automatically hide the notify. This is so that,
after an :py:func:`show()` on a notify object, if a timeout was set on it,
it will **automatically** get hidden after that time.
A timeout can be set to automatically hide the notify. This is so that, after an
:py:meth:`~efl.evas.Object.show` on a notify object, if a timeout
was set on it, it will **automatically** get hidden after that time.
Signals that you can add callbacks for are:

6
efl/elementary/object.pyx
View File

@ -1509,7 +1509,9 @@ cdef class Object(evasObject):
def domain_translatable_text_set(self, domain, text):
"""domain_translatable_text_set(unicode domain, unicode text)
Convenience function"""
A convenience function.
"""
if isinstance(domain, unicode): domain = PyUnicode_AsUTF8String(domain)
if isinstance(text, unicode): text = PyUnicode_AsUTF8String(text)
elm_object_domain_translatable_text_set(self.obj,
@ -1578,7 +1580,7 @@ cdef class Object(evasObject):
translatable)
property translatable_text:
# TODO: Document this
"""Translatable text for the main text part of the widget."""
def __get__(self):
return self.translatable_text_get()
def __set__(self, text):

8
efl/elementary/plug.pyx
View File

@ -25,8 +25,8 @@ This widget emits the following signals:
- ``clicked`` - the user clicked the image (press/release).
- ``image,deleted`` - the server side was deleted.
- ``image,resized`` - the server side was resized. The ``event_info`` parameter of
the callback will be ``Evas_Coord_Size`` (two integers).
- ``image,resized`` - the server side was resized. The ``event_info`` parameter
of the callback will be ``Evas_Coord_Size`` (two integers).
.. note::
@ -83,7 +83,7 @@ cdef class Plug(Object):
<const_char *>svcname if svcname is not None else NULL, svcnum, svcsys))
property image_object:
"""Get the basic Evas_Image object from this object (widget).
"""Get the basic Image object from this object (widget).
This function allows one to get the underlying ``Object`` of type
Image from this elementary widget. It can be useful to do things
@ -92,7 +92,7 @@ cdef class Plug(Object):
.. note:: Be careful to not manipulate it, as it is under control of
elementary.
:type: :py:class:`Object`
:type: :py:class:`~efl.evas.Image`
"""
def __get__(self):

4
efl/elementary/popup.pyx
View File

@ -23,7 +23,7 @@
Widget description
------------------
This widget is an enhancement of :py:class:`Notify<efl.elementary.notify.Notify>`.
This widget is an enhancement of :py:class:`~efl.elementary.notify.Notify`.
In addition to Content area, there are two optional sections namely Title
area and Action area.
@ -287,7 +287,7 @@ cdef class Popup(Object):
:param label: The Label of the new item
:type label: string
:param icon: Icon to be set on new item
:type icon: :py:class:`Object`
:type icon: :py:class:`~efl.evas.Object`
:param func: Convenience function called when item selected
:type func: function

2
efl/elementary/radio.pyx
View File

@ -39,7 +39,7 @@ object.
The radio object(s) will select from one of a set of integer values, so
any value they are configuring needs to be mapped to a set of integers.
To configure what value that radio object represents, use
:py:meth:`~Radio.state_value_set` to set the integer it represents. The
:py:attr:`~Radio.state_value` to set the integer it represents. The
value of the whole group (which one is currently selected) is
represented by the property :py:attr:`~Radio.value` on any group member. For
convenience the radio objects are also able to directly set an

28
efl/elementary/slideshow.pyx
View File

@ -271,8 +271,8 @@ cdef class SlideshowItem(ObjectItem):
.. seealso::
:py:class:`SlideshowItemClass`
:py:func:`item_sorted_insert()`
:py:attr:`efl.elementary.object_item.ObjectItem.data`
:py:meth:`sorted_insert`
:py:attr:`~efl.elementary.object_item.ObjectItem.data`
:param item_class: The item class for the item
:type item_class: :py:class:`SlideshowItemClass`
@ -309,7 +309,7 @@ cdef class SlideshowItem(ObjectItem):
.. seealso::
:py:class:`SlideshowItemClass`
:py:func:`item_add()`
:py:meth:`add_to`
:param itc: The item class for the item
:param func: The comparing function to be used to sort slideshow
@ -364,7 +364,7 @@ cdef class SlideshowItem(ObjectItem):
emitting custom signals or hooking lower level callbacks for events
on that object. Do not delete this object under any circumstances.
.. seealso:: :py:attr:`ObjectItem.data`
.. seealso:: :py:attr:`~efl.elementary.object_item.ObjectItem.data`
:type: :py:class:`Slideshow`
@ -573,7 +573,10 @@ cdef class Slideshow(LayoutClass):
This removes (and deletes) all items in the object, leaving it empty.
.. seealso:: :py:func:`ObjectItem.delete()`, to remove just one item.
.. seealso::
:py:meth:`~efl.elementary.object_item.ObjectItem.delete`, to remove
just one item.
"""
elm_slideshow_clear(self.obj)
@ -581,13 +584,16 @@ cdef class Slideshow(LayoutClass):
property items:
"""Get the internal list of items in a given slideshow widget.
This list is **not** to be modified in any way and must not be
freed. Use the list members with functions like
:py:func:`ObjectItem.delete()`, :py:attr:`ObjectItem.data`.
This list is **not** to be modified in any way and must not be freed.
Use the list members with functions like
:py:meth:`~efl.elementary.object_item.ObjectItem.delete`,
:py:attr:`~efl.elementary.object_item.ObjectItem.data`.
.. warning:: This list is only valid until ``obj`` object's internal
items list is changed. It should be fetched again with another
call to this function when changes happen.
.. warning::
This list is only valid until ``obj`` object's internal items list
is changed. It should be fetched again with another call to this
function when changes happen.
:type: tuple of :py:class:`SlideshowItem`

8
efl/elementary/table.pyx
View File

@ -109,7 +109,7 @@ cdef class Table(Object):
takes that 1 cell.
:param subobj: The subobject to be added to the table
:type subobj: :py:class:`evas.object.Object`
:type subobj: :py:class:`~efl.evas.Object`
:param x: Row number
:type x: int
:param y: Column number
@ -128,7 +128,7 @@ cdef class Table(Object):
Remove child from table.
:param subobj: The subobject
:type subobj: :py:class:`evas.object.Object`
:type subobj: :py:class:`~efl.evas.Object`
"""
elm_table_unpack(self.obj, subobj.obj)
@ -170,7 +170,7 @@ def table_pack_set(evasObject subobj, x, y, w, h):
takes that 1 cell.
:param subobj: The subobject to be modified in the table
:type subobj: :py:class:`evas.object.Object`
:type subobj: :py:class:`~efl.evas.Object`
:param x: Row number
:type x: int
:param y: Column number
@ -191,7 +191,7 @@ def table_pack_get(evasObject subobj):
.. seealso:: :py:func:`table_pack_set`
:param subobj: The subobject to be modified in the table
:type subobj: :py:class:`evas.object.Object`
:type subobj: :py:class:`~efl.evas.Object`
:return: Row number, Column number, rowspan, colspan
:rtype: tuple of ints

16
efl/elementary/toolbar.pyx
View File

@ -274,7 +274,7 @@ cdef class ToolbarItem(ObjectItem):
enough. The same should be done for ``data``.
Toolbar will load icon image from fdo or current theme. This
behavior can be set by :py:attr:`icon_order_lookup` function.
behavior can be set by :py:attr:`Toolbar.icon_order_lookup` function.
If an absolute path is provided it will load it direct from a file.
:param icon: A string with icon name or the absolute path of an
@ -446,7 +446,7 @@ cdef class ToolbarItem(ObjectItem):
.. note:: If it is the last item, ``None`` will be returned.
.. seealso:: :py:meth:`Toolbar.item_append`
.. seealso:: :py:meth:`ToolbarItem.append_to`
:type: :py:class:`ToolbarItem`
@ -462,7 +462,7 @@ cdef class ToolbarItem(ObjectItem):
.. note:: If it is the first item, ``None`` will be returned.
.. seealso:: :py:func:`Toolbar.item_prepend`
.. seealso:: :py:func:`ToolbarItem.prepend_to`
:type: :py:class:`ToolbarItem`
@ -555,7 +555,7 @@ cdef class ToolbarItem(ObjectItem):
property object:
"""Get the object of item.
:type: :py:class:`Object`
:type: :py:class:`~efl.evas.Object`
"""
def __get__(self):
@ -846,7 +846,7 @@ cdef class Toolbar(Object):
property first_item:
"""Get the first item in the given toolbar widget's list of items.
.. seealso:: :py:func:`item_append` :py:attr:`last_item`
.. seealso:: :py:func:`ToolbarItem.append_to` :py:attr:`last_item`
:type: :py:class:`ToolbarItem`
@ -860,7 +860,7 @@ cdef class Toolbar(Object):
property last_item:
"""Get the last item in the given toolbar widget's list of items.
.. seealso:: :py:func:`item_prepend` :py:attr:`first_item`
.. seealso:: :py:func:`ToolbarItem.prepend_to` :py:attr:`first_item`
:type: :py:class:`ToolbarItem`
@ -990,9 +990,9 @@ cdef class Toolbar(Object):
Each item can be set as item menu, with :py:attr:`ToolbarItem.menu`.
For more details about setting the parent for toolbar menus, see
:py:attr:`efl.elementary.menu.Menu.parent`.
:py:attr:`~efl.elementary.menu.Menu.parent`.
:type: :py:class:`Object`
:type: :py:class:`~efl.elementary.object.Object`
"""
def __get__(self):

2
efl/elementary/web.pyx
View File

@ -134,7 +134,7 @@ Web zoom modes
.. data:: ELM_WEB_ZOOM_MODE_MANUAL
Zoom controlled normally by :py:attr:`zoom`
Zoom controlled normally by :py:attr:`~Web.zoom`
.. data:: ELM_WEB_ZOOM_MODE_AUTO_FIT

2
efl/emotion/efl.emotion.pyx
View File

@ -580,7 +580,7 @@ cdef class Emotion(evasObject):
that doesn't contain a video channel is loaded, then this size can be
ignored.
The value reported by this function should be consistent with the aspect
ratio returned by :py:func:`ratio_get`, but sometimes the information
ratio returned by :py:attr:`ratio`, but sometimes the information
stored in the file is wrong. So use the ratio size reported by
py:func:`ratio_get()`, since it is more likely going to be accurate.

6
efl/evas/efl.evas_canvas.pxi
View File

@ -81,8 +81,8 @@ cdef class Canvas(Eo):
a number of objects (or actors) that will be managed. Object state
is monitored and redraw is optimized based on changes.
:ivar rect: :py:class:`efl.evas.Rect` describing object geometry, for
easy manipulation. Changing this :py:class:`evas.rect.Rect` will not
:ivar rect: :py:class:`~efl.evas.Rect` describing object geometry, for
easy manipulation. Changing this :py:class:`~efl.evas.Rect` will not
affect current geometry, you have to set it again to have this
behavior.
@ -90,7 +90,7 @@ cdef class Canvas(Eo):
order to be functional. So far it's impossible to do this
association directly from Python, so you should create Canvas
indirectly using ``efl.elementary`` classes, like
:py:class:`efl.elementary.Window`.
:py:class:`efl.elementary.window.Window`.
"""
def __cinit__(self, *a, **ka):

27
efl/evas/efl.evas_object.pxi
View File

@ -108,23 +108,22 @@ cdef _object_del_callback_from_list(Object obj, int type, func):
cdef class Object(Eo):
""" Basic Graphical Object (or actor).
:py:class:`Objects <efl.evas.Object>` are managed by
:py:class:`Canvas <efl.evas.Canvas>` in a non-immediate way, that is,
all operations, like moving, resizing, changing the color, etc will
not trigger immediate repainting, instead it will save the new state
and mark both this object and its Canvas as "dirty" so can be redrawn
on :py:func:`Canvas.render() <efl.evas.Canvas.render>` (usually called by the underlying system, when
you're entering idle. This means that doesn't matter how many times
you're moving an object between frame updates: just the last state
will be used, that's why you really should do animations
using :py:func:`efl.ecore.animator_add` instead of :py:func:`efl.ecore.timer_add`, since
it will call registered functions in one batch and then trigger redraw,
instead of calling one function, then redraw, then the next function,
and redraw...
Objects are managed by :py:class:`Canvas <efl.evas.Canvas>` in a non-
immediate way, that is, all operations, like moving, resizing, changing the
color, etc will not trigger immediate repainting, instead it will save the
new state and mark both this object and its Canvas as "dirty" so can be
redrawn on :py:func:`Canvas.render() <efl.evas.Canvas.render>` (usually
called by the underlying system, when you're entering idle. This means that
doesn't matter how many times you're moving an object between frame updates:
just the last state will be used, that's why you really should do animations
using :py:func:`~efl.ecore.Animator` instead of
:py:class:`~efl.ecore.Timer`, since it will call registered functions in one
batch and then trigger redraw, instead of calling one function, then redraw,
then the next function, and redraw...
The most important concept for evas object is *clipping*
(:py:attr:`clip`), usually done by use of
:py:class:`Rectangle <efl.evas.Rectangle>` as clipper. Clip objects will
:py:class:`~efl.evas.Rectangle` as clipper. Clip objects will
affect the drawing behavior:
- Limiting visibility

40
efl/evas/efl.evas_object_image.pxi
View File

@ -61,19 +61,20 @@ cdef class Image(Object):
other size was set with :py:attr:`load_size`, :py:attr:`load_dpi` or
:py:attr:`load_scale_down`.
Pixels will be scaled to match size specified by :py:attr:`fill`
using either sampled or smooth methods, these can be specified with
Pixels will be scaled to match size specified by :py:attr:`fill` using
either sampled or smooth methods, these can be specified with
:py:attr:`smooth_scale`. The scale will consider borders as specified by
:py:attr:`border` and :py:attr:`border_center_fill`, while the former specify
the border dimensions (top and bottom will scale horizontally, while
:py:attr:`border` and :py:attr:`border_center_fill`, while the former
specify the border dimensions (top and bottom will scale horizontally, while
right and left will do vertically, corners are kept unscaled), the latter
says whenever the center of the image will be used (useful to create
frames).
Contents will be tiled using :py:attr:`fill` information in order to paint
:py:attr:`geometry<Object.geometry>`, so if you want an image to be drawn
just once, you should match every :py:attr:`geometry` = **x, y, w, h** by a call
to :py:attr:`fill` = **0, 0, w, h**. :py:class:`FilledImage` does that for you.
:py:attr:`~efl.evas.Object.geometry`, so if you want an image to be drawn
just once, you should match every :py:attr:`geometry` = **x, y, w, h** by a
call to :py:attr:`fill` = **0, 0, w, h**. :py:class:`FilledImage` does that
for you.
.. rubric:: Pixel data and buffer API
@ -120,8 +121,8 @@ cdef class Image(Object):
R = (r * a) / 32; G = (g * a) / 32; B = (b * a) / 32;
.. note:: if an image is resized it will **tile** it's contents respecting
geometry set by :py:func:`fill_set()`, so if you want the contents to be
**scaled** you need to call :py:func:`fill_set()` with ``x=0, y=0, w=new_width,
geometry set by :py:attr:`fill`, so if you want the contents to be
**scaled** you need to call :py:attr:`fill` with ``x=0, y=0, w=new_width,
h=new_height``, or you should use :py:class:`FilledImage` instead.
:param canvas: Evas canvas for this object
@ -292,7 +293,7 @@ cdef class Image(Object):
:type: bool
.. seealso:: :py:func:`filled_add`
.. seealso:: :py:class:`FilledImage`
"""
def __set__(self, setting):
@ -425,7 +426,7 @@ cdef class Image(Object):
"""Get the row stride (in pixels) being used to draw this image.
While image have logical dimension of width and height set by
:py:func:`image_size_set()`, the line can be a bit larger than width to
:py:attr:`image_size`, the line can be a bit larger than width to
improve memory alignment.
The amount of bytes will change based on colorspace, while using
@ -434,7 +435,7 @@ cdef class Image(Object):
data using stride in multiple of 2 bytes and after that an
alpha plane with data using stride in multiple of 1 byte.
.. note:: This value can change after :py:func:`image_size_set()`.
.. note:: This value can change after setting :py:attr:`image_size`.
.. note:: Unit is pixels, not bytes.
:type: int
@ -1104,10 +1105,11 @@ cdef class Image(Object):
If set to False, the source object of the proxy will be invisible.
This API works differently to :py:func:`show` and :py:func:`hide`.
Once source object is hidden by :py:func:`hide` then the proxy object will
be hidden as well. Actually in this case both objects are excluded from the
Evas internal update circle.
This API works differently to :py:func:`~efl.evas.Object.show` and
:py:func:`~efl.evas.Object.hide`. Once source object is hidden by
:py:func:`~efl.evas.Object.hide` then the proxy object will be hidden as
well. Actually in this case both objects are excluded from the Evas
internal update circle.
By this API, instead, one can toggle the visibility of a proxy's source
object remaining the proxy visibility untouched.
@ -1119,7 +1121,7 @@ cdef class Image(Object):
If the all of proxies are deleted, then the source visibility of the
source object will be cancelled.
.. seealso:: evas_object_image_source_set()
.. seealso:: :py:attr:`source`
:since: 1.8
@ -1346,11 +1348,11 @@ cdef class FilledImage(Image):
Image that automatically resize it's contents to fit object size.
This :py:class:`Image` subclass already calls :py:func:`Image.fill_set`
This :py:class:`Image` subclass already calls :py:attr:`Image.fill`
on resize so it will match and so be scaled to fill the whole area.
:param canvas: The evas canvas for this object
:type canvas: :py:class:`Canvas`
:type canvas: :py:class:`~efl.evas.Canvas`
:keyword size: Width and height
:type size: tuple of ints
:keyword pos: X and Y

8
efl/evas/efl.evas_object_smart.pxi
View File

@ -686,9 +686,9 @@ cdef class SmartObject(Object):
# Factory
def Rectangle(self, **kargs):
"""Factory of children :py:class:`evas.Rectangle`.
"""Factory of children :py:class:`~efl.evas.Rectangle`.
:rtype: :py:class:`Rectangle<evas.Rectangle>`
:rtype: :py:class:`~efl.evas.Rectangle`
"""
obj = Rectangle(self.evas, **kargs)
@ -696,9 +696,9 @@ cdef class SmartObject(Object):
return obj
def Line(self, **kargs):
"""Factory of children :py:class:`evas.Line`.
"""Factory of children :py:class:`~efl.evas.Line`.
:rtype: :py:class:`Line<evas.Line>`
:rtype: :py:class:`~efl.evas.Line`
"""
obj = Line(self.evas, **kargs)

2
efl/evas/efl.evas_object_textblock.pxi
View File

@ -150,7 +150,7 @@ cdef class Textblock(Object):
:type: (int **w**, int **h**)
:see: :py:attr:`size_native_get`
:see: :py:attr:`size_native`
"""
def __get__(self):