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

Documentation: Fix more invalid references.

This commit is contained in:
Kai Huuhko 2013-12-04 01:24:31 +02:00
parent 4c9ab89426
commit 647e0523e4
31 changed files with 194 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
efl/elementary/configuration.pyx
View File

@ -326,8 +326,6 @@ cdef class Configuration(object):
:type: int
:see: elm_config_thumbscroll_flick_distance_tolerance_get()
"""
def __get__(self):
return elm_config_scroll_thumbscroll_flick_distance_tolerance_get()
@ -354,8 +352,6 @@ cdef class Configuration(object):
:type: float
:see: elm_config_thumbscroll_min_friction_get()
"""
def __get__(self):
return elm_config_scroll_thumbscroll_min_friction_get()
@ -371,8 +367,6 @@ cdef class Configuration(object):
:type: float
:see: elm_config_thumbscroll_friction_standard_get()
"""
def __get__(self):
return elm_config_scroll_thumbscroll_friction_standard_get()

8
efl/elementary/fileselector_entry.pyx
View File

@ -26,9 +26,11 @@ Widget description
This is an entry made to be filled with or display a file
system path string.
Besides the entry itself, the widget has a :py:class:`FileselectorButton`
on its side, which will raise an internal :py:class:`Fileselector`,
when clicked, for path selection aided by file system navigation.
Besides the entry itself, the widget has a
:py:class:`~efl.elementary.fileselector_button.FileselectorButton` on its side,
which will raise an internal
:py:class:`~efl.elementary.fileselector.Fileselector`, when clicked, for path
selection aided by file system navigation.
This file selector may appear in an Elementary window or in an
inner window. When a file is chosen from it, the (inner) window

13
efl/elementary/flipselector.pyx
View File

@ -24,10 +24,10 @@ Widget description
.. image:: /images/flipselector-preview.png
:align: left
A flip selector is a widget to show a set of *text* items, one
at a time, with the same sheet switching style as the :py:class:`Clock`
widget, when one changes the current displaying sheet
(thus, the "flip" in the name).
A flip selector is a widget to show a set of *text* items, one at a time, with
the same sheet switching style as the :py:class:`~efl.elementary.clock.Clock`
widget, when one changes the current displaying sheet (thus, the "flip" in the
name).
User clicks to flip sheets which are *held* for some time will
make the flip selector to flip continuously and automatically for
@ -35,11 +35,8 @@ the user. The interval between flips will keep growing in time,
so that it helps the user to reach an item which is distant from
the current selection.
This widget inherits from the :py:class:`Layout` one, so that all the
functions acting on it also work for flip selector objects.
This widget emits the following signals, besides the ones sent from
:py:class:`Layout`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``"selected"`` - when the widget's selected text item is changed
- ``"overflowed"`` - when the widget's current selection is changed

2
efl/elementary/frame.pyx
View File

@ -39,7 +39,7 @@ styles:
Of all this styles only default shows the title.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout.Layout`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``"clicked"`` - The user has clicked the frame's label

6
efl/elementary/gengrid.pyx
View File

@ -25,7 +25,7 @@ Widget description
This widget aims to position objects in a grid layout while actually
creating and rendering only the visible ones, using the same idea as the
:py:class:`efl.elementary.genlist.Genlist`: the user defines a **class** for
:py:class:`~efl.elementary.genlist.Genlist`: the user defines a **class** for
each item, specifying functions that will be called at object creation,
deletion, etc. When those items are selected by the user, a callback
function is issued. Users may interact with a gengrid via the mouse (by
@ -40,7 +40,7 @@ This widget supports the scrollable interface.
If you wish to control the scolling behaviour using these functions,
inherit both the widget class and the
:py:class:`Scrollable<efl.elementary.scroller.Scrollable>` class
:py:class:`~efl.elementary.scroller.Scrollable` class
using multiple inheritance, for example::
class ScrollableGenlist(Genlist, Scrollable):
@ -83,7 +83,7 @@ state parts.
A gengrid item may be at one of several styles. Elementary provides one
by default - "default", but this can be extended by system or
application custom themes/overlays/extensions (see
:py:class:`elementary.theme.Theme` for more details).
:py:class:`~efl.elementary.theme.Theme` for more details).
Gengrid item classes
====================

5
efl/elementary/gengrid_item.pxi
View File

@ -343,13 +343,18 @@ cdef class GengridItem(ObjectItem):
data = (func, self, args, kargs)
Py_INCREF(data)
# FIXME: refleak?
cbdata = <void *>data
elm_gengrid_item_tooltip_content_cb_set(self.item,
_tooltip_item_content_create,
cbdata,
_tooltip_item_data_del_cb)
@DEPRECATED("1.8", "Use tooltip_unset() instead")
def item_tooltip_unset(self):
elm_gengrid_item_tooltip_unset(self.item)
def tooltip_unset(self):
"""item_tooltip_unset()
Unset tooltip from object

8
efl/elementary/gengrid_widget.pxi
View File

@ -172,10 +172,10 @@ cdef class Gengrid(Object):
# XXX TODO elm_gengrid_item_sorted_insert()
property selected_item:
"""This returns the selected item in ``obj``. If multi selection is
enabled on ``obj`` (.. seealso:: :py:func:`multi_select_set()),` only
the first item in the list is selected, which might not be very
useful. For that case, see elm_gengrid_selected_items_get().
"""This returns the selected item. If multi selection is enabled
(:py:attr:`multi_select`), only the first item in the list is selected,
which might not be very useful. For that case, see
:py:attr:`selected_items`.
:type: :py:class:`GengridItem`

4
efl/elementary/genlist.pyx
View File

@ -28,7 +28,7 @@ entries while still being fast and low on memory usage. At the same time
it was also made to be able to do tree structures. But the price to pay
is more complexity when it comes to usage. If all you want is a simple
list with icons and a single text, use the normal
:py:class:`elementary.list.List` object.
:py:class:`~efl.elementary.list.List` object.
Genlist has a fairly large API, mostly because it's relatively complex,
trying to be both expansive, powerful and efficient. First we will begin
@ -228,7 +228,7 @@ This widget supports the scrollable interface.
If you wish to control the scolling behaviour using these functions,
inherit both the widget class and the
:py:class:`Scrollable<efl.elementary.scroller.Scrollable>` class
:py:class:`~efl.elementary.scroller.Scrollable` class
using multiple inheritance, for example::
class ScrollableGenlist(Genlist, Scrollable):

8
efl/elementary/hoversel.pyx
View File

@ -33,7 +33,7 @@ together yourself. It is intended for a small number of items in the
hoversel menu (no more than 8), though is capable of many more.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.button.Button`:
:py:class:`~efl.elementary.button.Button`:
- ``"clicked"`` - the user clicked the hoversel button and popped up
the sel
@ -106,7 +106,7 @@ cdef class HoverselItem(ObjectItem):
icon_type = ELM_ICON_NONE, callback = None, cb_data = None,
*args, **kargs):
"""For more information on what ``icon_file`` and ``icon_type`` are,
see :py:class:`elementary.icon.Icon`.
see :py:class:`~efl.elementary.icon.Icon`.
:param label: The text label to use for the item (None if not desired)
:type label: string
@ -147,7 +147,7 @@ cdef class HoverselItem(ObjectItem):
use :py:attr:`HoverselItem.icon` right after this function.
:return: The item added.
:rtype: Elm_Object_Item
:rtype: HoverselItem
"""
cdef Evas_Smart_Cb cb = NULL
@ -327,7 +327,7 @@ cdef class Hoversel(Button):
.. seealso:: :py:func:`HoverselItem.add()`
:type: tuple of Elm_Object_Items
:type: tuple of :py:class:`HoverselItem`'s
"""
def __get__(self):

8
efl/elementary/icon.pyx
View File

@ -93,8 +93,8 @@ And these are names for some media player specific icons:
This widget emits the following signals, besides the ones sent from
:py:class:`~efl.elementary.image.Image`:
- ``"thumb,done"`` - Setting :py:attr:`thumb` has completed with success
- ``"thumb,error"`` - Setting :py:attr:`thumb` has failed
- ``"thumb,done"`` - Setting :py:attr:`~Icon.thumb` has completed with success
- ``"thumb,error"`` - Setting :py:attr:`~Icon.thumb` has failed
Enumerations
@ -170,14 +170,12 @@ cdef class Icon(Image):
"""Set the file (and edje group) that will be used, but use a
generated thumbnail.
This functions like :py:attr:`elementary.image.Image.file` but
This functions like :py:attr:`~efl.elementary.image.Image.file` but
requires the Ethumb library support to be enabled successfully with
:py:func:`efl.elementary.need.need_ethumb`. When set the file indicated
has a thumbnail generated and cached on disk for future use or will
directly use an existing cached thumbnail if it is valid.
.. seealso:: :py:attr:`~efl.elementary.image.Image.file`
:type: string ``file`` or tuple(string ``file``, string ``group``)
"""

4
efl/elementary/image.pyx
View File

@ -39,7 +39,7 @@ One can tune various properties of the image, like:
- aspect ratio during resizes, etc.
An image object may also be made valid source and destination for drag
and drop actions by setting :py:attr:`editable`.
and drop actions by setting :py:attr:`~Image.editable`.
Signals that you can add callbacks for are:
@ -143,7 +143,7 @@ class ImageErrorInfo(object):
by Image when fail to download remote urls.
:var status: The http error code (such as 401)
:var open_error: TODOC
:var open_error: TODO
"""
def __init__(self):

13
efl/elementary/index.pyx
View File

@ -34,14 +34,15 @@ user clicks over it's reserved area in the canvas. In its
default theme, it's an area one ``finger`` wide on
the right side of the index widget's container.
When items on the index are selected, smart callbacks get
called, so that its user can make other container objects to
show a given area or child object depending on the index item
selected. You'd probably be using an index together with :py:class:`List`,
:py:class:`Genlist` or :py:class:`Gengrid`.
When items on the index are selected, smart callbacks get called, so that its
user can make other container objects to show a given area or child object
depending on the index item selected. You'd probably be using an index together
with :py:class:`~efl.elementary.list.List`,
:py:class:`~efl.elementary.genlist.Genlist` or
:py:class:`~efl.elementary.gengrid.Gengrid`.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout.Layout`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``"changed"`` - When the selected index item changes. ``event_info``
is the selected item's data pointer.

2
efl/elementary/label.pyx
View File

@ -45,7 +45,7 @@ Custom themes can of course invent new markup tags and style them any way
they like.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout.Layout`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``language,changed`` - The program's language changed.
- ``slide,end`` - The slide is end.

58
efl/elementary/list.pyx
View File

@ -29,7 +29,7 @@ The list can accept only one or multiple items selection. Also has many
modes of items displaying.
A list is a very simple type of list widget. For more robust
lists, :py:class:`genlist.Genlist` should probably be used.
lists, :py:class:`~efl.elementary.genlist.Genlist` should probably be used.
Smart callbacks one can listen to:
@ -77,7 +77,7 @@ This widget supports the scrollable interface.
If you wish to control the scolling behaviour using these functions,
inherit both the widget class and the
:py:class:`Scrollable<efl.elementary.scroller.Scrollable>` class
:py:class:`~efl.elementary.scroller.Scrollable` class
using multiple inheritance, for example::
class ScrollableGenlist(Genlist, Scrollable):
@ -206,10 +206,10 @@ 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`.
:type icon: :py:class:`evas.object.Object`
: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.
:type end: :py:class:`evas.object.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 +255,7 @@ cdef class ListItem(ObjectItem):
be set as **last** item.
Items created with this method can be deleted with
:py:func:`elementary.object_item.ObjectItem.delete()`.
:py:meth:`~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.
@ -274,9 +274,9 @@ cdef class ListItem(ObjectItem):
.. seealso::
:py:attr:`List.select_mode`
:py:func:`efl.elementary.object_item.ObjectItem.delete()`
:py:meth:`~efl.elementary.object_item.ObjectItem.delete`
:py:func:`List.clear()`
:py:class:`Icon <efl.elementary.icon.Icon>`
:py:class:`~efl.elementary.icon.Icon`
:return: The created item or ``None`` upon failure.
:rtype: :py:class:`ListItem`
@ -306,11 +306,11 @@ cdef class ListItem(ObjectItem):
Prepend a new item to the list object.
.. seealso::
:py:func:`append_to()`
:py:meth:`append_to`
:py:attr:`List.select_mode`
:py:func:`efl.elementary.object_item.ObjectItem.delete()`
:py:func:`List.clear()`
:py:class:`Icon <efl.elementary.icon.Icon>`
:py:meth:`efl.elementary.object_item.ObjectItem.delete`
:py:meth:`List.clear`
:py:class:`~efl.elementary.icon.Icon`
:param list: The list
:type list: List
@ -343,11 +343,11 @@ cdef class ListItem(ObjectItem):
Insert a new item into the list object before item *before*.
.. seealso::
:py:func:`append_to()`
:py:meth:`append_to`
:py:attr:`List.select_mode`
:py:func:`efl.elementary.object_item.ObjectItem.delete()`
:py:func:`List.clear()`
:py:class:`Icon <efl.elementary.icon.Icon>`
:py:meth:`efl.elementary.object_item.ObjectItem.delete`
:py:meth:`List.clear`
:py:class:`~efl.elementary.icon.Icon`
:param before: The list item to insert before.
:type before: :py:class:`ListItem`
@ -382,11 +382,11 @@ cdef class ListItem(ObjectItem):
Insert a new item into the list object after item *after*.
.. seealso::
:py:func:`append_to()`
:py:meth:`append_to`
:py:attr:`List.select_mode`
:py:func:`efl.elementary.object_item.ObjectItem.delete()`
:py:func:`List.clear()`
:py:class:`Icon <efl.elementary.icon.Icon>`
:py:meth:`efl.elementary.object_item.ObjectItem.delete`
:py:meth:`List.clear`
:py:class:`~efl.elementary.icon.Icon`
:param after: The list item to insert after.
:type after: :py:class:`ListItem`
@ -516,7 +516,7 @@ cdef class ListItem(ObjectItem):
Show the item in the list view.
It won't animate list until item is visible. If such behavior is
wanted, use :py:func:`bring_in()` instead.
wanted, use :py:meth:`bring_in` instead.
"""
elm_list_item_show(self.item)
@ -531,7 +531,7 @@ cdef class ListItem(ObjectItem):
This may use animation to do so and take a period of time.
If animation isn't wanted, :py:func:`show()` can be used.
If animation isn't wanted, :py:meth:`show` can be used.
"""
elm_list_item_bring_in(self.item)
@ -544,7 +544,7 @@ cdef class ListItem(ObjectItem):
behavior (like deleting the base!), but it might be used to
feed Edje signals to add more features to row representation.
:type: :py:class:`edje.Edje`
:type: :py:class:`efl.edje.Edje`
"""
def __get__(self):
@ -559,7 +559,7 @@ cdef class ListItem(ObjectItem):
.. note:: If the item is the first item, ``None`` will be returned.
.. seealso::
:py:func:`append_to()`
:py:meth:`append_to`
:py:attr:`List.items`
:type: :py:class:`ListItem`
@ -615,7 +615,7 @@ cdef class List(Object):
li.go()
li.show()
.. note:: Call before running :py:func:`show() <efl.evas.Object.show>` on the list object.
.. note:: Call before running :py:meth:`~efl.evas.Object.show` on the list object.
.. warning:: If not called, it won't display the list properly.
"""
@ -835,8 +835,8 @@ cdef class List(Object):
Remove all list's items.
.. seealso::
:py:func:`efl.elementary.object_item.ObjectItem.delete`
:py:func:`ListItem.append_to`
:py:meth:`~efl.elementary.object_item.ObjectItem.delete`
:py:meth:`ListItem.append_to`
"""
elm_list_clear(self.obj)
@ -845,9 +845,9 @@ cdef class List(Object):
"""Get a list of all the list items.
.. seealso::
:py:func:`ListItem.append_to()`
:py:func:`efl.elementary.object_item.ObjectItem.delete`
:py:func:`clear()`
:py:meth:`ListItem.append_to`
:py:meth:`~efl.elementary.object_item.ObjectItem.delete`
:py:meth:`clear`
:type: tuple of :py:class:`List items <ListItem>`

18
efl/elementary/menu.pyx
View File

@ -78,6 +78,7 @@ cdef class MenuItem(ObjectItem):
self.kwargs = kargs
def add_to(self, Menu menu not None):
# TODO: document this
cdef Elm_Object_Item *item, *parent_obj = NULL
cdef Evas_Smart_Cb cb = NULL
@ -224,11 +225,14 @@ cdef class MenuItem(ObjectItem):
cdef class MenuSeparatorItem(ObjectItem):
"""A separator type menu item."""
cdef MenuItem parent
def __init__(self, MenuItem parent):
self.parent = parent
def add_to(self, Menu menu not None):
# TODO: document this
cdef Elm_Object_Item *item
if self.cb_func is not None:
@ -246,8 +250,6 @@ cdef class MenuSeparatorItem(ObjectItem):
property is_separator:
"""Returns whether the item is a separator.
.. seealso:: :py:func:`Menu.item_separator_add()`
:type: bool
"""
@ -301,7 +303,7 @@ cdef class Menu(Object):
property parent:
"""The parent for the given menu widget.
:type: :py:class:`Object`
:type: :py:class:`~efl.elementary.object.Object`
"""
def __get__(self):
@ -340,9 +342,9 @@ cdef class Menu(Object):
elm_menu_close(self.obj)
property items:
"""Returns a list of ``item``'s items.
"""Returns a list of ``item``'s.
:type: tuple of :py:class:`Object`
:type: tuple of :py:class:`MenuItem`
"""
def __get__(self):
@ -358,7 +360,7 @@ cdef class Menu(Object):
Add an item at the end of the given menu widget
:param parent: The parent menu item (optional)
:type parent: :py:class:`Object`
:type parent: :py:class:`~efl.elementary.object.Object`
:param string icon: An icon display on the item. The icon will be destroyed
by the menu.
:param string label: The label of the item.
@ -401,10 +403,10 @@ cdef class Menu(Object):
Add a separator item to menu under ``parent``.
This item is a :py:class:`Separator`.
This item is a :py:class:`~efl.elementary.separator.Separator`.
:param parent: The item to add the separator under
:type parent: :py:class:`Object`
:type parent: :py:class:`~efl.elementary.object.Object`
:return: The created item or None on failure
:rtype: :py:class:`MenuSeparatorItem`

24
efl/elementary/naviframe.pyx
View File

@ -60,7 +60,7 @@ on:
current page
Most of those content objects can be passed at the time of an item
creation (see :py:meth:`~Naviframe.item_push`).
creation (see :py:meth:`~NaviframeItem.push_to`).
Naviframe items can have different styles, which affect the
transition between views, for example. On the default theme, two of
@ -84,12 +84,13 @@ This widget emits the following signals, besides the ones sent from
All the parts, for content and text, described here will also be
reachable by naviframe **items** direct calls:
- :py:func:`part_text_set()`
- :py:func:`part_text_get()`
- :py:func:`part_content_set()`
- :py:func:`part_content_get()`
- :py:func:`part_content_unset()`
- :py:func:`signal_emit()`
- :py:meth:`~efl.elementary.object_item.ObjectItem.delete`
- :py:meth:`~efl.elementary.object_item.ObjectItem.part_text_set`
- :py:meth:`~efl.elementary.object_item.ObjectItem.part_text_get`
- :py:meth:`~efl.elementary.object_item.ObjectItem.part_content_set`
- :py:meth:`~efl.elementary.object_item.ObjectItem.part_content_get`
- :py:meth:`~efl.elementary.object_item.ObjectItem.part_content_unset`
- :py:meth:`~efl.elementary.object_item.ObjectItem.signal_emit`
What happens is that the topmost item of a naviframe will be the
widget's target layout, when accessed directly. Items lying below
@ -371,7 +372,7 @@ cdef class Naviframe(LayoutClass):
:return: ``None`` or the content object(if
:py:attr:`content_preserve_on_pop` is True).
:rtype: :py:class:`evas.object.Object`
:rtype: :py:class:`~efl.evas.Object`
"""
return object_from_instance(elm_naviframe_item_pop(self.obj))
@ -453,12 +454,11 @@ cdef class Naviframe(LayoutClass):
If is True, the contents of the naviframe item will receives events
from mouse and keyboard during view changing such as item push/pop.
.. warning:: Events will be blocked by
calling :py:func:`freeze_events_set()` internally.
.. warning::
Events will be blocked by setting
:py:attr:`~efl.evas.Object.freeze_events` internally.
So don't call the API while pushing/popping items.
.. seealso:: :py:attr:`evas.object.Object.freeze_events`
:type: bool
"""

19
efl/elementary/notify.pyx
View File

@ -95,7 +95,7 @@ cdef class Notify(Object):
Once the parent object is set, a previously set one will be disconnected
and replaced.
:type: :py:class:`Object`
:type: :py:class:`~efl.elementary.object.Object`
"""
def __get__(self):
@ -113,11 +113,11 @@ cdef class Notify(Object):
"""The time interval after which the notify window is going to be
hidden.
Setting this starts the timer controlling when the
notify is hidden. Since calling :py:func:`show()` on a notify restarts
the timer controlling when the notify is hidden, setting this before the
notify is shown will in effect mean starting the timer when the notify is
shown.
Setting this starts the timer controlling when the notify is hidden.
Since calling :py:meth:`efl.evas.Object.show` on a notify restarts the
timer controlling when the notify is hidden, setting this before the
notify is shown will in effect mean starting the timer when the notify
is shown.
.. note:: Set a value <= 0.0 to disable a running timer.
@ -141,8 +141,8 @@ cdef class Notify(Object):
property allow_events:
"""Whether events should be passed to by a click outside its area.
When True if the user clicks outside the window the events will be caught
by the others widgets, else the events are blocked.
When True if the user clicks outside the window the events will be
caught by the others widgets, else the events are blocked.
.. note:: The default value is True.
@ -169,7 +169,8 @@ cdef class Notify(Object):
Sets the alignment in which the notify will appear in its parent.
.. note:: To fill the notify box in the parent area, please pass
:ref:`ELM_NOTIFY_ALIGN_FILL <ELM_NOTIFY_ALIGN_FILL>` to ``horizontal``, ``vertical``.
:ref:`ELM_NOTIFY_ALIGN_FILL` to
``horizontal``, ``vertical``.
:since: 1.8

4
efl/elementary/object.pyx
View File

@ -1172,7 +1172,7 @@ cdef class Object(evasObject):
property mirrored_automatic:
"""The widget's mirrored mode setting. When widget in automatic
mode, it follows the system mirrored mode set by
:py:attr:`efl.elementary.configuration.mirrored`.
:py:attr:`efl.elementary.configuration.Configuration.mirrored`.
:type: bool
@ -1322,7 +1322,7 @@ cdef class Object(evasObject):
configuration difficult. Avoid any custom themes at all if it can be
helped.
:type: :py:class:`Theme`
:type: :py:class:`~efl.elementary.theme.Theme`
"""
def __set__(self, Theme th):

6
efl/elementary/object_item.pyx
View File

@ -172,7 +172,7 @@ cdef class ObjectItem(object):
.. note:: This returns the widget object itself that an item belongs to.
.. note:: Every elm_object_item supports this API
:type: :py:class:`elementary.object.Object`
:type: :py:class:`~efl.elementary.object.Object`
"""
def __get__(self):
@ -212,7 +212,7 @@ cdef class ObjectItem(object):
content)
:type part: string
:return: content of the object item or None for any error
:rtype: :py:class:`evas.object.Object`
:rtype: :py:class:`~efl.evas.Object`
"""
if isinstance(part, unicode): part = PyUnicode_AsUTF8String(part)
@ -359,7 +359,7 @@ cdef class ObjectItem(object):
:see: :py:func:`domain_translatable_part_text_set`
:see: :py:func:`part_text_set`
:see: :py:func:`efl.elementary.general.policy`
:see: :py:func:`efl.elementary.general.policy_set`
:since: 1.8

2
efl/elementary/panes.pyx
View File

@ -30,7 +30,7 @@ Panes can be displayed vertically or horizontally, and contents size
proportion can be customized (homogeneous by default).
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout.Layout`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``"press"`` - The panes has been pressed (button wasn't released yet).
- ``"unpressed"`` - The panes was released after being pressed.

6
efl/elementary/photo.pyx
View File

@ -28,9 +28,9 @@ ex., a person's image (contact).
Simple, yet with a very specific purpose. It has a decorative frame
around the inner image itself, on the default theme.
This widget relies on an internal :py:class:`Icon`, so that the APIs of
these two widgets are similar (drag and drop is also possible here, for
example).
This widget relies on an internal :py:class:`~efl.elementary.icon.Icon`, so that
the APIs of these two widgets are similar (drag and drop is also possible here,
for example).
Signals that you can add callbacks for are:

25
efl/elementary/photocam.pyx
View File

@ -64,7 +64,7 @@ This widget supports the scrollable interface.
If you wish to control the scolling behaviour using these functions,
inherit both the widget class and the
:py:class:`Scrollable<efl.elementary.scroller.Scrollable>` class
:py:class:`~efl.elementary.scroller.Scrollable` class
using multiple inheritance, for example::
class ScrollableGenlist(Genlist, Scrollable):
@ -81,7 +81,7 @@ Photocam zoom modes
.. data:: ELM_PHOTOCAM_ZOOM_MODE_MANUAL
Zoom controlled normally by :py:attr:`zoom`
Zoom controlled normally by :py:attr:`~Photocam.zoom`
.. data:: ELM_PHOTOCAM_ZOOM_MODE_AUTO_FIT
@ -184,17 +184,24 @@ cdef class Photocam(Object):
:raise RuntimeError: when setting the file fails
"""
def __set__(self, file):
if isinstance(file, unicode): file = PyUnicode_AsUTF8String(file)
def __set__(self, filename):
# TODO: Return EvasLoadError
if isinstance(filename, unicode):
filename = PyUnicode_AsUTF8String(filename)
if elm_photocam_file_set(self.obj,
<const_char *>file if file is not None else NULL) != 0:
<const_char *>filename if filename is not None else NULL) != 0:
raise RuntimeError("Could not set file")
def __get__(self):
return _ctouni(elm_photocam_file_get(self.obj))
def file_set(self, file):
self.file = file
def file_set(self, filename):
# TODO: Return EvasLoadError
if isinstance(filename, unicode):
filename = PyUnicode_AsUTF8String(filename)
if elm_photocam_file_set(self.obj,
<const_char *>filename if filename is not None else NULL) != 0:
raise RuntimeError("Could not set file")
def file_get(self):
return _ctouni(elm_photocam_file_get(self.obj))
@ -286,7 +293,7 @@ cdef class Photocam(Object):
elm_photocam_image_region_get(self.obj, &x, &y, &w, &h)
return (x, y, w, h)
def image_region_show(self, x, y, w, h):
def image_region_show(self, int x, int y, int w, int h):
"""image_region_show(int x, int y, int w, int h)
Set the viewed region of the image
@ -305,7 +312,7 @@ cdef class Photocam(Object):
"""
elm_photocam_image_region_show(self.obj, x, y, w, h)
def image_region_bring_in(self, x, y, w, h):
def image_region_bring_in(self, int x, int y, int w, int h):
"""image_region_bring_in(int x, int y, int w, int h)
Bring in the viewed portion of the image

12
efl/elementary/progressbar.pyx
View File

@ -39,14 +39,14 @@ A progress bar may be **inverted**, in which case it gets its values
inverted, i.e., high values being on the left or top and low values on
the right or bottom, for horizontal and vertical modes respectively.
The **span** of the progress, as set by :py:attr:`span_size`, is its length
(horizontally or vertically), unless one puts size hints on the widget
to expand on desired directions, by any container. That length will be
scaled by the object or applications scaling factor. Applications can
query the progress bar for its value with :py:attr:`value`.
The **span** of the progress, as set by :py:attr:`~Progressbar.span_size`, is
its length (horizontally or vertically), unless one puts size hints on the
widget to expand on desired directions, by any container. That length will be
scaled by the object or applications scaling factor. Applications can query the
progress bar for its value with :py:attr:`~Progressbar.value`.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout.Layout`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``changed`` - when the value is changed
- ``focused`` - When the progressbar has received focus. (since 1.8)

16
efl/elementary/radio.pyx
View File

@ -33,23 +33,20 @@ are normally used in groups of two or more.
Radio objects are grouped in a slightly different, compared to other UI
toolkits. There is no seperate group name/id to remember or manage. The
members represent the group, there are the group. To make a group, use
:py:func:`group_add()` and pass existing radio object and the new radio
:py:meth:`Radio.group_add` and pass existing radio object and the new radio
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
elm_radio_state_value_set() to set the integer it represents. The
:py:meth:`~Radio.state_value_set` to set the integer it represents. The
value of the whole group (which one is currently selected) is
represented by the property :py:attr:`value` on any group member. For
represented by the property :py:attr:`~Radio.value` on any group member. For
convenience the radio objects are also able to directly set an
integer(int) to the value that is selected. To specify the pointer to
this integer to modify, use :py:attr:`value_pointer`. The radio objects
will modify this directly. That implies the pointer must point to valid
memory for as long as the radio objects exist.
integer(int) to the value that is selected.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout_class.LayoutClass`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``changed`` - This is called whenever the user changes the state of one of
the radio objects within the group of radio objects that work together.
@ -67,6 +64,7 @@ Default content parts of the radio widget that you can use for are:
"""
from efl.eo cimport _object_mapping_register, object_from_instance
from efl.utils.deprecated cimport DEPRECATED
from efl.evas cimport Object as evasObject
from layout_class cimport LayoutClass
@ -131,7 +129,7 @@ cdef class Radio(LayoutClass):
def value_get(self):
return elm_radio_value_get(self.obj)
#TODO: Check whether this actually works
@DEPRECATED("1.8", "Don't use this, only works in C.")
def value_pointer_set(self, int value):
"""value_pointer_set(value)

71
efl/elementary/segment_control.pyx
View File

@ -33,7 +33,7 @@ item can display combination of Text and any Evas_Object like Images or
other widget.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout.Layout`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``"changed"`` - When the user clicks on a segment item which is not
previously selected and get selected. The event_info parameter is the
@ -128,10 +128,11 @@ cdef class SegmentControl(LayoutClass):
i.e., will be set as **last** item.
If it should be inserted at another position,
elm_segment_control_item_insert_at() should be used instead.
:py:meth:`item_insert_at` should be used instead.
Items created with this function can be deleted with function
:py:func:`ObjectItem.delete()` or :py:func:`item_del_at()`.
:py:meth:`efl.elementary.object_item.ObjectItem.delete` or
:py:meth:`item_del_at`.
Simple example::
@ -147,14 +148,10 @@ cdef class SegmentControl(LayoutClass):
centered. If it has icon and label, even that an empty string,
icon will be smaller and positioned at left.
.. seealso::
:py:func:`SegmentControl.item_insert_at()`
:py:func:`ObjectItem.delete()`
: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 icon created
with elm_icon_add().
:type icon: :py:class:`Object`
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 label: The label of the item. Note that, None is different
from empty string "".
:type label: string
@ -182,11 +179,12 @@ cdef class SegmentControl(LayoutClass):
Index values must be between ``0``, when item will be prepended to
segment control, and items count, that can be get with
elm_segment_control_item_count_get(), case when item will be appended
to segment control, just like elm_segment_control_item_add().
:py:attr:`item_count`, case when item will be appended
to segment control, just like :py:meth:`item_add`.
Items created with this function can be deleted with function
elm_object_item_del() or elm_segment_control_item_del_at().
:py:meth:`~efl.elementary.object_item.ObjectItem.delete` or
:py:meth:`item_del_at`.
.. note:: ``label`` set to ``None`` is different from empty string "".
If an item only has icon, it will be displayed bigger and
@ -194,14 +192,14 @@ cdef class SegmentControl(LayoutClass):
icon will be smaller and positioned at left.
.. seealso::
:py:func:`SegmentControl.item_add()`
:py:func:`SegmentControl.item_count_get()`
:py:func:`ObjectItem.delete()`
:py:meth:`item_add`
:py:attr:`item_count`
:py:meth:`efl.elementary.object_item.ObjectItem.delete`
: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 icon created
with elm_icon_add().
:type icon: :py:class:`Object`
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 label: The label of the item.
:type label: string
:param index: Item position. Value should be between 0 and items count.
@ -229,8 +227,8 @@ cdef class SegmentControl(LayoutClass):
Remove a segment control item at given index from its parent,
deleting it.
Items can be added with elm_segment_control_item_add() or
elm_segment_control_item_insert_at().
Items can be added with :py:meth:`item_add` or
:py:meth:`item_insert_at`.
:param index: The position of the segment control item to be deleted.
:type index: int
@ -257,7 +255,7 @@ cdef class SegmentControl(LayoutClass):
Index is the position of an item in segment control widget. Its
range is from ``0`` to <tt> count - 1 </tt>.
Count is the number of items, that can be get with
elm_segment_control_item_count_get().
:py:attr:`item_count`.
:param index: The index of the segment item.
:type index: int
@ -273,13 +271,9 @@ cdef class SegmentControl(LayoutClass):
Get the label of item.
The return value is a pointer to the label associated to the item when
it was created, with function elm_segment_control_item_add(), or later
with function elm_object_item_text_set. If no label
was passed as argument, it will return ``None``.
.. seealso::
:py:func:`ObjectItem.text_set()` for more details.
:py:func:`SegmentControl.item_add()`
it was created, with function :py:meth:`item_add`, or later with
function :py:attr:`~efl.elementary.object_item.ObjectItem.text`. If no
label was passed as argument, it will return ``None``.
:param index: The index of the segment item.
:type index: int
@ -294,28 +288,21 @@ cdef class SegmentControl(LayoutClass):
Get the icon associated to the item.
The return value is a pointer to the icon associated to the item when
it was created, with function elm_segment_control_item_add(), or later
with function elm_object_item_part_content_set(). If no icon
was passed as argument, it will return ``None``.
.. seealso::
:py:func:`SegmentControl.item_add()`
:py:func:`ObjectItem.part_content_set()`
The return value is a pointer to the icon associated to the item when it
was created, with function :py:meth:`item_add`, or later with function
:py:meth:`~efl.elementary.object_item.ObjectItem.part_content_set`. If
no icon was passed as argument, it will return ``None``.
:param index: The index of the segment item.
:type index: int
:return: The left side icon associated to the item at ``index``.
:rtype: :py:class:`Object`
:rtype: :py:class:`~efl.evas.Object`
"""
return object_from_instance(elm_segment_control_item_icon_get(self.obj, index))
property item_selected:
"""Get the selected item.
The selected item can be unselected with function
elm_segment_control_item_selected_set().
"""The selected item.
The selected item always will be highlighted on segment control.

2
efl/elementary/separator.pyx
View File

@ -28,7 +28,7 @@ Separator is a very thin object used to separate other objects.
A separator can be vertical or horizontal.
This widget emits the signals coming from
:py:class:`elementary.layout_class.LayoutClass`.
:py:class:`~efl.elementary.layout_class.LayoutClass`.
"""

6
efl/elementary/slider.pyx
View File

@ -44,7 +44,7 @@ the object or applications scaling factor. At any point code can query the
slider for its value with :py:attr:`Slider.value`.
This widget emits the following signals, besides the ones sent from
:py:class:`LayoutClass <efl.elementary.layout_class.LayoutClass>`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``changed`` - Whenever the slider value is changed by the user.
- ``slider,drag,start`` - dragging the slider indicator around has
@ -282,8 +282,8 @@ cdef class Slider(LayoutClass):
"""The value displayed in the slider.
Value will be presented on the unit label following format specified
with :py:attr:`unit_format_set()` and on indicator with
:py:attr:`indicator_format_set()`.
with :py:attr:`unit_format` and on indicator with
:py:attr:`indicator_format`.
.. warning:: The value must to be between min and max values. These
values are set by :py:attr:`min_max`.

10
efl/elementary/slideshow.pyx
View File

@ -39,9 +39,9 @@ update the widget's code.
Slideshow items
===============
For slideshow items, just like for :py:class:`Genlist` "genlist" ones,
the user defines a **classes**, specifying functions that will be
called on the item's creation and deletion times.
For slideshow items, just like for :py:class:`~efl.elementary.genlist.Genlist`
ones, the user defines a **classes**, specifying functions that will be called
on the item's creation and deletion times.
The :py:class:`SlideshowItemClass` class contains the following
members:
@ -49,7 +49,7 @@ members:
- ``get`` - When an item is displayed, this function is
called, and it's where one should create the item object, de
facto. For example, the object can be a pure Evas image object
or an Elementary :py:class:`Photocam` "photocam" widget.
or a :py:class:`~efl.elementary.photocam.Photocam` widget.
- ``delete`` - When an item is no more displayed, this function
is called, where the user must delete any data associated to
@ -67,7 +67,7 @@ cached **before** and **after** the current item, in the widget's
item list.
This widget emits the following signals, besides the ones sent from
:py:class:`elementary.layout.Layout`:
:py:class:`efl.elementary.layout_class.LayoutClass`:
- ``"changed"`` - when the slideshow switches its view to a new item.
event_info parameter in callback contains the current visible item

17
efl/elementary/toolbar.pyx
View File

@ -572,7 +572,7 @@ cdef class ToolbarItem(ObjectItem):
:py:attr:`icon_file`, or
:py:attr:`icon_memfile` for details.
:type: :py:class:`Icon`
:type: :py:class:`~efl.elementary.icon.Icon`
"""
def __get__(self):
@ -662,8 +662,8 @@ cdef class ToolbarItem(ObjectItem):
sets it to be that.
Once it is set to be a menu, it can be manipulated through
:py:attr:`Toolbar.menu_parent` and the :py:class:`Menu` functions
and properties.
:py:attr:`Toolbar.menu_parent` and the
:py:class:`~efl.elementary.menu.Menu` functions and properties.
So, items to be displayed in this item's menu should be added with
:py:func:`efl.elementary.menu.Menu.item_add()`.
@ -907,8 +907,9 @@ cdef class Toolbar(Object):
property more_item:
"""Get the more item.
The more item can be changed with function
:py:attr:`ObjectItem.text` and :py:attr:`ObjectItem.content`.
The more item can be changed with
:py:attr:`~efl.elementary.object_item.ObjectItem.text` and
:py:attr:`~efl.elementary.object_item.ObjectItem.content`.
:type: :py:class:`ToolbarItem`
@ -989,11 +990,7 @@ 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:`Menu.parent`.
.. seealso::
:py:attr:`Menu.parent` and
:py:attr:`ToolbarItem.menu` for details.
:py:attr:`efl.elementary.menu.Menu.parent`.
:type: :py:class:`Object`

4
efl/elementary/video.pyx
View File

@ -28,7 +28,7 @@ animation depending on the video state change. It also implements a
resource management policy to remove this burden from the application.
These widgets emit the following signals, besides the ones sent from
:py:class:`efl.elementary.layout_class.LayoutClass`:
:py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``focused`` - When the widget has received focus. (since 1.8)
- ``unfocused`` - When the widget has lost focus. (since 1.8)
@ -269,7 +269,7 @@ cdef class Player(LayoutClass):
activates the "remember" function on the linked :py:class:`Video` object.
The player widget emits the following signals, besides the ones
sent from :py:class:`elementary.layout.Layout`:
sent from :py:class:`~efl.elementary.layout_class.LayoutClass`:
- ``"forward,clicked"`` - the user clicked the forward button.
- ``"info,clicked"`` - the user clicked the info button.

12
efl/elementary/window.pyx
View File

@ -86,7 +86,7 @@ fixed to "out001.png" Some examples of using the shot engine::
Signals that you can add callbacks for are:
- "delete,request": the user requested to close the window. See
:py:attr:`autodel <Window.autodel>`.
:py:attr:`~Window.autodel`.
- "focus,in": window got focus
- "focus,out": window lost focus
- "moved": window that holds the canvas was moved
@ -156,7 +156,7 @@ Window types
The window is a dropdown menu, as when an entry in a menubar is clicked.
Typically used with :py:attr:`override`. This hint exists for
Typically used with :py:attr:`~Window.override`. This hint exists for
completion only, as the EFL way of implementing a menu would not
normally use a separate window for its contents.
@ -171,7 +171,7 @@ Window types
A short piece of explanatory text that typically appear after the mouse
cursor hovers over an object for a while. Typically used with
:py:attr:`override` and also not very commonly used in the EFL.
:py:attr:`~Window.override` and also not very commonly used in the EFL.
.. data:: ELM_WIN_NOTIFICATION
@ -189,7 +189,7 @@ Window types
Used to indicate the window is a representation of an object being
dragged across different windows, or even applications.
Typically used with :py:attr:`override`.
Typically used with :py:attr:`~Window.override`.
.. data:: ELM_WIN_INLINED_IMAGE
@ -452,7 +452,7 @@ cdef class Window(Object):
For the end user to be able to resize a window by dragging the handles
or borders provided by the Window Manager, or using any other similar
mechanism, all of the resize objects in the window should have their
:py:attr:`size_hint_weight` set to EVAS_HINT_EXPAND.
:py:attr:`~efl.evas.Object.size_hint_weight` set to EVAS_HINT_EXPAND.
Also notice that the window can get resized to the current size of the
object if the EVAS_HINT_EXPAND is set **after** the call to
@ -462,7 +462,7 @@ cdef class Window(Object):
as soon as the object is added to the window).
:param subobj: The resize object to add
:type subobj: :py:class:`efl.elementary.object.Object`
:type subobj: :py:class:`~efl.elementary.object.Object`
"""
elm_win_resize_object_add(self.obj, subobj.obj)