Eina_Iterator* promise_values;
has_promise = EINA_TRUE;
promise_param_name = eina_stringshare_add(pname);
- promise_values = eolian_type_subtypes_get(eolian_type_base_type_get(ptypet));
+ promise_values = eolian_type_subtypes_get(ptypet);
Eolian_Type* subtype;
if(eina_iterator_next(promise_values, (void**)&subtype))
promise_value_type = eolian_type_c_type_get(subtype);
*/
struct Ecore.Exe.Event_Data
{
- exe: Eo.Base *; [[The handle to the process. FIXME: should actually be Ecore.Exe, workaround cyclic]]
+ exe: Eo.Base; [[The handle to the process. FIXME: should actually be Ecore.Exe, workaround cyclic]]
data: void *; [[the raw binary data from the child process that was received]]
size: int; [[the size of this data in bytes]]
lines: Ecore.Exe.Event_Data.Line *; [[an array of line data if line buffered, the last one has it's line member set to $NULL]]
params {
@in data: const(void)* @optional; [[The data to be given when the promise is done.]]
}
- return: promise<void*>*; [[The promise that will be triggered.]]
+ return: promise<void*>; [[The promise that will be triggered.]]
}
timeout {
[[Will trigger this promise when the specified timeout occur.]]
@in time: double; [[The time from now in second that the main loop will wait before triggering it.]]
@in data: const(void)* @optional; [[The data to be given when the promise is done.]]
}
- return: promise<void*>*; [[The promise that will be triggered.]]
+ return: promise<void*>; [[The promise that will be triggered.]]
}
}
only allowing parent that provide such interface or NULL.]]
methods {
loop_get {
- return: Efl.Loop *;
+ return: Efl.Loop;
}
}
implements {
]]
}
values {
- output: Ecore.Audio *; [[The output]] /* FIXME-cyclic Should be Ecore.Audio.Out */
+ output: Ecore.Audio; [[The output]] /* FIXME-cyclic Should be Ecore.Audio.Out */
}
}
@property remaining {
]]
return: bool; [[true if the input was attached, false otherwise]]
params {
- @in input: Ecore.Audio.In *; [[The input to attach to the output]]
+ @in input: Ecore.Audio.In; [[The input to attach to the output]]
}
}
input_detach {
]]
return: bool; [[true if the input was detached, false otherwise]]
params {
- @in input: Ecore.Audio.In *; [[The input to detach to the output]]
+ @in input: Ecore.Audio.In; [[The input to detach to the output]]
}
}
inputs_get {
@since 1.8
]]
- return: list<Ecore.Audio.In*> *; [[A list of the inputs that are attached to the output]]
+ return: list<Ecore.Audio.In>; [[A list of the inputs that are attached to the output]]
}
}
implements {
get {
}
values {
- data: Efl.Network.Server *;
+ data: Efl.Network.Server;
}
}
@property data_callback {
get {
}
values {
- svr: Efl.Network.Server *; [[The server the client is connected to.]]
+ svr: Efl.Network.Server; [[The server the client is connected to.]]
}
}
}
}
values {
// FIXME: Efl.Network.Client is needed, but that introduces a cycle
- clients: const(list<const(Efl.Network) *>) *; [[The list of clients on this server.]]
+ clients: const(list<const(Efl.Network)>); [[The list of clients on this server.]]
}
}
@property connection_type {
[[Get the surface associated to this renderer. Can not be set.]]
}
values {
- s: Ector.Surface *; [[Associated surface]]
+ s: Ector.Surface; [[Associated surface]]
}
}
@property transformation {
get {
}
values {
- r: Ector.Renderer *;
+ r: Ector.Renderer;
}
}
@property quality {
return: bool @warn_unused;
params {
@in op: Efl.Gfx.Render_Op;
- @in clips: array<Eina.Rectangle *> *; [[array of @Eina.Rectangle clip]]
+ @in clips: array<Eina.Rectangle *>; [[array of @Eina.Rectangle clip]]
@in mul_col: uint;
}
}
set { [[Sets the source buffer for this renderer, adds a ref]] }
get { [[Return the current source, no ref change]] }
values {
- buf: Ector.Buffer*;
+ buf: Ector.Buffer;
}
}
}
get {
}
values {
- r: const(Ector.Renderer) *;
+ r: const(Ector.Renderer);
}
}
@property stroke_fill {
get {
}
values {
- r: const(Ector.Renderer) *;
+ r: const(Ector.Renderer);
}
}
@property stroke_marker {
get {
}
values {
- r: const(Ector.Renderer) *;
+ r: const(Ector.Renderer);
}
}
}
}
renderer_factory_new @virtual_pure {
[[Create a new renderer factory for the given type]]
- return: Eo.Base *; /* FIXME: Should be a more restricted type, only here for cyclic. */
+ return: Eo.Base; /* FIXME: Should be a more restricted type, only here for cyclic. */
params {
- @in type: const(Eo.Class) * @nonull; /* FIXME: Should probably be a more restricted type */
+ @in type: const(Eo.Class) @nonull; /* FIXME: Should probably be a more restricted type */
}
}
}
return: bool;
params {
@in op: Efl.Gfx.Render_Op;
- @in clips: array<Eina.Rectangle *> *; [[array of @Eina.Rectangle clip]]
+ @in clips: array<Eina.Rectangle *>; [[array of @Eina.Rectangle clip]]
}
}
}
set {}
get {}
values {
- buf: Ector.Buffer *;
+ buf: Ector.Buffer;
}
}
}
access_part_iterate {
[[Iterate over all accessibility-enabled part names.]]
legacy: null;
- return: free(own(iterator<const(char)*> *), eina_iterator_free);
+ return: free(own(iterator<const(char)*>), eina_iterator_free);
}
@property load_error {
get {
Note: Almost all swallow rules apply: you should not move, resize,
hide, show, set the color or clipper of such part. It's a bit
more restrictive as one must never delete this object!]]
- return: Evas.Object *; [[The externally created object, or $null if there is none or
+ return: Evas.Object; [[The externally created object, or $null if there is none or
part is not an external.]]
params {
@in part: const(char)*; [[The part name]]
The content string must not be $null. Its actual value depends on the
code providing the EXTERNAL.]]
- return: Evas.Object *;
+ return: Evas.Object;
params {
@in part: const(char)*; [[The name of the part holding the EXTERNAL]]
@out content: const(char); [[A string identifying which content from the EXTERNAL to get]]
This function return a list of Evas_Textblock_Rectangle anchor
rectangles.]]
- return: const(list<const(Evas.Textblock_Rectangle)*>)*; [[The list of anchor rects (const Evas_Textblock_Rectangle
- *), do not modify! Geometry is relative to entry part.]]
+ return: const(list<const(Evas.Textblock_Rectangle)*>); [[The list of anchor rects (const Evas_Textblock_Rectangle
+ *), do not modify! Geometry is relative to entry part.]]
params {
@in part: const(char)*; [[The part name]]
@in anchor: const(char)*; [[The anchor name]]
Note: If the type of Edje part is GROUP, SWALLOW or EXTERNAL,
returned handle by this function will indicate nothing or transparent
rectangle for events. Use $.part_swallow_get() in that case.]]
- return: const(Evas.Object)*; [[A pointer to the Evas object implementing the given part,
+ return: const(Evas.Object); [[A pointer to the Evas object implementing the given part,
or $null on failure (e.g. the given part doesn't exist)]]
params {
@in part: const(char)*; [[The Edje part's name]]
[[Return a list of char anchor names.
This function returns a list of char anchor names.]]
- return: const(list<const(char)*>)*; [[The list of anchors (const char *), do not modify!]]
+ return: const(list<const(char)*>); [[The list of anchors (const char *), do not modify!]]
params {
@in part: const(char)*; [[The part name]]
}
[[Return a list of char item names.
This function returns a list of char item names.]]
- return: const(list<const(char)*>)*; [[The list of items (const char *), do not modify!]]
+ return: const(list<const(char)*>); [[The list of items (const char *), do not modify!]]
params {
@in part: const(char)*; [[The part name]]
}
part: const(char)*; [[the part in which to swallow the object]]
}
values {
- content: Efl.Gfx*; [[the object to swallow.]]
+ content: Efl.Gfx; [[the object to swallow.]]
}
}
@property content_part_name {
[[The name of the part under which an object is swallowed.]]
get {}
keys {
- content: Efl.Gfx*;
+ content: Efl.Gfx;
}
values {
name: const(char)*;
params {
@in name: const(char)* @nullable;
}
- return: Efl.Gfx*;
+ return: Efl.Gfx;
}
content_remove {
[[Unswallow an object from this container.]]
params {
- @in content: Efl.Gfx*;
+ @in content: Efl.Gfx;
}
return: bool; [[$false if $content was not a child or can not be removed.]]
}
content_iterate {
[[Begin iterating over this object's contents.]]
- return: free(own(iterator<Efl.Gfx *> *), eina_iterator_free) @warn_unused;
+ return: free(own(iterator<Efl.Gfx>), eina_iterator_free) @warn_unused;
}
content_count {
[[Returns the number of UI elements packed in this container.]]
}
}
events {
- content,added: Efl.Gfx*; [[Sent after a new item was added.]]
- content,removed: Efl.Gfx*; [[Sent after an item was removed, before unref.]]
+ content,added: Efl.Gfx; [[Sent after a new item was added.]]
+ content,removed: Efl.Gfx; [[Sent after an item was removed, before unref.]]
}
}
name: const(char)*; [[Buffer name as used in the program.]]
}
values {
- source: Efl.Gfx*; [[Object to use as a source of pixels.]]
+ source: Efl.Gfx; [[Object to use as a source of pixels.]]
}
}
@property filter_data {
@since 1.14
]]
params {
- @in dup_from: const(Eo.Base)*; [[Shape object from where data will be copied.]]
+ @in dup_from: const(Eo.Base); [[Shape object from where data will be copied.]]
}
}
bounds_get {
interpolate {
return: bool;
params {
- @in from: const(Eo.Base)*;
- @in to: const(Eo.Base)*;
+ @in from: const(Eo.Base);
+ @in to: const(Eo.Base);
@in pos_map: double;
}
}
equal_commands {
return: bool;
params {
- @in with: const(Eo.Base)*;
+ @in with: const(Eo.Base);
}
}
}
objects on layers below the one $obj is placed at.
See also @.layer.get(), @.layer.set() and @.below.get()]]
- return: Efl.Gfx.Stack * @warn_unused; [[the #Efl_Gfx_Stack directly below $obj, if any,
+ return: Efl.Gfx.Stack @warn_unused; [[the #Efl_Gfx_Stack directly below $obj, if any,
or $null, if none]]
}
}
objects on layers above the one $obj is placed at.
See also @.layer.get(), @.layer.set() and @.below.get()]]
- return: Efl.Gfx.Stack * @warn_unused; [[the #Efl_Gfx_Stack directly below $obj, if any,
+ return: Efl.Gfx.Stack @warn_unused; [[the #Efl_Gfx_Stack directly below $obj, if any,
or $null, if none]]
}
}
See also @.layer.get(), @.layer.set() and @.stack_below()]]
params {
- @in below: Efl.Gfx.Stack * @nonull; [[the object below which to stack]]
+ @in below: Efl.Gfx.Stack @nonull; [[the object below which to stack]]
}
}
raise {
See also @.layer.get(), @.layer.set() and @.stack_below()]]
params {
- @in above: Efl.Gfx.Stack * @nonull; [[the object above which to stack]]
+ @in above: Efl.Gfx.Stack @nonull; [[the object above which to stack]]
}
}
lower {
struct Efl.Model.Property_Event {
- changed_properties: array<const(char) *> *; [[List of changed properties]]
- invalidated_properties: array<const(char) *> *; [[Removed properties identified by name]]
+ changed_properties: array<const(char) *>; [[List of changed properties]]
+ invalidated_properties: array<const(char) *>; [[Removed properties identified by name]]
}
interface Efl.Model ()
]]
}
values {
- properties: const(array<const(char)*>)*; [[array of current properties]]
+ properties: const(array<const(char)*>); [[array of current properties]]
}
}
property_set {
params {
@in property: const(char)*; [[Property name]]
@in value: const(generic_value)*; [[New value]]
- @inout promise: promise<generic_value>*; [[Promise returning the recorded value or error]]
+ @inout promise: promise<generic_value>; [[Promise returning the recorded value or error]]
}
}
property_get {
]]
params {
@in property: const(char)*; [[Property name]]
- @inout value: promise<generic_value>*; [[Promise of the value that was got]]
+ @inout value: promise<generic_value>; [[Promise of the value that was got]]
}
}
children_slice_get {
count are 0 slice is ignored.]]
@in count: uint; [[Range size. If count and start are 0 slice is
ignored.]]
- @inout promise: promise<accessor<list<Eo.Base*>*>*>*; [[Promise of the children]]
+ @inout promise: promise<accessor<list<Eo.Base> > >; [[Promise of the children]]
}
}
children_count_get {
@since 1.14
]]
params {
- @inout promise: promise<uint>*;
+ @inout promise: promise<uint>;
}
}
child_add {
@since 1.14
]]
- return: Eo.Base *;
+ return: Eo.Base;
}
child_del {
[[Remove a child.
@since 1.14
]]
params {
- @in child: Eo.Base*; [[Child to be removed]]
+ @in child: Eo.Base; [[Child to be removed]]
}
}
}
unpack {
[[Removes an existing item from the container, without deleting it.]]
params {
- subobj: own(Efl.Gfx *);
+ subobj: own(Efl.Gfx);
}
return: bool; [[$false if $subobj wasn't a child or can't be removed]]
}
failed, the object will be unrefed.
]]
params {
- subobj: own(Efl.Gfx *);
+ subobj: own(Efl.Gfx);
}
return: bool; [[$false if $subobj could not be packed.]]
}
methods {
pack_grid {
params {
- subobj: own(Efl.Gfx *);
+ subobj: own(Efl.Gfx);
col: int;
row: int;
colspan: int @optional; [[0 means 1, -1 means @.grid_columns]]
}
grid_contents_get {
[[Returns all objects at a given position in this grid.]]
- return: free(own(iterator<Efl.Gfx *> *), eina_iterator_free);
+ return: free(own(iterator<Efl.Gfx>), eina_iterator_free);
params {
@in col: int;
@in row: int;
}
grid_content_get {
[[Returns a child at a given position, see @.grid_contents_get.]]
- return: Efl.Gfx*;
+ return: Efl.Gfx;
params {
@in col: int;
@in row: int;
[[position and span of the $subobj in this container, may be modified to move the $subobj]]
get { return: bool; [[returns false if item is not a child]] }
keys {
- subobj: Efl.Gfx*;
+ subobj: Efl.Gfx;
}
values {
col: int;
get {}
values {
/* FIXME: engine is an Eo.Class */
- engine: const(Eo.Base)*; [[Must be an $Efl.Pack.Layout subclass.]]
- data: const(void)*; [[Any data to pass along to $Efl.Pack.Layout.layout_do.
- Owned by the caller. Depends on the layout engine.]]
+ engine: const(Eo.Base); [[Must be an $Efl.Pack.Layout subclass.]]
+ data: const(void)*; [[Any data to pass along to $Efl.Pack.Layout.layout_do.
+ Owned by the caller. Depends on the layout engine.]]
}
}
layout_request {
layout_do @class @protected {
[[Lay out (resize and move) children objects of $pack.]]
params {
- pack: Efl.Gfx*; [[The container to lay out.]]
+ pack: Efl.Gfx; [[The container to lay out.]]
data: const(void)* @optional; [[Extra data passed by the caller.]]
}
}
This is the same as @.pack_at($subobj, 0).
]]
params {
- @in subobj: own(Efl.Gfx *); [[Item to pack.]]
+ @in subobj: own(Efl.Gfx); [[Item to pack.]]
}
return: bool; [[$false if $subobj could not be packed]]
}
This is the same as @.pack_at($subobj, -1).
]]
params {
- @in subobj: own(Efl.Gfx *); [[Item to pack.]]
+ @in subobj: own(Efl.Gfx); [[Item to pack.]]
}
return: bool; [[$false if $subobj could not be packed]]
}
pack_before {
[[Prepend item before other sub object.]]
params {
- @in subobj: own(Efl.Gfx *); [[Item to pack.]]
- @in existing: const(Efl.Gfx)*; [[Item to refer to.]]
+ @in subobj: own(Efl.Gfx); [[Item to pack.]]
+ @in existing: const(Efl.Gfx); [[Item to refer to.]]
}
return: bool; [[$false if $existing could not be found or $subobj
could not be packed]]
pack_after {
[[Append item after other sub object.]]
params {
- @in subobj: own(Efl.Gfx *); [[Item to pack.]]
- @in existing: const(Efl.Gfx)*; [[Item to refer to.]]
+ @in subobj: own(Efl.Gfx); [[Item to pack.]]
+ @in existing: const(Efl.Gfx); [[Item to refer to.]]
}
return: bool; [[$false if $existing could not be found or $subobj
could not be packed]]
Out of range indices will trigger an append.
]]
params {
- @in subobj: own(Efl.Gfx *); [[Item to pack.]]
+ @in subobj: own(Efl.Gfx); [[Item to pack.]]
@in index: int; [[A position.]]
}
return: bool; [[$false if $subobj could not be packed]]
params {
index: int;
}
- return: Efl.Gfx *; [[The object contained at the given $index.]]
+ return: Efl.Gfx; [[The object contained at the given $index.]]
}
pack_index_get {
[[Get the index of a child in this container.]]
params {
- subobj: const(Efl.Gfx)*; [[An object contained in this pack.]]
+ subobj: const(Efl.Gfx); [[An object contained in this pack.]]
}
return: int(-1); [[-1 in case of failure, or the index of this item.]]
}
params {
index: int;
}
- return: Efl.Gfx*; [[The child item if it could be removed.]]
+ return: Efl.Gfx; [[The child item if it could be removed.]]
}
@property pack_direction {
[[Primary up/left/right/down orientation. Default is right.]]
params {
path: const(char)*; [[ The input virtual file path to fetch ]]
}
- return: own(Efl.Vpath.File *); [[ An object representing the file ]]
+ return: own(Efl.Vpath.File); [[ An object representing the file ]]
}
}
}
methods {
get @class {
[[ This gets the global EFL Core Vpath class - only 1 - singleton ]]
- return: Efl.Vpath.Core *; [[ Get the singleton core vpath ]]
+ return: Efl.Vpath.Core; [[ Get the singleton core vpath ]]
}
meta_set {
[[ A Meta key is a mapping from a virtual path to a real one ]]
params {
path: const(char)*; [[ The input virtual file path to fetch ]]
}
- return: own(Efl.Vpath.File *); [[ An object representing the file ]]
+ return: own(Efl.Vpath.File); [[ An object representing the file ]]
}
register @class {
[[Register a vpath with the manager ]]
params {
priority: int; [[ Search order - higher values tried first ]]
- vpath: Efl.Vpath * @nonull; [[ A Vpath implementation object ]]
+ vpath: Efl.Vpath @nonull; [[ A Vpath implementation object ]]
}
}
unregister @class {
[[ Unregister a vpath from the manager ]]
params {
- vpath: Efl.Vpath * @nonull; [[ A Vpath implementation object ]]
+ vpath: Efl.Vpath @nonull; [[ A Vpath implementation object ]]
}
}
}
params {
@in proxy: Eldbus.Proxy*; [[Eldbus proxy]]
@in name: const(char)*; [[Name]]
- @in arguments: const(list<Eldbus.Introspection.Argument *>)*; [[The introspected arguments]]
+ @in arguments: const(list<Eldbus.Introspection.Argument *>); [[The introspected arguments]]
}
}
@property name {
struct Eldbus.Introspection.Node
{
name: Eina.Stringshare *; [[optional]]
- nodes: list<void *> *;
- interfaces: list<void *> *;
+ nodes: list<void *>;
+ interfaces: list<void *>;
}
struct Eldbus.Introspection.Interface
{
name: Eina.Stringshare *;
- methods: list<void *> *;
- signals: list<void *> *;
- properties: list<void *> *;
- annotations: list<void *> *;
+ methods: list<void *>;
+ signals: list<void *>;
+ properties: list<void *>;
+ annotations: list<void *>;
}
struct Eldbus.Introspection.Method
{
name: Eina.Stringshare *;
- arguments: list<void *> *;
- annotations: list<void *> *;
+ arguments: list<void *>;
+ annotations: list<void *>;
}
struct Eldbus.Introspection.Property
name: Eina.Stringshare *;
type: Eina.Stringshare *;
access: Eldbus.Introspection.Property_Access;
- annotations: list<void *> *;
+ annotations: list<void *>;
}
struct Eldbus.Introspection.Annotation
struct Eldbus.Introspection.Signal
{
name: Eina.Stringshare *;
- arguments: list<Eldbus.Introspection.Argument *> *;
- annotations: list<Eldbus.Introspection.Annotation *> *;
+ arguments: list<Eldbus.Introspection.Argument *>;
+ annotations: list<Eldbus.Introspection.Annotation *>;
}
@property real_part @protected {
set {}
values {
- layout: Eo.Base*;
- pack: Eo.Base*;
+ layout: Eo.Base;
+ pack: Eo.Base;
part: const(char)*;
}
}
@property real_part @protected {
set {}
values {
- layout: Eo.Base*;
- pack: Eo.Base*;
+ layout: Eo.Base;
+ pack: Eo.Base;
part: const(char)*;
}
}
[[Return a iterator with all views of application.]]
}
values {
- ret: free(own(iterator<Elm.App.Client.View *> *), eina_iterator_free); [[The iterator with all views, must be freed after use.]]
+ ret: free(own(iterator<Elm.App.Client.View>), eina_iterator_free); [[The iterator with all views, must be freed after use.]]
}
}
@property package {
[[Return a iterator with all views of application]]
}
values {
- ret: free(own(iterator<Elm.App.Server.View *> *), eina_iterator_free); [[Iterator with all views of application, you must free iterator after use]]
+ ret: free(own(iterator<Elm.App.Server.View>), eina_iterator_free); [[Iterator with all views of application, you must free iterator after use]]
}
}
@property path {
requested by create_view_cb.
]]
params {
- @in view: Elm.App.Server.View *; [[elm_app_server_view]]
+ @in view: Elm.App.Server.View; [[elm_app_server_view]]
}
}
title_set {
set {
}
values {
- win: Evas.Object *;
+ win: Evas.Object;
}
}
@property id {
You must free this list with eina_list_free() once you are done with it.
]]
- return: free(own(list<Evas.Object*>*), eina_list_free) @warn_unused;
+ return: free(own(list<Evas.Object>), eina_list_free) @warn_unused;
}
}
pack_end {
]]
params {
- @in subobj: Evas.Object *; [[The object to add to the box]]
+ @in subobj: Evas.Object; [[The object to add to the box]]
}
}
unpack_all {
]]
params {
- @in subobj: Evas.Object *; [[The object to unpack]]
+ @in subobj: Evas.Object; [[The object to unpack]]
}
}
pack_after {
]]
params {
- @in subobj: Evas.Object *; [[The object to add to the box]]
- @in after: Evas.Object *; [[The object after which to add it]]
+ @in subobj: Evas.Object; [[The object to add to the box]]
+ @in after: Evas.Object; [[The object after which to add it]]
}
}
pack_start {
]]
params {
- @in subobj: Evas.Object *; [[The object to add to the box]]
+ @in subobj: Evas.Object; [[The object to add to the box]]
}
}
recalculate {
]]
params {
- @in subobj: Evas.Object *; [[The object to add to the box]]
- @in before: Evas.Object *; [[The object before which to add it]]
+ @in subobj: Evas.Object; [[The object to add to the box]]
+ @in before: Evas.Object; [[The object before which to add it]]
}
}
clear {
@.marks_clear.
]]
- return: const(list<Elm.Calendar.Mark*>)*; [[List with all calendar marks]]
+ return: const(list<Elm.Calendar.Mark*>); [[List with all calendar marks]]
}
}
selected_time_set {
@since 1.9
]]
- return: const(list<Elm.Widget.Item*>)*;[[The list of color palette items.]]
+ return: const(list<Elm.Widget.Item>);[[The list of color palette items.]]
}
}
@property palette_selected_item {
@since 1.9]]
- return: Elm.Widget.Item *;[[The selected item, or $null if none
+ return: Elm.Widget.Item;[[The selected item, or $null if none
selected.]]
}
}
palette_color_add {
[[Add a new color item to palette.]]
- return: Elm.Widget.Item *;[[A new color palette Item.]]
+ return: Elm.Widget.Item;[[A new color palette Item.]]
params {
@in r: int; [[r-value of color]]
@in g: int; [[g-value of color]]
]]
}
values {
- parent: Evas.Object *; [[The parent to use.]]
+ parent: Evas.Object; [[The parent to use.]]
}
}
@property direction_priority {
@since 1.11
]]
- return: const(list<Elm.Widget.Item*>)*; [[The list of items or
+ return: const(list<Elm.Widget.Item>); [[The list of items or
$null on errors.]]
}
@since 1.11
]]
- return: Elm.Widget.Item *; [[The first item or $null, if it has no items (and on
+ return: Elm.Widget.Item; [[The first item or $null, if it has no items (and on
errors).]]
}
@since 1.1
]]
- return: Elm.Widget.Item *; [[The last item or $null, if it has no items (and on
+ return: Elm.Widget.Item; [[The last item or $null, if it has no items (and on
errors).]]
}
See also \@ref elm_object_content_set.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null, on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null, on errors.]]
params {
@in label: const(char)*; [[The Label of the new item]]
- @in icon: Evas.Object * @optional; [[Icon to be set on new item]]
+ @in icon: Evas.Object @optional; [[Icon to be set on new item]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when item selected]]
@in data: const(void)* @optional; [[Data passed to $func]]
}
@since 1.11
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null, on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null, on errors.]]
params {
@in label: const(char)*; [[The Label of the new item]]
- @in icon: Evas.Object * @optional; [[Icon to be set on new item]]
+ @in icon: Evas.Object @optional; [[Icon to be set on new item]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when item selected]]
@in data: const(void)* @optional; [[Data passed to $func]]
}
]]
}
values {
- item: Elm.Widget.Item *; [[The item before the object in its parent's list. If there is no previous item for $ it or there's an error, $null is returned.]]
+ item: Elm.Widget.Item; [[The item before the object in its parent's list. If there is no previous item for $ it or there's an error, $null is returned.]]
}
}
@property next {
]]
}
values {
- item: Elm.Widget.Item *; [[The item after the object in its parent's list. If there is no previous item for $ it or there's an error, $null is returned.]]
+ item: Elm.Widget.Item; [[The item after the object in its parent's list. If there is no previous item for $ it or there's an error, $null is returned.]]
}
}
init {
@since 1.8
]]
- return: own(list<own(Eina_Stringshare *)> *) @warn_unused; [[A list of seven strings to be used as weekday names.]]
+ return: own(list<own(Eina_Stringshare *)>) @warn_unused; [[A list of seven strings to be used as weekday names.]]
}
day_selected_set {
[[Set the state of given Dayselector_Day.
See also @.item_append,
@.items.get.
]]
- return: Elm.Widget.Item *; [[The first item, or $null if none.]]
+ return: Elm.Widget.Item; [[The first item, or $null if none.]]
}
}
@property items {
\@ref elm_object_item_del,
@.clear.
]]
- return: const(list<Elm.Widget.Item*>)*; [[A $list of diskselector items, or $ull on failure.]]
+ return: const(list<Elm.Widget.Item>); [[A $list of diskselector items, or $ull on failure.]]
}
}
@property last_item {
See also @.item_append,
@.items.get.
]]
- return: Elm.Widget.Item *; [[The last item, or $null if none.]]
+ return: Elm.Widget.Item; [[The last item, or $null if none.]]
}
}
@property selected_item {
apply on the selected item. More details on
@.side_text_max_length.set.
]]
- return: Elm.Widget.Item *; [[The selected diskselector item.]]
+ return: Elm.Widget.Item; [[The selected diskselector item.]]
}
}
item_append {
* elm_diskselector_item_append(disk, "label", ic, NULL, NULL);
* @endcode
*/
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in label: const(char)*; [[The label of the diskselector item.]]
- @in icon: Evas.Object * @optional; [[The icon object to use at left side of the item. An
+ @in icon: Evas.Object @optional; [[The icon object to use at left side of the item. An
icon can be any Evas object, but usually it is an icon created
with elm_icon_add(). ]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is selected.]]
]]
}
values {
- item: Elm.Widget.Item *; [[The item before $item, or $null if none or on failure.]]
+ item: Elm.Widget.Item; [[The item before $item, or $null if none or on failure.]]
}
}
@property next {
]]
}
values {
- item: Elm.Widget.Item *; [[The item after $item, or $null if none or on failure.]]
+ item: Elm.Widget.Item; [[The item after $item, or $null if none or on failure.]]
}
}
@property selected {
]]
}
values {
- parent: Evas.Object * @nullable; [[The object to use as parent for the hover.]]
+ parent: Evas.Object @nullable; [[The object to use as parent for the hover.]]
}
}
@property prediction_allow {
change the internal textblock object). This applies to all cursors
returned from textblock calls, and all the other derivative values.
]]
- return: Evas.Object *;
+ return: Evas.Object;
}
}
@property cursor_geometry {
items list is changed. It should be fetched again with another
call to this function when changes happen.
]]
- return: const(list<Elm.Widget.Item*>)*;
+ return: const(list<Elm.Widget.Item>);
}
}
@property first_item {
See also @.item_append,
@.last_item.get.
]]
- return: Elm.Widget.Item *; [[The first item or $null, if it has no items (and on
+ return: Elm.Widget.Item; [[The first item or $null, if it has no items (and on
errors).]]
}
See also @.item_prepend,
@.first_item.get.
]]
- return: Elm.Widget.Item *; [[The last item or $null, if it has no items (and on
+ return: Elm.Widget.Item; [[The last item or $null, if it has no items (and on
errors).]]
}
@property selected_item {
get {
[[Get the currently selected item in a flip selector widget.]]
- return: Elm.Widget.Item *; [[The selected item or $null, if the widget has no items
+ return: Elm.Widget.Item; [[The selected item or $null, if the widget has no items
(and on errors).]]
}
determined by the widget's theme. Strings larger than
that value are going to be truncated.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in label: const(char)*; [[The (text) label of the new item.]]
@in func: Evas_Smart_Cb @optional; [[Convenience callback function to take place when
determined by the widget's theme. Strings larger than
that value are going to be truncated.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in label: const(char)*; [[The (text) label of the new item.]]
@in func: Evas_Smart_Cb @optional; [[Convenience callback function to take place when
See also @.next_get.
]]
- return: Elm.Widget.Item *; [[The item before the $item, in its parent's list. If there is no previous item for $item or there's an error, $null is returned.]]
+ return: Elm.Widget.Item; [[The item before the $item, in its parent's list. If there is no previous item for $item or there's an error, $null is returned.]]
}
next_get @const {
[[Get the item after $item in a flip selector widget's
See also @.prev_get.
]]
- return: Elm.Widget.Item *; [[The item after the $item, in its parent's list. If there is no next item for $item or there's an error, $null is returned.]]
+ return: Elm.Widget.Item; [[The item after the $item, in its parent's list. If there is no next item for $item or there's an error, $null is returned.]]
}
}
implements {
in the list is selected, which might not be very useful. For
that case, see @.selected_items.get.
]]
- return: Elm.Widget.Item *; [[The selected item's handle or $null
+ return: Elm.Widget.Item; [[The selected item's handle or $null
if none is selected at the moment
(and on errors).]]
}
in the list are only valid so long as those items are not
deleted or the gengrid is not deleted.
]]
- return: free(own(list<Elm_Gen_Item *> *), eina_list_free) @warn_unused; [[
+ return: free(own(list<Elm_Gen_Item *>), eina_list_free) @warn_unused; [[
The list of realized items or $null if none are realized.
]]
}
This returns the first item in the $obj's internal list of
items.
]]
- return: Elm.Widget.Item *; [[
+ return: Elm.Widget.Item; [[
The first item's handle or $null, if there are no
items in $obj (and on errors)
]]
by deletion). The list contains Gengrid item pointers as
data, naturally.
]]
- return: const(list<Elm.Widget.Item *>)*; [[
+ return: const(list<Elm.Widget.Item>); [[
The list of selected items or $null, if none is
selected at the moment (and on errors).
]]
This returns the last item in the $obj's internal list of
items.
]]
- return: Elm.Widget.Item *; [[The last item's handle or $null
+ return: Elm.Widget.Item; [[The last item's handle or $null
if there are no items in $obj
(and on errors).]]
}
This inserts an item before another in the gengrid.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
params {
@in itc: const(Elm.Gengrid.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
- @in relative: Elm.Widget.Item *; [[The item to place this new one before.]]
+ @in relative: Elm.Widget.Item; [[The item to place this new one before.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called
when the item is selected.]]
@in func_data: const(void)* @optional; [[Data to be passed to $func.]]
This inserts an item after another in the gengrid.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null on error.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null on error.]]
params {
@in itc: const(Elm.Gengrid.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
- @in relative: Elm.Widget.Item *; [[The item to place this new one after.]]
+ @in relative: Elm.Widget.Item; [[The item to place this new one after.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called
when the item is selected.]]
@in func_data: const(void)* @optional; [[Data to be passed to $func.]]
there), then posret may indicate -1 or 1 based if the coordinate
is above or below all items respectively in the gengrid.
]]
- return: Elm.Widget.Item *; [[The item at the coordinates or $null if none.]]
+ return: Elm.Widget.Item; [[The item at the coordinates or $null if none.]]
params {
@in x: Evas.Coord; [[The input x coordinate.]]
@in y: Evas.Coord; [[The input y coordinate.]]
This adds an item to the beginning of the gengrid.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
params {
@in itc: const(Elm.Gengrid.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
This adds an item to the end of the gengrid.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
params {
@in itc: const(Elm.Gengrid.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
comparison function. The two arguments passed to the function
$func are gengrid item handles to compare.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
params {
@in itc: const(Elm.Gengrid.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
@since 1.11
]]
- return: Elm.Widget.Item *; [[Pointer to the gengrid item which matches
+ return: Elm.Widget.Item; [[Pointer to the gengrid item which matches
search_string in case of success,
otherwise $null.]]
params {
- @in item_to_search_from: Elm.Widget.Item * @optional; [[
+ @in item_to_search_from: Elm.Widget.Item @optional; [[
Pointer to item to start search from. If $null, search will
be started from the first item of the gengrid.
]]
gengrid.]]
}
values {
- item: Elm.Widget.Item *; [[The item before $item, or $NULL if there's none (and on errors)]]
+ item: Elm.Widget.Item; [[The item before $item, or $NULL if there's none (and on errors)]]
}
}
@property next {
gengrid.]]
}
values {
- item: Elm.Widget.Item *; [[The item after $item, or $NULL if there's none (and on errors)]]
+ item: Elm.Widget.Item; [[The item after $item, or $NULL if there's none (and on errors)]]
}
}
@property selected {
floating "orphans" that can be re-used elsewhere if the user wants
to.]]
params {
- @out l: own(list<own(Evas.Object *)> *); [[The contents list to return.]]
+ @out l: own(list<own(Evas.Object)>); [[The contents list to return.]]
}
}
}
This function returns the item that was activated with a mode,
by the function @.decorate_mode.set.
]]
- return: Elm.Widget.Item *; [[The active item for that current mode.
- Or $null if no item is activated with any mode.]]
+ return: Elm.Widget.Item; [[The active item for that current mode.
+ Or $null if no item is activated with any mode.]]
}
}
@property selected_item {
If no item is selected, $null is returned.
]]
- return: Elm.Widget.Item *; [[The selected item, or $null if none is selected.]]
+ return: Elm.Widget.Item; [[The selected item, or $null if none is selected.]]
}
}
@property first_item {
If filter is set on genlist, it returns
the first filtered item in the list.
]]
- return: Elm.Widget.Item *; [[The first item or $null.]]
+ return: Elm.Widget.Item; [[The first item or $null.]]
}
}
@property realized_items {
item pointers in the list are only valid so long as those
items are not deleted or the genlist is not deleted.
]]
- return: free(own(list<Elm_Gen_Item *> *), eina_list_free) @warn_unused;
+ return: free(own(list<Elm_Gen_Item *>), eina_list_free) @warn_unused;
}
}
@property selected_items {
Note: If not in multi-select mode, consider using function
@.selected_item.get instead.
]]
- return: const(list<Elm.Widget.Item *>)*;
+ return: const(list<Elm.Widget.Item>);
}
}
@property last_item {
If filter is set to genlist, it returns
last filtered item in the list.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
}
}
item_insert_before {
This inserts an item before another in the list. It will be in
the same tree level or group as the item it is inserted before.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
- @in parent: Elm.Widget.Item * @nullable; [[The parent item, or $null if none.]]
- @in before_it: Elm.Widget.Item *; [[The item to place this new one before.]]
+ @in parent: Elm.Widget.Item @nullable; [[The parent item, or $null if none.]]
+ @in before_it: Elm.Widget.Item; [[The item to place this new one before.]]
@in type: Elm.Genlist.Item.Type; [[Item type.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
This inserts an item after another in the list. It will be in the
same tree level or group as the item it is inserted after.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
- @in parent: Elm.Widget.Item * @nullable; [[The parent item, or $null if none.]]
- @in after_it: Elm.Widget.Item *; [[The item to place this new one after.]]
+ @in parent: Elm.Widget.Item @nullable; [[The parent item, or $null if none.]]
+ @in after_it: Elm.Widget.Item; [[The item to place this new one after.]]
@in type: Elm.Genlist.Item.Type; [[Item type.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
1 based if the coordinate is above or below all items
respectively in the genlist.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in x: Evas.Coord; [[The input x coordinate.]]
@in y: Evas.Coord; [[The input y coordinate.]]
Return NULL if filter is not set. Application must take care
of the case while calling the API. Must be freed after use.
]]
- return: free(own(iterator<Elm_Gen_Item *> *), eina_iterator_free); [[Iterator on genlist]]
+ return: free(own(iterator<Elm_Gen_Item *>), eina_iterator_free); [[Iterator on genlist]]
}
filtered_items_count @const {
[[Return how many items have passed the filter currently.
This adds an item to the beginning of the list or beginning of
the children of the parent if given.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
- @in parent: Elm.Widget.Item * @nullable; [[The parent item, or $null if none.]]
+ @in parent: Elm.Widget.Item @nullable; [[The parent item, or $null if none.]]
@in type: Elm.Genlist.Item.Type; [[Item type.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
This adds the given item to the end of the list or the end of
the children list if the $parent is given.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
- @in parent: Elm.Widget.Item * @nullable; [[The parent item, or $null if none.]]
+ @in parent: Elm.Widget.Item @nullable; [[The parent item, or $null if none.]]
@in type: Elm.Genlist.Item.Type; [[Item type.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
comparison function. The two arguments passed to the function
$func are genlist item handles to compare.
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item data.]]
- @in parent: Elm.Widget.Item * @nullable; [[The parent item, or $null if none.]]
+ @in parent: Elm.Widget.Item @nullable; [[The parent item, or $null if none.]]
@in type: Elm.Genlist.Item.Type; [[Item type.]]
@in comp: Eina_Compare_Cb; [[The function called for the sort.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
@since 1.11
]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
params {
- @in item_to_search_from: Elm.Widget.Item * @optional; [[
+ @in item_to_search_from: Elm.Widget.Item @optional; [[
Pointer to item to start search from. If $null, search
will be started from the first item of the genlist.
]]
]]
}
values {
- item: Elm.Widget.Item *; [[The item before $item, or $null if there's none (and on errors).]]
+ item: Elm.Widget.Item; [[The item before $item, or $null if there's none (and on errors).]]
}
}
@property next {
]]
}
values {
- item: Elm.Widget.Item *; [[The item after $item, or $null if there's none (and on errors).]]
+ item: Elm.Widget.Item; [[The item after $item, or $null if there's none (and on errors).]]
}
}
@property parent {
]]
}
values {
- item: Elm.Widget.Item *; [[The parent of the item or $null if it has no parent.]]
+ item: Elm.Widget.Item; [[The parent of the item or $null if it has no parent.]]
}
}
@property subitems {
]]
}
values {
- subitems: const (list<Elm.Widget.Item *>) *; [[The list of subitems, $null on error.]]
+ subitems: const(list<Elm.Widget.Item>); [[The list of subitems, $null on error.]]
}
}
@property selected {
elsewhere if the user wants to.
]]
params {
- @out l: own(list<own(Evas.Object *)> *); [[The contents list to return.]]
+ @out l: own(list<own(Evas.Object)>); [[The contents list to return.]]
}
}
update {
]]
return: bool; [[$true on success, $false otherwise.]]
params {
- @in target: Evas.Object *; [[The object to attach.]]
+ @in target: Evas.Object; [[The object to attach.]]
}
}
cb_del {
It's possible to remove objects from the grid when walking this
list, but these removals won't be reflected on it.
]]
- return: free(own(list<Evas.Object *> *), eina_list_free) @warn_unused;
+ return: free(own(list<Evas.Object>), eina_list_free) @warn_unused;
}
}
clear {
unpack {
[[Unpack a child from a grid object]]
params {
- @in subobj: Evas.Object *; [[The child to unpack]]
+ @in subobj: Evas.Object; [[The child to unpack]]
}
}
pack {
[[Pack child at given position and size]]
params {
- @in subobj: Evas.Object *; [[The child to pack.]]
+ @in subobj: Evas.Object; [[The child to pack.]]
@in x: Evas.Coord; [[The virtual x coord at which to pack it.]]
@in y: Evas.Coord; [[The virtual y coord at which to pack it.]]
@in w: Evas.Coord; [[The virtual width at which to pack it.]]
[[Get the target object for the hover.]]
}
values {
- target: Evas.Object *; [[The target object.]]
+ target: Evas.Object; [[The target object.]]
}
}
best_content_location_get @const {
get {
}
values {
- parent: Evas.Object * @nullable; [[The parent to use]]
+ parent: Evas.Object @nullable; [[The parent to use]]
}
}
@property expanded {
@property items {
get {
[[Get the list of items within the given hoversel.]]
- return: const(list<Elm.Widget.Item *>)*;
+ return: const(list<Elm.Widget.Item>);
}
}
@property auto_update {
/* FIXME-doc
For more information on what $icon_file and $icon_type are, see the
@ref Icon "icon documentation". */
- return: Elm.Widget.Item *; [[A handle to the added item.]]
+ return: Elm.Widget.Item; [[A handle to the added item.]]
params {
@in label: const(char)* @optional; [[The text label to use for the item (NULL if not desired)]]
@in icon_file: const(char)* @optional; [[An image file path on disk to use for the icon or standard icon name (NULL if not desired)]]
$item will be the pointer returned back on $"changed",
"delay,changed" and $"selected" smart events.]]
- return: Elm.Widget.Item *; [[A handle to the item added or $NULL, on errors]]
+ return: Elm.Widget.Item; [[A handle to the item added or $NULL, on errors]]
params {
@in letter: const(char)*; [[Letter under which the item should be indexed]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is selected.]]
Note: If $relative is $NULL this function will behave as
elm_index_item_append().]]
- return: Elm.Widget.Item *; [[A handle to the item added or $NULL, on errors]]
+ return: Elm.Widget.Item; [[A handle to the item added or $NULL, on errors]]
params {
- @in after: Elm.Widget.Item *; [[The index item to insert after.]]
+ @in after: Elm.Widget.Item; [[The index item to insert after.]]
@in letter: const(char)*; [[Letter under which the item should be indexed]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
@in data: const(void)* @optional; [[The item data to set for the index's item]]
item_find {
[[Find a given index widget's item, using item data.]]
- return: Elm.Widget.Item *; [[The index item handle, if found, or $NULL otherwise]]
+ return: Elm.Widget.Item; [[The index item handle, if found, or $NULL otherwise]]
params {
@in data: const(void)*; [[The item data pointed to by the desired index item]]
}
Note: If $relative is $NULL this function will behave as
elm_index_item_prepend().]]
- return: Elm.Widget.Item *; [[A handle to the item added or $NULL, on errors]]
+ return: Elm.Widget.Item; [[A handle to the item added or $NULL, on errors]]
params {
- @in before: Elm.Widget.Item *; [[The index item to insert after.]]
+ @in before: Elm.Widget.Item; [[The index item to insert after.]]
@in letter: const(char)*; [[Letter under which the item should be indexed]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
@in data: const(void)* @optional; [[The item data to set for the index's item]]
$item will be the pointer returned back on $"changed",
"delay,changed" and $"selected" smart events.]]
- return: Elm.Widget.Item *; [[A handle to the item added or $NULL, on errors]]
+ return: Elm.Widget.Item; [[A handle to the item added or $NULL, on errors]]
params {
@in letter: const(char)*; [[Letter under which the item should be indexed]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is selected.]]
selected_item_get @const {
[[Returns the last selected item, for a given index widget.]]
- return: Elm.Widget.Item *; [[The last item selected on $obj (or $NULL, on errors).]]
+ return: Elm.Widget.Item; [[The last item selected on $obj (or $NULL, on errors).]]
params {
@in level: int; [[$0 or $1, the currently implemented levels.]]
}
$item will be the pointer returned back on $"changed",
"delay,changed" and $"selected" smart events.]]
- return: Elm.Widget.Item *; [[A handle to the item added or $NULL, on errors]]
+ return: Elm.Widget.Item; [[A handle to the item added or $NULL, on errors]]
params {
@in letter: const(char)*; [[Letter under which the item should be indexed]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
struct Elm.Atspi.Event.Children_Changed.Data
{
is_added: bool;
- child: Eo.Base *;
+ child: Eo.Base;
}
struct Elm.Atspi.Attribute
struct Elm.Atspi.Relation
{
type: Elm.Atspi.Relation_Type;
- objects: list<Eo.Base *> *;
+ objects: list<Eo.Base>;
}
-type Elm.Atspi.Relation_Set: list<Elm.Atspi.Relation *> *;
+type Elm.Atspi.Relation_Set: list<Elm.Atspi.Relation *>;
mixin Elm.Interface.Atspi_Accessible ()
{
[[Gets widget's accessible children.]]
}
values {
- children: free(own(list<Elm.Interface.Atspi_Accessible *> *), eina_list_free);
+ children: free(own(list<Elm.Interface.Atspi_Accessible>), eina_list_free);
}
}
@property role_name @protected {
[[Gets key-value pairs indentifying widget extra attributes. Must be free by a user.]]
}
values {
- attributes: free(own(list<own(Elm.Atspi.Attribute *)> *), elm_atspi_attributes_list_free);
+ attributes: free(own(list<own(Elm.Atspi.Attribute *)>), elm_atspi_attributes_list_free);
}
}
@property index_in_parent @protected {
[[Sets widget accessible parent.]]
}
values {
- parent: Elm.Interface.Atspi_Accessible *;
+ parent: Elm.Interface.Atspi_Accessible;
}
}
@property state_set @protected {
}
event_emit @class @protected {
params {
- @in accessible: Elm.Interface.Atspi_Accessible *; [[Accessibility object.]]
+ @in accessible: Elm.Interface.Atspi_Accessible; [[Accessibility object.]]
@in event: const(Eo.Event.Description)*; [[Accessibility event type.]]
@in event_info: void*; [[Accessibility event details.]]
}
return: bool;
params {
@in type: Elm.Atspi.Relation_Type;
- @in relation_object: const(Elm.Interface.Atspi_Accessible)*;
+ @in relation_object: const(Elm.Interface.Atspi_Accessible);
}
}
relationship_remove {
]]
params {
@in type: Elm.Atspi.Relation_Type;
- @in relation_object: const(Elm.Interface.Atspi_Accessible)*;
+ @in relation_object: const(Elm.Interface.Atspi_Accessible);
}
}
relationships_clear {
get {
[[Get root object of accessible object hierarchy]]
values {
- ret: Eo.Base*;
+ ret: Eo.Base;
}
}
}
[[Get list of available widget actions]]
}
values {
- actions: list<Elm_Atspi_Action> *; [[contains statically allocated strings]]
+ actions: list<Elm_Atspi_Action>; [[contains statically allocated strings]]
}
}
action_do @protected @virtual_pure {
@in x: int;
@in y: int;
}
- return: Eo.Base*;
+ return: Eo.Base;
}
}
}
@property selected_child @protected {
[[Gets child for given child index]]
get {
- return: Eo.Base *;
+ return: Eo.Base;
}
keys {
selected_child_index: int; [[index of selected child]]
end_offset: int *;
}
values {
- attributes: own(list<own(Elm.Atspi_Text.Attribute *)> *);
+ attributes: own(list<own(Elm.Atspi_Text.Attribute *)>);
}
}
@property default_attributes @protected {
get {
}
values {
- attributes: own(list<own(Elm.Atspi_Text.Attribute *)>*);
+ attributes: own(list<own(Elm.Atspi_Text.Attribute *)>);
}
}
@property character_extents @protected {
yclip: Elm.Atspi_Text.Clip_Type;
}
values {
- ranges: own(list<own(Elm.Atspi_Text.Range *)> *);
+ ranges: own(list<own(Elm.Atspi_Text.Range *)>);
}
}
@property range_extents @protected {
[[Get a list of selected paths in the fileselector.]]
}
values {
- ret: const(list<const(char)*>)*;
+ ret: const(list<const(char)*>);
}
}
@property current_name {
set {
}
values {
- pan: Evas.Object * @nullable;
+ pan: Evas.Object @nullable;
}
}
@property page_change_cb {
set {
}
values {
- content: Evas.Object * @nullable;
+ content: Evas.Object @nullable;
}
}
@property edge_left_cb {
set {
}
values {
- edje_object: Evas.Object *;
- hit_rectangle: Evas.Object *;
+ edje_object: Evas.Object;
+ hit_rectangle: Evas.Object;
}
}
@property last_page {
hooking callbacks to signals, etc.) can be done with
proper elementary functions.
]]
- return: Evas.Object *; [[An Evas_Object with the edje layout
+ return: Evas.Object; [[An Evas_Object with the edje layout
settings loaded \@ref elm_layout_file_set.]]
}
}
The selected item always will be highlighted on list.]]
- return: Elm.Widget.Item *; [[The selected list item.]]
+ return: Elm.Widget.Item; [[The selected list item.]]
}
}
@property items {
get {
[[Get a list of all the list items.]]
- return: const(list<Elm.Widget.Item *>)*; [[A $list of list items, #Elm.Widget.Item, or $NULL on failure.]]
+ return: const(list<Elm.Widget.Item>); [[A $list of list items, #Elm.Widget.Item, or $NULL on failure.]]
}
}
@property first_item {
This returns the first item in the list.]]
- return: Elm.Widget.Item *; [[The first item, or NULL if none]]
+ return: Elm.Widget.Item; [[The first item, or NULL if none]]
}
}
@property selected_items {
Multiple items can be selected if multi select is enabled. It can be
done with elm_list_multi_select_set().]]
- return: const(list<Elm.Widget.Item *>)*; [[An $list of list items, #Elm.Widget.Item, or $NULL on failure.]]
+ return: const(list<Elm.Widget.Item>); [[An $list of list items, #Elm.Widget.Item, or $NULL on failure.]]
}
}
@property last_item {
This returns the last item in the list.]]
- return: Elm.Widget.Item *; [[The last item, or NULL if none]]
+ return: Elm.Widget.Item; [[The last item, or NULL if none]]
}
}
item_insert_before {
application dynamically allocated the label, the application should free the
label after this call.]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in before: Elm.Widget.Item *; [[The list item to insert before.]]
+ @in before: Elm.Widget.Item; [[The list item to insert before.]]
@in label: const(char)*; [[The label of the list item.]]
- @in icon: Evas.Object * @optional; [[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().]]
- @in end: Evas.Object * @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
+ @in icon: Evas.Object @optional; [[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().]]
+ @in end: Evas.Object @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
@in data: const(void)* @optional; [[The data to associate with the item for related callbacks.]]
}
application dynamically allocated the label, the application should free the
label after this call.]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in after: Elm.Widget.Item *; [[The list item to insert after.]]
+ @in after: Elm.Widget.Item; [[The list item to insert after.]]
@in label: const(char)*; [[The label of the list item.]]
- @in icon: Evas.Object * @optional; [[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().]]
- @in end: Evas.Object * @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
+ @in icon: Evas.Object @optional; [[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().]]
+ @in end: Evas.Object @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
@in data: const(void)* @optional; [[The data to associate with the item for related callbacks.]]
}
based if the coordinate is above or below all items respectively in
the list.]]
- return: Elm.Widget.Item *; [[The item at the coordinates or NULL if none]]
+ return: Elm.Widget.Item; [[The item at the coordinates or NULL if none]]
params {
@in x: Evas.Coord; [[The input x coordinate]]
@in y: Evas.Coord; [[The input y coordinate]]
@see elm_icon_add()
*/
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
@in label: const(char)*; [[The label of the list item.]]
- @in icon: Evas.Object * @optional; [[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().]]
- @in end: Evas.Object * @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
+ @in icon: Evas.Object @optional; [[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().]]
+ @in end: Evas.Object @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
@in data: const(void)* @optional; [[The data to associate with the item for related callbacks.]]
}
application dynamically allocated the label, the application should free the
label after this call.]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
@in label: const(char)*; [[The label of the list item.]]
- @in icon: Evas.Object * @optional; [[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().]]
- @in end: Evas.Object * @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
+ @in icon: Evas.Object @optional; [[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().]]
+ @in end: Evas.Object @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
@in data: const(void)* @optional; [[The data to associate with the item for related callbacks.]]
}
application dynamically allocated the label, the application should free the
label after this call.]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
@in label: const(char)*; [[The label of the list item.]]
- @in icon: Evas.Object * @optional; [[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().]]
- @in end: Evas.Object * @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
+ @in icon: Evas.Object @optional; [[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().]]
+ @in end: Evas.Object @optional; [[The icon object to use for the right side of the item. An icon can be any Evas object.]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
@in data: const(void)* @optional; [[The data to associate with the item for related callbacks.]]
@in cmp_func: Eina_Compare_Cb; [[The comparing function to be used to sort list
]]
}
values {
- obj: Evas.Object *; [[The base Edje object associated with the item.]]
+ obj: Evas.Object; [[The base Edje object associated with the item.]]
}
}
@property prev {
legacy: elm_list_item_prev;
}
values {
- item: Elm.Widget.Item *; [[The item before or $null.]]
+ item: Elm.Widget.Item; [[The item before or $null.]]
}
}
@property next {
legacy: elm_list_item_next;
}
values {
- item: Elm.Widget.Item *; [[The item after or $null.]]
+ item: Elm.Widget.Item; [[The item after or $null.]]
}
}
/* init { FIXME
@since 1.7
]]
- return: list<Elm_Map_Overlay *> *; [[The list of all overlays or $null upon failure.]]
+ return: list<Elm_Map_Overlay *>; [[The list of all overlays or $null upon failure.]]
}
}
@property tile_load_status {
}
track_add {
[[Add a track on the map.]]
- return: Evas.Object *; [[The route object. This is an elm object of type Route.]]
+ return: Evas.Object; [[The route object. This is an elm object of type Route.]]
params {
@in emap: void *; [[The emap route object.]]
}
track_remove {
[[Remove a track from the map.]]
params {
- @in route: Evas.Object *; [[The track to remove.]]
+ @in route: Evas.Object; [[The track to remove.]]
}
}
overlay_route_add {
@property selected_item {
get {
[[Get the selected item in the menu.]]
- return: Elm.Widget.Item *; [[The selected item or $null.]]
+ return: Elm.Widget.Item; [[The selected item or $null.]]
}
}
@property items {
get {
[[Returns a list of the item's items.]]
- return: const(list<Elm.Widget.Item *>)*;
+ return: const(list<Elm.Widget.Item>);
}
}
@property first_item {
get {
[[Get the first item in the menu.]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
}
}
@property last_item {
get {
[[Get the last item in the menu.]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
}
}
move {
Note: This function does not accept relative icon path.
]]
- return: Elm.Widget.Item *; [[The new menu item.]]
+ return: Elm.Widget.Item; [[The new menu item.]]
params {
- @in parent: Elm.Widget.Item * @optional; [[The parent menu item (optional).]]
+ @in parent: Elm.Widget.Item @optional; [[The parent menu item (optional).]]
@in icon: const(char)* @optional; [[An icon display on the item. The icon will be destroyed by the menu.]]
@in label: const(char)*; [[The label of the item.]]
@in func: Evas_Smart_Cb @optional; [[Function called when the user select the item.]]
}
item_separator_add {
[[Add a separator item to menu $obj under $parent.]]
- return: Elm.Widget.Item *; [[The created item or $null.]]
+ return: Elm.Widget.Item; [[The created item or $null.]]
params {
- @in parent: Elm.Widget.Item *; [[The item to add the separator under.]]
+ @in parent: Elm.Widget.Item; [[The item to add the separator under.]]
}
}
}
}
prev_get @const {
[[Get the previous item in the menu.]]
- return: Elm.Widget.Item*;
+ return: Elm.Widget.Item;
}
next_get @const {
[[Get the next item in the menu.]]
- return: Elm.Widget.Item*;
+ return: Elm.Widget.Item;
}
index_get @const {
[[Get the next item in the menu.]]
}
subitems_get @const {
[[Returns a list of $item's subitems.]]
- return: const (list<Elm.Widget.Item *>) *; [[a list of $item's subitems]]
+ return: const(list<Elm.Widget.Item>); [[a list of $item's subitems]]
}
is_separator @const {
[[Returns whether $item is a separator.]]
Warning: Don't manipulate this object!
]]
- return: Evas.Object*; [[The base Edje object containing the
+ return: Evas.Object; [[The base Edje object containing the
swallowed content associated with the item.]]
}
}
get {
[[Get a list of items in the multibuttonentry]]
- return: const(list<Elm.Widget.Item *>)*; [[The list of items, or NULL if none]]
+ return: const(list<Elm.Widget.Item>); [[The list of items, or NULL if none]]
}
}
@property first_item {
get {
[[Get the first item in the multibuttonentry]]
- return: Elm.Widget.Item *; [[The first item, or NULL if none]]
+ return: Elm.Widget.Item; [[The first item, or NULL if none]]
}
}
@property last_item {
get {
[[Get the last item in the multibuttonentry]]
- return: Elm.Widget.Item *; [[The last item, or NULL if none]]
+ return: Elm.Widget.Item; [[The last item, or NULL if none]]
}
}
@property entry {
get {
[[Get the entry of the multibuttonentry object]]
- return: Evas.Object *; [[The entry object, or NULL if none]]
+ return: Evas.Object; [[The entry object, or NULL if none]]
}
}
@property selected_item {
get {
[[Get the selected item in the multibuttonentry]]
- return: Elm.Widget.Item *; [[The selected item, or NULL if none]]
+ return: Elm.Widget.Item; [[The selected item, or NULL if none]]
}
}
item_prepend {
See @Elm.Widget.Item.del to delete the item.]]
- return: Elm.Widget.Item *; [[A handle to the item added or NULL if not possible]]
+ return: Elm.Widget.Item; [[A handle to the item added or NULL if not possible]]
params {
@in label: const(char)*; [[The label of new item]]
@in func: Evas_Smart_Cb @optional; [[The callback function to be invoked when this item is pressed.]]
See @Elm.Widget.Item.del to delete the item.]]
- return: Elm.Widget.Item *; [[A handle to the item added or NULL if not possible]]
+ return: Elm.Widget.Item; [[A handle to the item added or NULL if not possible]]
params {
- @in before: Elm.Widget.Item *; [[The item before which to add it]]
+ @in before: Elm.Widget.Item; [[The item before which to add it]]
@in label: const(char)*; [[The label of new item]]
@in func: Evas_Smart_Cb @optional; [[The callback function to be invoked when this item is pressed.]]
@in data: void * @optional; [[The pointer to the data to be attached]]
See @Elm.Widget.Item.del to delete the item.]]
- return: Elm.Widget.Item *; [[A handle to the item added or NULL if not possible]]
+ return: Elm.Widget.Item; [[A handle to the item added or NULL if not possible]]
params {
@in label: const(char)*; [[The label of new item]]
@in func: Evas_Smart_Cb @optional; [[The callback function to be invoked when this item is pressed.]]
See @Elm.Widget.Item.del to delete the item.]]
- return: Elm.Widget.Item *; [[A handle to the item added or NULL if not possible]]
+ return: Elm.Widget.Item; [[A handle to the item added or NULL if not possible]]
params {
- @in after: Elm.Widget.Item *; [[The item after which to add it]]
+ @in after: Elm.Widget.Item; [[The item after which to add it]]
@in label: const(char)*; [[The label of new item]]
@in func: Evas_Smart_Cb @optional; [[The callback function to be invoked when this item is pressed.]]
@in data: void * @optional; [[The pointer to the data to be attached]]
}
prev_get @const {
[[Get the previous item in the multibuttonentry]]
- return: Elm.Widget.Item *; [[The item before the item]]
+ return: Elm.Widget.Item; [[The item before the item]]
}
next_get @const {
[[Get the next item in the multibuttonentry]]
- return: Elm.Widget.Item *; [[The item after the item]]
+ return: Elm.Widget.Item; [[The item after the item]]
}
}
implements {
get {
[[Get a list of all the naviframe items.]]
- return: free(own(list<Elm.Widget.Item *> *), eina_list_free) @warn_unused; [[A list of naviframe items, @Elm.Widget.Item, or $NULL on failure. Note: The returned list MUST be freed.]]
+ return: free(own(list<Elm.Widget.Item>), eina_list_free) @warn_unused; [[A list of naviframe items, @Elm.Widget.Item, or $NULL on failure. Note: The returned list MUST be freed.]]
}
}
@property top_item {
get {
[[Get a top item on the naviframe stack]]
- return: Elm.Widget.Item *; [[The top item on the naviframe stack or $NULL, if the stack is empty]]
+ return: Elm.Widget.Item; [[The top item on the naviframe stack or $NULL, if the stack is empty]]
}
}
@property bottom_item {
get {
[[Get a bottom item on the naviframe stack]]
- return: Elm.Widget.Item *; [[The bottom item on the naviframe stack or $NULL, if the stack is empty]]
+ return: Elm.Widget.Item; [[The bottom item on the naviframe stack or $NULL, if the stack is empty]]
}
}
item_pop {
is complete.
]]
- return: Evas.Object *; [[$NULL or the content object(if the elm_naviframe_content_preserve_on_pop_get is true).]]
+ return: Evas.Object; [[$NULL or the content object(if the elm_naviframe_content_preserve_on_pop_get is true).]]
}
item_insert_before {
[[Insert a new item into the naviframe before item $before.
The item is inserted into the naviframe straight away without any
transition operations. This item will be deleted when it is popped.]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in before: Elm.Widget.Item *; [[The naviframe item to insert before.]]
+ @in before: Elm.Widget.Item; [[The naviframe item to insert before.]]
@in title_label: const(char)* @optional; [[The label in the title area. The name of the title label part is "elm.text.title"]]
- @in prev_btn: Evas.Object * @nullable; [[The button to go to the previous item. If it is NULL, then naviframe will create a back button automatically. The name of the prev_btn part is "elm.swallow.prev_btn"]]
- @in next_btn: Evas.Object * @nullable; [[The button to go to the next item. Or It could be just an extra function button. The name of the next_btn part is "elm.swallow.next_btn"]]
- @in content: Evas.Object *; [[The main content object. The name of content part is "elm.swallow.content"]]
+ @in prev_btn: Evas.Object @nullable; [[The button to go to the previous item. If it is NULL, then naviframe will create a back button automatically. The name of the prev_btn part is "elm.swallow.prev_btn"]]
+ @in next_btn: Evas.Object @nullable; [[The button to go to the next item. Or It could be just an extra function button. The name of the next_btn part is "elm.swallow.next_btn"]]
+ @in content: Evas.Object; [[The main content object. The name of content part is "elm.swallow.content"]]
@in item_style: const(char)* @nullable; [[The current item style name. $NULL would be default.]]
}
}
The following styles are available for this item:
"default"]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
@in title_label: const(char)* @optional; [[The label in the title area. The name of the title label part is "elm.text.title"]]
- @in prev_btn: Evas.Object * @nullable; [[The button to go to the previous item. If it is NULL, then naviframe will create a back button automatically. The name of the prev_btn part is "elm.swallow.prev_btn"]]
- @in next_btn: Evas.Object * @nullable; [[The button to go to the next item. Or It could be just an extra function button. The name of the next_btn part is "elm.swallow.next_btn"]]
- @in content: Evas.Object *; [[The main content object. The name of content part is "elm.swallow.content"]]
+ @in prev_btn: Evas.Object @nullable; [[The button to go to the previous item. If it is NULL, then naviframe will create a back button automatically. The name of the prev_btn part is "elm.swallow.prev_btn"]]
+ @in next_btn: Evas.Object @nullable; [[The button to go to the next item. Or It could be just an extra function button. The name of the next_btn part is "elm.swallow.next_btn"]]
+ @in content: Evas.Object; [[The main content object. The name of content part is "elm.swallow.content"]]
@in item_style: const(char)* @nullable; [[The current item style name. $NULL would be default.]]
}
}
[[Simple version of item_promote.]]
params {
- @in content: Evas.Object *;
+ @in content: Evas.Object;
}
}
item_insert_after {
The following styles are available for this item:
"default"]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in after: Elm.Widget.Item *; [[The naviframe item to insert after.]]
+ @in after: Elm.Widget.Item; [[The naviframe item to insert after.]]
@in title_label: const(char)* @optional; [[The label in the title area. The name of the title label part is "elm.text.title"]]
- @in prev_btn: Evas.Object * @nullable; [[The button to go to the previous item. If it is NULL, then naviframe will create a back button automatically. The name of the prev_btn part is "elm.swallow.prev_btn"]]
- @in next_btn: Evas.Object * @nullable; [[The button to go to the next item. Or It could be just an extra function button. The name of the next_btn part is "elm.swallow.next_btn"]]
- @in content: Evas.Object *; [[The main content object. The name of content part is "elm.swallow.content"]]
+ @in prev_btn: Evas.Object @nullable; [[The button to go to the previous item. If it is NULL, then naviframe will create a back button automatically. The name of the prev_btn part is "elm.swallow.prev_btn"]]
+ @in next_btn: Evas.Object @nullable; [[The button to go to the next item. Or It could be just an extra function button. The name of the next_btn part is "elm.swallow.next_btn"]]
+ @in content: Evas.Object; [[The main content object. The name of content part is "elm.swallow.content"]]
@in item_style: const(char)* @nullable; [[The current item style name. $NULL would be default.]]
}
}
modify it. It is for inspection only, and hooking callbacks
to. Nothing else. It may be deleted at any time as well.
]]
- return: Evas.Object *; [[The internal image object handle or $null]]
+ return: Evas.Object; [[The internal image object handle or $null]]
}
}
@property image_size {
Note: Be careful to not manipulate it, as it is under control of
elementary.
]]
- return: Evas.Object *; [[The inlined image object or $null.]]
+ return: Evas.Object; [[The inlined image object or $null.]]
}
}
connect {
only one of content, content-text and item(s) can be there
in a popup content area.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
params {
@in label: const(char)*; [[The Label of the new item.]]
- @in icon: Evas.Object * @optional; [[Icon to be set on new item.]]
+ @in icon: Evas.Object @optional; [[Icon to be set on new item.]]
@in func: Evas_Smart_Cb @optional; [[Convenience function called when item selected.]]
@in data: const(void)* @optional; [[Data passed to $func above.]]
}
@since 1.8]]
- return: const(Evas.Object)*; [[A valid widget handle, on success, or $NULL, otherwise]]
+ return: const(Evas.Object); [[A valid widget handle, on success, or $NULL, otherwise]]
params {
@in name: const(char)*; [[The name of the item (as declared in the prefs collection) to get object from]]
}
return: bool; [[$true, on success, $false otherwise]]
params {
@in name: const(char)*; [[the name of the SWALLOW item (as declared in the prefs collection)]]
- @in child: Evas.Object *; [[The object to occupy the item]]
+ @in child: Evas.Object; [[The object to occupy the item]]
}
}
item_editable_set {
@since 1.8]]
- return: Evas.Object *; [[The unswallowed object, or NULL on errors]]
+ return: Evas.Object; [[The unswallowed object, or NULL on errors]]
params {
@in name: const(char)*; [[the name of the SWALLOW item (as declared in the prefs collection)]]
}
@property selected_object {
get {
[[Get the selected radio object.]]
- return: Evas.Object *; [[The selected radio object]]
+ return: Evas.Object; [[The selected radio object]]
}
}
group_add {
]]
params {
- @in group: Elm.Radio *; [[Any radio object whose group the obj is
- to join.]]
+ @in group: Elm.Radio; [[Any radio object whose group the obj is
+ to join.]]
}
}
}
The selected item always will be highlighted on segment control.]]
- return: Elm.Widget.Item *; [[The selected item or $NULL if none of segment items is selected.]]
+ return: Elm.Widget.Item; [[The selected item or $NULL if none of segment items is selected.]]
}
}
icon and label, even that an empty string, icon will be smaller and
positioned at left.]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in icon: Evas.Object * @optional; [[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().]]
+ @in icon: Evas.Object @optional; [[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().]]
@in label: const(char)* @optional; [[The label of the item.]]
@in idx: int; [[Item position. Value should be between 0 and items count.]]
}
Count is the number of items, that can be get with
elm_segment_control_item_count_get().]]
- return: Elm.Widget.Item *; [[The segment control item or $NULL on failure.]]
+ return: Elm.Widget.Item; [[The segment control item or $NULL on failure.]]
params {
@in idx: int; [[The index of the segment item.]]
}
evas_object_show(sc);
@endcode */
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in icon: Evas.Object * @optional; [[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().]]
+ @in icon: Evas.Object @optional; [[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().]]
@in label: const(char)* @optional; [[The label of the item. Note that, NULL is different from empty string "".]]
}
}
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 $NULL.]]
- return: Evas.Object *; [[The left side icon associated to the item at $index.]]
+ return: Evas.Object; [[The left side icon associated to the item at $index.]]
params {
@in idx: int; [[The index of the segment item.]]
}
[[Get the real Evas(Edje) object created to implement the view of a given segment_control item.
Base object is the @Evas.Object that represents that item.]]
- return: Evas.Object*; [[The base Edje object associated with $it]]
+ return: Evas.Object; [[The base Edje object associated with $it]]
}
selected_set {
[[Set the selected state of an item.
items list is changed. It should be fetched again with another
call to this function when changes happen.
]]
- return: const(list<Elm.Widget.Item *>)*; [[
+ return: const(list<Elm.Widget.Item>); [[
The list of items (#Elm.Widget.Item as data) or $null on
errors.
]]
is valid and has not internally changed its list for some
reason, so make a copy if you need it around.
]]
- return: const(list<const(char)*>)*; [[
+ return: const(list<const(char)*>); [[
The list of transitions (list of stringshared strings
as data).
]]
@property item_current {
get {
[[Returns the currently displayed item, in a given slideshow widget.]]
- return: Elm.Widget.Item *; [[A handle to the item being displayed
+ return: Elm.Widget.Item; [[A handle to the item being displayed
in $obj or $null, if none is (and
on errors)]]
}
like to use them out of this call's context, you'd better
\@ref eina_stringshare_ref them.
]]
- return: const(list<const(char)*>)*; [[
+ return: const(list<const(char)*>); [[
The list of layouts (list of stringshared strings as data)
]]
}
[[Get the the item, in a given slideshow widget, placed at
position $nth, in its internal items list.
]]
- return: Elm.Widget.Item *; [[The item stored in $obj at position
+ return: Elm.Widget.Item; [[The item stored in $obj at position
$nth or $null if there's no item with
that index (and on errors).]]
params {
parameter is going to be passed to both class functions of the
item.
]]
- return: Elm.Widget.Item *; [[A handle to the item added or $null on errors.]]
+ return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
params {
@in itc: const(Elm_Slideshow_Item_Class)*; [[The item class for the item.]]
@in data: const(void)*; [[The item's data.]]
Elementary photo, for example. The $data parameter is going to
be passed to both class functions of the item.
]]
- return: Elm.Widget.Item *; [[Returns The slideshow item handle,
+ return: Elm.Widget.Item; [[Returns The slideshow item handle,
on success, or $null on errors.]]
params {
@in itc: const(Elm_Slideshow_Item_Class)*; [[The item class for the item.]]
lower level callbacks for events on that object. Do not delete
this object under any circumstances.]]
- return: Evas.Object*;
+ return: Evas.Object;
}
}
implements {
@since 1.17
]]
- return: Elm.Sys_Notify *; [[The unique notification manager]]
+ return: Elm.Sys_Notify; [[The unique notification manager]]
}
}
[[Get the object path of the D-Bus Menu currently in use.]]
}
values {
- menu: const(Eo.Base)* @nullable;
+ menu: const(Eo.Base) @nullable;
}
}
@property att_icon_name {
}
child_get @const {
[[Get child object of table at given coordinates.]]
- return: Evas.Object *; [[Child of object if find if not return $null.]]
+ return: Evas.Object; [[Child of object if find if not return $null.]]
params {
@in col: int; [[Column number of child object.]]
@in row: int; [[Row number of child object.]]
means only takes that 1 cell.
]]
params {
- @in subobj: Evas.Object *; [[The subobject to be modified in the table.]]
+ @in subobj: Evas.Object; [[The subobject to be modified in the table.]]
@in column: int; [[Column number.]]
@in row: int; [[Row number.]]
@in colspan: int;
pack_get {
[[Get the packing location of an existing child of the table.]]
params {
- @in subobj: Evas.Object *; [[The subobject to be modified in the table.]]
+ @in subobj: Evas.Object; [[The subobject to be modified in the table.]]
@out column: int; [[Column number.]]
@out row: int; [[Row number.]]
@out colspan: int;
unpack {
[[Remove child from table.]]
params {
- @in subobj: Evas.Object *; [[The subobject.]]
+ @in subobj: Evas.Object; [[The subobject.]]
}
}
pack {
able to fit in 16bits will result in failure.
]]
params {
- @in subobj: Evas.Object *; [[The subobject to be added to the table.]]
+ @in subobj: Evas.Object; [[The subobject to be added to the table.]]
@in column: int; [[Column number.]]
@in row: int; [[Row number.]]
@in colspan: int;
get {
}
values {
- parent: Evas.Object *; [[The parent of the menu objects.]]
+ parent: Evas.Object; [[The parent of the menu objects.]]
}
}
@property standard_priority {
The selected item always will be highlighted on toolbar.]]
- return: Elm.Widget.Item *; [[The selected toolbar item.]]
+ return: Elm.Widget.Item; [[The selected toolbar item.]]
}
}
@property first_item {
See: @.item_append and @.last_item]]
- return: Elm.Widget.Item *; [[The first item or $NULL, if it has no items (and on errors)]]
+ return: Elm.Widget.Item; [[The first item or $NULL, if it has no items (and on errors)]]
}
}
@property more_item {
The more item can be manipulated by elm_object_item_text_set() and
elm_object_item_content_set.]]
- return: Elm.Widget.Item *; [[The toolbar more item.]]
+ return: Elm.Widget.Item; [[The toolbar more item.]]
}
}
@property last_item {
[[Get the last item in the given toolbar widget's list of items.
See: @.item_prepend and @.first_item]]
- return: Elm.Widget.Item *; [[The last item or $NULL, if it has no items (and on errors)]]
+ return: Elm.Widget.Item; [[The last item or $NULL, if it has no items (and on errors)]]
}
}
item_insert_before {
See: elm_toolbar_item_icon_set()]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in before: Elm.Widget.Item *; [[The toolbar item to insert before.]]
+ @in before: Elm.Widget.Item; [[The toolbar item to insert before.]]
@in icon: const(char)* @optional; [[A string with icon name or the absolute path of an image file.]]
@in label: const(char)*; [[The label of the item.]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
See: elm_toolbar_item_icon_set()]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
- @in after: Elm.Widget.Item *; [[The toolbar item to insert after.]]
+ @in after: Elm.Widget.Item; [[The toolbar item to insert after.]]
@in icon: const(char)* @optional; [[A string with icon name or the absolute path of an image file.]]
@in label: const(char)*; [[The label of the item.]]
@in func: Evas_Smart_Cb @optional; [[The function to call when the item is clicked.]]
See: elm_toolbar_item_icon_set()]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
@in icon: const(char)* @optional; [[A string with icon name or the absolute path of an image file.]]
@in label: const(char)*; [[The label of the item.]]
See: elm_toolbar_item_icon_set()]]
- return: Elm.Widget.Item *; [[The created item or $NULL upon failure.]]
+ return: Elm.Widget.Item; [[The created item or $NULL upon failure.]]
params {
@in icon: const(char)* @optional; [[A string with icon name or the absolute path of an image file.]]
@in label: const(char)*; [[The label of the item.]]
item_find_by_label @const {
[[Returns a pointer to a toolbar item by its label.]]
- return: Elm.Widget.Item *; [[The pointer to the toolbar item matching $label or $NULL on failure.]]
+ return: Elm.Widget.Item; [[The pointer to the toolbar item matching $label or $NULL on failure.]]
params {
@in label: const(char)*; [[The label of the item to find.]]
}
]]
label: const(char)*;
icon_str: const(char)*;
- icon: Evas.Object *;
+ icon: Evas.Object;
func: Evas_Smart_Cb ;
data: const(void)*;
}
]]
}
values {
- item: Elm.Widget.Item *; [[The item before $item, or $null
+ item: Elm.Widget.Item; [[The item before $item, or $null
if none or on failure.]]
}
}
]]
}
values {
- item: Elm.Widget.Item *; [[The item after $item, or $null
+ item: Elm.Widget.Item; [[The item after $item, or $null
if none or on failure.]]
}
}
]]
}
values {
- obj: Evas.Object *; [[The base Edje object associated with $it.]]
+ obj: Evas.Object; [[The base Edje object associated with $it.]]
}
}
@property icon_object {
]]
}
values {
- obj: Evas.Object *; [[The icon object.]]
+ obj: Evas.Object; [[The icon object.]]
}
}
@property separator {
]]
}
values {
- menu: Evas.Object *; [[Item's menu object or $null on failure.]]
+ menu: Evas.Object; [[Item's menu object or $null on failure.]]
}
}
@property state {
@property emotion {
get {
[[Get the underlying Emotion object.]]
- return: Evas.Object *; [[the underlying Emotion object.]]
+ return: Evas.Object; [[the underlying Emotion object.]]
}
}
@property is_seekable {
@since 1.11
]]
params {
- @in model: Efl.Model*; [[Emodel object]]
+ @in model: Efl.Model; [[Emodel object]]
}
}
widget_add {
]]
params {
@in propname: const(char)*; [[Property name]]
- @in evas: Evas.Object *; [[Evas widget]]
+ @in evas: Evas.Object; [[Evas widget]]
}
}
}
@since 1.11
]]
params {
- @in genlist: Evas.Object*; [[Genlist object]]
+ @in genlist: Evas.Object; [[Genlist object]]
@in item_type: Elm.Genlist.Item.Type; [[Item type]]
@in item_style: const(char)*; [[The current item style name. $null would be default.]]
}
@since 1.11
]]
params {
- @out widget: Evas.Object*; [[Returned widget]]
+ @out widget: Evas.Object; [[Returned widget]]
}
}
property_connect {
@since 1.11
]]
params {
- @in model: Efl.Model *; [[New Emodel to set]]
+ @in model: Efl.Model; [[New Emodel to set]]
}
}
model_unset {
@since 1.11
]]
params {
- @out model: Efl.Model *; [[Returned Emodel]]
+ @out model: Efl.Model; [[Returned Emodel]]
}
}
}
return the internal reference. Be careful using it as it may
interfere with elm_web behavior.
]]
- return: Evas.Object *; [[The internal ewk_view object or $null
+ return: Evas.Object; [[The internal ewk_view object or $null
if it does not exist. (Failure to
create or Elementary compiled
without ewebkit)]]
the list of objects. The previous list will be deleted and this list
will be managed by elementary. After it is set, don't modify it.]]
values {
- objs: list<Evas.Object*>*; [[Chain of objects to pass focus]]
+ objs: list<Evas.Object>; [[Chain of objects to pass focus]]
}
}
get {
values {
- objs: const(list<Evas.Object*>)*; [[Chain of objects]]
+ objs: const(list<Evas.Object>); [[Chain of objects]]
}
}
}
legacy: elm_widget_parent_get; /* Needed because we don't do duplication removal for legacy names. */
}
values {
- parent: Evas.Object * @nullable;
+ parent: Evas.Object @nullable;
}
}
@property access_info {
return: bool;
}
values {
- edj: Evas.Object *;
+ edj: Evas.Object;
wname: const(char)*;
welement: const(char)*;
wstyle: const(char)*;
set {
}
values {
- sobj: Evas.Object * @nullable;
+ sobj: Evas.Object @nullable;
}
}
@property display_mode {
set {
}
values {
- sobj: Evas.Object * @nullable;
+ sobj: Evas.Object @nullable;
sub_obj: bool;
}
}
[[Function to operate on a given widget's scrollabe children when necessary.
Warning: free the returned list with eina_list_free().]]
- return: free(own(list<Evas.Object *> *), eina_list_free) @warn_unused;
+ return: free(own(list<Evas.Object>), eina_list_free) @warn_unused;
}
}
@property scroll_hold {
}
@property top {
get {
- return: Evas.Object *;
+ return: Evas.Object;
}
}
@property focus_order {
}
@property can_focus_child_list {
get {
- return: free(own(list<Evas.Object *> *), eina_list_free) @warn_unused;
+ return: free(own(list<Evas.Object>), eina_list_free) @warn_unused;
}
}
@property focused_item {
get {
[[Get the focused widget item.]]
- return: Elm.Widget.Item *;
+ return: Elm.Widget.Item;
}
}
@property parents_bounce {
}
@property parent_widget {
get @virtual_pure {
- return: Evas.Object *;
+ return: Evas.Object;
legacy: null;
}
}
@property focused_object {
[[Current focused object in object tree.]]
get {
- return: Evas.Object *; [[Current focused or $null, if there is no focused object.]]
+ return: Evas.Object; [[Current focused or $null, if there is no focused object.]]
}
}
@property parent2 {
get {
}
values {
- parent: Evas.Object * @nullable;
+ parent: Evas.Object @nullable;
}
}
@property part_text {
}
}
newest_focus_order_get @const {
- return: Evas.Object *;
+ return: Evas.Object;
params {
@out newest_focus_order: uint;
@in can_focus_only: bool;
@since 1.8]]
params {
- @in next: Evas.Object * @nullable; [[Focus next object]]
+ @in next: Evas.Object @nullable; [[Focus next object]]
@in dir: Elm.Focus_Direction; [[Focus direction]]
}
}
[[Get the next object with specific focus direction.
@since 1.8]]
- return: Evas.Object *; [[Focus next object]]
+ return: Evas.Object; [[Focus next object]]
params {
@in dir: Elm.Focus_Direction; [[Focus direction]]
}
@since 1.16]]
params {
- @in next_item: Elm.Widget.Item * @nullable; [[Focus next object item]]
+ @in next_item: Elm.Widget.Item @nullable; [[Focus next object item]]
@in dir: Elm.Focus_Direction; [[Focus direction]]
}
}
[[Get the next object item with specific focus direction.
@since 1.16]]
- return: Elm.Widget.Item *; [[Focus next object item]]
+ return: Elm.Widget.Item; [[Focus next object item]]
params {
@in dir: Elm.Focus_Direction; [[Focus direction]]
}
Note: On focus cycle, only will be evaluated children of this container.]]
params {
- @in child: Evas.Object *; [[The child to be added in custom chain.]]
- @in relative_child: Evas.Object * @optional; [[The relative object to position the child.]]
+ @in child: Evas.Object; [[The child to be added in custom chain.]]
+ @in relative_child: Evas.Object @optional; [[The relative object to position the child.]]
}
}
part_text_translate {
[['Virtual' function handling sub objects being added.]]
return: bool;
params {
- @in sobj: Evas.Object *;
+ @in sobj: Evas.Object;
}
}
focus_direction_manager_is {
event {
[['Virtual' function handling input events on the widget.]]
params {
- @in source: Evas.Object *;
+ @in source: Evas.Object;
@in type: Evas.Callback_Type;
@in event_info: void *;
}
on_focus {
[['Virtual' function handling focus in/out events on the widget. return true if this widget can handle focus, false otherwise]]
params {
- @in item: Elm.Widget.Item * @nullable;
+ @in item: Elm.Widget.Item @nullable;
}
return: bool;
}
focus_direction @virtual_pure {
[['Virtual' function handling passing focus to sub-objects given a direction, in degrees.]]
params {
- @in base: const(Evas.Object)*;
+ @in base: const(Evas.Object);
@in degree: double;
- @out direction: Evas.Object *;
- @out direction_item: Elm.Widget.Item *;
+ @out direction: Evas.Object;
+ @out direction_item: Elm.Widget.Item;
@out weight: double;
}
return: bool;
return: bool;
}
name_find @const {
- return: Evas.Object *;
+ return: Evas.Object;
params {
@in name: const(char)*;
@in recurse: int;
focus_list_direction_get @const {
return: bool;
params {
- @in base: const(Evas.Object)*;
- @in items: const(list<Eo.Base*>)*;
+ @in base: const(Evas.Object);
+ @in items: const(list<Eo.Base>);
@in list_data_get: list_data_get_func_type;
@in degree: double;
- @out direction: Evas.Object *;
- @out direction_item: Elm.Widget.Item *;
+ @out direction: Evas.Object;
+ @out direction_item: Elm.Widget.Item;
@out weight: double;
}
}
return: bool;
params {
@in dir: Elm.Focus_Direction;
- @out next: Evas.Object *;
- @out next_item: Elm.Widget.Item *;
+ @out next: Evas.Object;
+ @out next_item: Elm.Widget.Item;
}
}
translatable_part_text_get @const {
}
focus_steal {
params {
- @in item: Elm.Widget.Item * @nullable;
+ @in item: Elm.Widget.Item @nullable;
}
}
focus_hide_handle {
[['Virtual' function handling passing focus to sub-objects.]]
params {
@in dir: Elm.Focus_Direction;
- @out next: Evas.Object *;
- @out next_item: Elm.Widget.Item *;
+ @out next: Evas.Object;
+ @out next_item: Elm.Widget.Item;
}
return: bool;
}
focus_list_next_get @const {
return: bool;
params {
- @in items: const(list<Eo.Base*>)*;
+ @in items: const(list<Eo.Base>);
@in list_data_get: list_data_get_func_type;
@in dir: Elm.Focus_Direction;
- @out next: Evas.Object *;
- @out next_item: Elm.Widget.Item *;
+ @out next: Evas.Object;
+ @out next_item: Elm.Widget.Item;
}
}
focus_mouse_up_handle {
focus_direction_get @const {
return: bool;
params {
- @in base: const(Evas.Object)*;
+ @in base: const(Evas.Object);
@in degree: double;
- @out direction: Evas.Object *;
- @out direction_item: Elm.Widget.Item *;
+ @out direction: Evas.Object;
+ @out direction_item: Elm.Widget.Item;
@out weight: double;
}
}
[['Virtual' function handling sub objects being removed.]]
return: bool;
params {
- @in sobj: Evas.Object *;
+ @in sobj: Evas.Object;
}
}
tooltip_add {
Note: On focus cycle, only will be evaluated children of this container.]]
params {
- @in child: Evas.Object *; [[The child to be added in custom chain.]]
- @in relative_child: Evas.Object * @optional; [[The relative object to position the child.]]
+ @in child: Evas.Object; [[The child to be added in custom chain.]]
+ @in relative_child: Evas.Object @optional; [[The relative object to position the child.]]
}
}
@property focus_move_policy {
part: const (char) * @nullable; [[The content part name (NULL for the default content)]]
}
values {
- content: Evas.Object *; [[The content of the object item]]
+ content: Evas.Object; [[The content of the object item]]
}
}
@property part_text {
[[Get highlight order
@since 1.8]]
- return: const(list<Evas.Object *>) *;
+ return: const(list<Evas.Object>);
}
access_order_set {
[[Set highlight order
@since 1.8]]
params {
- @in objs: own(list<Evas.Object *> *); [[Order of objects to pass highlight]]
+ @in objs: own(list<Evas.Object>); [[Order of objects to pass highlight]]
}
}
widget_get @const {
Note: This returns the widget object itself that an item belongs to.
Note: Every elm_object_item supports this API]]
- return: Evas.Object*; [[The widget object]]
+ return: Evas.Object; [[The widget object]]
}
del {
[[Delete the given item.]]
params {
part: const (char) *; [[The content part name to unset (NULL for the default content)]]
}
- return: Evas.Object*;
+ return: Evas.Object;
}
part_text_custom_update @protected {
[[Update additional text part content]]
[[Get an accessible object of the object item.
@since 1.8]]
- return: Evas.Object*; [[Accessible object of the object item or NULL for any error]]
+ return: Evas.Object; [[Accessible object of the object item or NULL for any error]]
}
domain_translatable_part_text_set {
[[Set the text for an object item's part, marking it as translatable.
See: @.track_get
@since 1.8]]
- return: Evas.Object*; [[The track object]]
+ return: Evas.Object; [[The track object]]
}
untrack {
[[This retrieve the track object of the item.
[[Register object item as an accessible object.
@since 1.8]]
- return: Evas.Object*; [[Accessible object of the object item or NULL for any error]]
+ return: Evas.Object; [[Accessible object of the object item or NULL for any error]]
}
access_unregister {
[[Unregister accessible object of the object item.
params {
dir: Elm.Focus_Direction; [[Focus direction]]
}
- return: Evas.Object *; [[Focus next object]]
+ return: Evas.Object; [[Focus next object]]
}
focus_next_object_set {
[[Set the next object with specific focus direction.
@since 1.16]]
params {
- next: Evas.Object * @nullable; [[Focus next object]]
+ next: Evas.Object @nullable; [[Focus next object]]
dir: Elm.Focus_Direction; [[Focus direction]]
}
}
params {
dir: Elm.Focus_Direction; [[Focus direction]]
}
- return: Elm.Widget.Item *; [[Focus next object item]]
+ return: Elm.Widget.Item; [[Focus next object item]]
}
focus_next_item_set {
[[Set the next object item with specific focus direction.
@since 1.16]]
params {
- next_item: Elm.Widget.Item * @nullable; [[Focus next object item]]
+ next_item: Elm.Widget.Item @nullable; [[Focus next object item]]
dir: Elm.Focus_Direction; [[Focus direction]]
}
}
@endcode
*/
values {
- icon: Evas.Object* @nullable; [[The Evas image object to use for an icon.]]
+ icon: Evas.Object @nullable; [[The Evas image object to use for an icon.]]
}
}
get {
the object to use for the window icon.
]]
values {
- icon: const(Evas.Object)* @nullable; [[The Evas image object to use for an icon.]]
+ icon: const(Evas.Object) @nullable; [[The Evas image object to use for an icon.]]
}
}
}
@property main_menu {
get {
[[Get the Main Menu of a window.]]
- return: Evas.Object *; [[The Main Menu of the window ($null on error).]]
+ return: Evas.Object; [[The Main Menu of the window ($null on error).]]
}
}
@property window_id {
control of elementary), and use it to do things like get
pixel data, save the image to a file, etc.
]]
- return: Evas.Object *; [[The inlined image object or $null if none exists.]]
+ return: Evas.Object; [[The inlined image object or $null if none exists.]]
}
}
@property name {
struct Eo.Event {
[[Parameter passed in event callbacks holding extra event parameters]]
- object: Eo.Base *; [[The object the event was called on.]]
+ object: Eo.Base; [[The object the event was called on.]]
desc: const(Eo.Event.Description) *; [[The event description.]]
info: void *; [[Extra event information passed by the event caller.]]
}
get {
}
values {
- parent: Eo.Base * @nullable; [[the new parent]]
+ parent: Eo.Base @nullable; [[the new parent]]
}
}
@property name {
If this is not done the class cannot be found up in the object tree.
]]
params {
- klass : const(Eo.Base)*; [[The class identifier to search for]]
+ klass : const(Eo.Base); [[The class identifier to search for]]
}
- return : Eo.Base*;
+ return : Eo.Base;
}
constructor {
[[Call the object's constructor.
Should not be used with #eo_do. Only use it with #eo_do_super.
]]
- return: Eo.Base *; [[The new object created, can be NULL if aborting]]
+ return: Eo.Base; [[The new object created, can be NULL if aborting]]
}
destructor {
[[Call the object's destructor.
}
finalize {
[[Called at the end of #eo_add. Should not be called, just overridden.]]
- return: Eo.Base *; [[The new object created, can be NULL if aborting]]
+ return: Eo.Base; [[The new object created, can be NULL if aborting]]
}
name_find {
[[Find a child object with the given name and return it.
params {
@in search: const(char)*; [[the name search string]]
}
- return: Eo.Base *; [[the first object found]]
+ return: Eo.Base; [[the first object found]]
}
wref_add {
[[Add a new weak reference to obj.
being freed.
]]
params {
- @out wref: Eo.Base *;
+ @out wref: Eo.Base;
}
}
wref_del {
[[Delete the weak reference passed.]]
params {
- @in wref: Eo.Base **;
+ @out wref: Eo.Base;
}
}
@property key_data {
}
set {
values {
- objdata: const(Eo.Base) *; [[the object to set]]
+ objdata: const(Eo.Base); [[the object to set]]
}
}
get {
values {
- objdata: Eo.Base *; [[the object to set]]
+ objdata: Eo.Base; [[the object to set]]
}
}
}
[[Add an event callback forwarder for an event and an object.]]
params {
@in desc: const(Eo.Event.Description)*; [[The description of the event to listen to]]
- @in new_obj: Eo.Base *; [[The object to emit events from]]
+ @in new_obj: Eo.Base; [[The object to emit events from]]
}
}
event_callback_forwarder_del {
[[Remove an event callback forwarder for an event and an object.]]
params {
@in desc: const(Eo.Event.Description)*; [[The description of the event to listen to]]
- @in new_obj: Eo.Base *; [[The object to emit events from]]
+ @in new_obj: Eo.Base; [[The object to emit events from]]
}
}
dbg_info_get {
}
children_iterator_new {
[[Get an iterator on all childrens]]
- return: free(own(iterator<Eo.Base *> *), eina_iterator_free) @warn_unused;
+ return: free(own(iterator<Eo.Base>), eina_iterator_free) @warn_unused;
}
composite_attach @beta {
[[Make an object a composite object of another.
See @.composite_detach, @.composite_part_is.
]]
params {
- @in comp_obj: Eo.Base *; [[the object that will be used to composite the parent.]]
+ @in comp_obj: Eo.Base; [[the object that will be used to composite the parent.]]
}
return: bool; [[$true if successful. $false otherwise.]]
}
See @.composite_attach, @.composite_part_is.
]]
params {
- @in comp_obj: Eo.Base *; [[the object that will be removed from the parent.]]
+ @in comp_obj: Eo.Base; [[the object that will be removed from the parent.]]
}
return: bool; [[$true if successful. $false otherwise.]]
}
EAPI const Eolian_Class *eolian_type_class_get(const Eolian_Type *tp);
/*
- * @brief Get whether the given type is @own.
+ * @brief Get whether the given type is owned.
*
* @param[in] tp the type.
- * @return EINA_TRUE when @c tp is a non-function type and not NULL,
- * EINA_FALSE otherwise.
+ * @return EINA_TRUE when the type is marked owned, EINA_FALSE otherwise.
*
* @ingroup Eolian
*/
* @brief Get whether the given type is const.
*
* @param[in] tp the type.
- * @return EINA_TRUE when @c tp is a non-function type and not NULL,
- * EINA_FALSE otherwise.
+ * @return EINA_TRUE when the type is const, EINA_FALSE otherwise.
*
* @ingroup Eolian
*/
* @param[in] tp the type.
* @return the free func name.
*
- * For pointer types, this returns name of the func used to free the pointer.
- * For other types, this returns NULL.
+ * For pointer, class and complex types, this returns name of the func used
+ * to free the pointer. For other types, this returns NULL.
*
* @ingroup Eolian
*/
return database_expr_eval(expr, mask);
}
case EOLIAN_TYPE_CLASS:
+ case EOLIAN_TYPE_COMPLEX:
return database_expr_eval(expr, EOLIAN_MASK_NULL);
case EOLIAN_TYPE_REGULAR:
{
eina_strbuf_append_char(buf, '*');
if (tp->is_const) eina_strbuf_append(buf, " const");
}
+ if (tp->type == EOLIAN_TYPE_COMPLEX || tp->type == EOLIAN_TYPE_CLASS)
+ eina_strbuf_append(buf, " *");
if (name)
{
- if (tp->type != EOLIAN_TYPE_POINTER)
+ if (tp->type != EOLIAN_TYPE_POINTER &&
+ tp->type != EOLIAN_TYPE_CLASS &&
+ tp->type != EOLIAN_TYPE_COMPLEX)
eina_strbuf_append_char(buf, ' ');
eina_strbuf_append(buf, name);
}
}
static Eolian_Type *
-parse_type_void_base(Eo_Lexer *ls, Eina_Bool noptr)
+parse_type_void(Eo_Lexer *ls)
{
Eolian_Type *def;
- const char *ctype;
Eina_Strbuf *buf;
int line = ls->line_number, col = ls->column;
switch (ls->t.kw)
pline = ls->line_number;
pcol = ls->column;
check_next(ls, '(');
- def = parse_type_void_base(ls, EINA_TRUE);
+ def = parse_type_void(ls);
FILL_BASE(def->base, ls, line, col);
def->is_const = EINA_TRUE;
check_match(ls, ')', '(', pline, pcol);
pcolumn = ls->column;
check_next(ls, '(');
eo_lexer_context_push(ls);
- def = parse_type_void_base(ls, EINA_TRUE);
- if (def->type != EOLIAN_TYPE_POINTER)
+ def = parse_type_void(ls);
+ if (def->type != EOLIAN_TYPE_POINTER &&
+ def->type != EOLIAN_TYPE_COMPLEX &&
+ def->type != EOLIAN_TYPE_CLASS)
{
eo_lexer_context_restore(ls);
- eo_lexer_syntax_error(ls, "pointer type expected");
+ eo_lexer_syntax_error(ls, "ownable type expected");
}
eo_lexer_context_pop(ls);
FILL_BASE(def->base, ls, line, col);
pcolumn = ls->column;
check_next(ls, '(');
eo_lexer_context_push(ls);
- def = parse_type_void_base(ls, EINA_TRUE);
- if (def->type != EOLIAN_TYPE_POINTER)
+ def = parse_type_void(ls);
+ if (def->type != EOLIAN_TYPE_POINTER &&
+ def->type != EOLIAN_TYPE_COMPLEX &&
+ def->type != EOLIAN_TYPE_CLASS)
{
eo_lexer_context_restore(ls);
- eo_lexer_syntax_error(ls, "pointer type expected");
+ eo_lexer_syntax_error(ls, "freeable type expected");
}
eo_lexer_context_pop(ls);
check_next(ls, ',');
int tpid = ls->t.kw;
def->type = EOLIAN_TYPE_REGULAR;
check(ls, TOK_VALUE);
- ctype = eo_lexer_get_c_type(ls->t.kw);
- if (ctype)
+ if (eo_lexer_get_c_type(ls->t.kw))
{
_fill_name(eina_stringshare_ref(ls->t.value.s), &def->full_name,
&def->name, &def->namespaces);
}
}
parse_ptr:
- /* check: complex/class type must always be behind a pointer */
- if (!noptr && ((def->type == EOLIAN_TYPE_CLASS) || (def->type == EOLIAN_TYPE_COMPLEX)))
+ if ((def->type == EOLIAN_TYPE_CLASS) || (def->type == EOLIAN_TYPE_COMPLEX))
{
- if (getenv("EOLIAN_CLASS_NO_PTR"))
- {
- fprintf(stderr, "eolian:%s:%d:%d: pointer around complex/class type '%s'\n",
- def->base.file, line, col, def->full_name);
- if (ls->t.token != '*')
- {
- Eolian_Type *pdef;
- pop_type(ls);
- pdef = push_type(ls);
- FILL_BASE(pdef->base, ls, ls->line_number, ls->column);
- pdef->base_type = def;
- pdef->type = EOLIAN_TYPE_POINTER;
- def = pdef;
- }
- }
- else check(ls, '*');
+ if (ls->t.token == '*')
+ eo_lexer_syntax_error(ls, "pointer to complex/class type");
}
while (ls->t.token == '*')
{
return def;
}
-static Eolian_Type *
-parse_type_void(Eo_Lexer *ls)
-{
- return parse_type_void_base(ls, EINA_FALSE);
-}
-
static Eolian_Typedecl *
parse_typedef(Eo_Lexer *ls)
{
}
get {}
values {
- src: Evas.Object * @nonull; [[Source object to use for the proxy.]]
+ src: Evas.Object @nonull; [[Source object to use for the proxy.]]
}
}
@property source_clip {
set {}
get {}
values {
- scene: Evas.Canvas3D.Scene *; [[3D scene.]]
+ scene: Evas.Canvas3D.Scene; [[3D scene.]]
}
}
}
get {
}
values {
- m: Efl.VG *;
+ m: Efl.VG;
}
}
/* quality {
interpolate {
return: bool;
params {
- @in from: const(Efl.VG)*;
- @in to: const(Efl.VG)*;
+ @in from: const(Efl.VG);
+ @in to: const(Efl.VG);
@in pos_map: double;
}
}
dup {
params {
- @in from: const(Efl.VG)*;
+ @in from: const(Efl.VG);
}
}
}
params {
@in name: const(char)*;
}
- return: Efl.VG *;
+ return: Efl.VG;
}
children_get {
- return: free(own(iterator<Efl.VG *>*), eina_iterator_free) @warn_unused;
+ return: free(own(iterator<Efl.VG>), eina_iterator_free) @warn_unused;
}
}
implements {
get {
}
values {
- f: Efl.VG *;
+ f: Efl.VG;
}
}
@property stroke_fill {
get {
}
values {
- f: Efl.VG *;
+ f: Efl.VG;
}
}
@property stroke_marker {
get {
}
values {
- m: Efl.VG *;
+ m: Efl.VG;
}
}
}
}
internal_remove {
[[No description supplied by the EAPI.]]
- return: Evas.Object *;
+ return: Evas.Object;
legacy: null;
params {
- @in child: Evas.Object *;
+ @in child: Evas.Object;
}
}
layout_flow_vertical {
return: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
$null, on errors]]
params {
- @in child: Evas.Object * @nonull; [[A child Evas object to be made a member of $o.]]
- @in reference: const(Evas.Object)* @nonull; [[The child object to place this new one after.]]
+ @in child: Evas.Object @nonull; [[A child Evas object to be made a member of $o.]]
+ @in reference: const(Evas.Object) @nonull; [[The child object to place this new one after.]]
}
}
remove_all {
[[Get an iterator to walk the list of children of a given box object.
Note: Do not remove or delete objects while walking the list.]]
- return: free(own(iterator<Evas.Object *> *), eina_iterator_free)
+ return: free(own(iterator<Evas.Object>), eina_iterator_free)
@warn_unused; [[An iterator on $o's child objects, on success, or $null, on errors.]]
}
add_to {
This is a helper function that has the same effect of putting a new
box object into $parent by use of evas_object_smart_member_add.]]
- return: Evas.Object * @warn_unused; [[$null on error, a pointer to a new box object on
+ return: Evas.Object @warn_unused; [[$null on error, a pointer to a new box object on
success.]]
}
append {
return: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
$null, on errors.]]
params {
- @in child: Evas.Object * @nonull; [[A child Evas object to be made a member of $o.]]
+ @in child: Evas.Object @nonull; [[A child Evas object to be made a member of $o.]]
}
}
option_property_id_get @const {
return: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
$null, on errors.]]
params {
- @in child: Evas.Object * @nonull; [[A child Evas object to be made a member of $o.]]
+ @in child: Evas.Object @nonull; [[A child Evas object to be made a member of $o.]]
}
}
accessor_new @const {
list of children of a given box object.
Note: Do not remove or delete objects while walking the list.]]
- return: free(own(accessor<Evas.Object *> *), eina_accessor_free)
+ return: free(own(accessor<Evas.Object>), eina_accessor_free)
@warn_unused; [[An accessor on $o's child objects, on success, or $null,
on errors.]]
}
legacy: null;
return: Evas_Object_Box_Option *;
params {
- @in child: Evas.Object *;
+ @in child: Evas.Object;
}
}
option_property_vset {
internal_remove_at {
[[No description supplied by the EAPI.]]
legacy: null;
- return: Evas.Object *;
+ return: Evas.Object;
params {
@in pos: uint;
}
legacy: null;
return: Evas_Object_Box_Option *;
params {
- @in child: Evas.Object *;
+ @in child: Evas.Object;
@in pos: uint;
}
}
return: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
$null, on errors.]]
params {
- @in child: Evas.Object * @nonull; [[A child Evas object to be made a member of $o.]]
- @in reference: const(Evas.Object)* @nonull; [[The child object to place this new one before.]]
+ @in child: Evas.Object @nonull; [[A child Evas object to be made a member of $o.]]
+ @in reference: const(Evas.Object) @nonull; [[The child object to place this new one before.]]
}
}
option_property_name_get @const {
legacy: null;
return: Evas_Object_Box_Option *;
params {
- @in child: Evas.Object *;
- @in reference: const(Evas.Object)*;
+ @in child: Evas.Object;
+ @in reference: const(Evas.Object);
}
}
layout_homogeneous_horizontal {
legacy: null;
return: Evas_Object_Box_Option*;
params {
- @in child: Evas.Object *;
+ @in child: Evas.Object;
}
}
layout_homogeneous_max_size_vertical {
legacy: null;
return: Evas_Object_Box_Option *;
params {
- @in child: Evas.Object *;
- @in reference: const(Evas.Object)*;
+ @in child: Evas.Object;
+ @in reference: const(Evas.Object);
}
}
insert_at {
return: Evas_Object_Box_Option *; [[A box option bound to the recently added box item or
$null, on errors.]]
params {
- @in child: Evas.Object * @nonull; [[A child Evas object to be made a member of $o.]]
+ @in child: Evas.Object @nonull; [[A child Evas object to be made a member of $o.]]
@in pos: uint; [[The numeric position (starting from $0) to place the
new child object at.]]
}
legacy: null;
return: Evas_Object_Box_Option*;
params {
- @in child: Evas.Object *;
+ @in child: Evas.Object;
}
}
remove {
return: bool; [[$true on success, $false otherwise.]]
params {
- @in child: Evas.Object * @nonull; [[The handle to the child object to be removed.]]
+ @in child: Evas.Object @nonull; [[The handle to the child object to be removed.]]
}
}
layout_stack {
In this example the $event_info is exactly a pointer to that
focused rectangle. See the full @ref Example_Evas_Events "example".
*/
- return: Evas.Object * @warn_unused; [[The object that has focus
+ return: Evas.Object @warn_unused; [[The object that has focus
or $null if there is not one.]]
}
}
\@ref evas_object_layer_set, \@ref evas_object_below_get,
\@ref evas_object_above_get.
]]
- return: Evas.Object * @warn_unused; [[A pointer to the highest object
+ return: Evas.Object @warn_unused; [[A pointer to the highest object
on it (if any) or $null otherwise.]]
}
}
See also \@ref evas_object_layer_get, \@ref evas_object_layer_set,
\@ref evas_object_below_get, \@ref evas_object_below_set.
]]
- return: Evas.Object * @warn_unused; [[
+ return: Evas.Object @warn_unused; [[
A pointer to the lowest object on it, if any, or $null
otherwise.
]]
It will not append to the list pass events as hidden objects.
Call eina_list_free on the returned list after usage.
]]
- return: list<Evas.Object *> * @warn_unused;
+ return: list<Evas.Object> @warn_unused;
params {
- @in stop: Evas.Object *; [[An Evas Object where to stop searching.]]
+ @in stop: Evas.Object; [[An Evas Object where to stop searching.]]
@in x: int; [[The horizontal coordinate of the position.]]
@in y: int; [[The vertical coordinate of the position.]]
}
objects, acting only on the ones at the "top level", with
regard to object parenting.
]]
- return: list<Evas.Object *> * @warn_unused; [[
+ return: list<Evas.Object> @warn_unused; [[
The list of Evas objects that are over the given position in $e.
]]
params {
@since 1.15
]]
- return: free(own(list<Eina.Rectangle *> *), evas_render_updates_free)
+ return: free(own(list<Eina.Rectangle *>), evas_render_updates_free)
@warn_unused; [[
A newly allocated list of updated rectangles of the canvas
($Eina.Rectangle structs). Free this list with
objects, acting only on the ones at the "top level", with
regard to object parenting.
]]
- return: Evas.Object * @warn_unused; [[The Evas object that is over all other objects at the given position.]]
+ return: Evas.Object @warn_unused; [[The Evas object that is over all other objects at the given position.]]
params {
@in x: Evas.Coord; [[The horizontal coordinate of the position.]]
@in y: Evas.Coord; [[The vertical coordinate of the position.]]
fontconfig support, and the paths provided at runtime as
explained in \@ref Evas_Font_Path_Group.
]]
- return: list<const(char) *> * @warn_unused; [[
+ return: list<const(char) *> @warn_unused; [[
A newly allocated list of strings. Do not change the
strings. Be sure to call \@ref evas_font_available_list_free
after you're done.
]]
}
objects_in_rectangle_get @const {
- return: list<Evas.Object *> * @warn_unused;
+ return: list<Evas.Object> @warn_unused;
params {
@in x: Evas.Coord;
@in y: Evas.Coord;
name is returned is undefined, so only use this if you can
ensure the object name is unique.
]]
- return: Evas.Object * @warn_unused; [[
+ return: Evas.Object @warn_unused; [[
If successful, the Evas object with the given name. Otherwise,
$null.
]]
}
font_path_list @const {
[[Retrieves the list of font paths used by the given evas.]]
- return: const(list<const(char) *>)* @warn_unused; [[The list of font paths used.]]
+ return: const(list<const(char) *>) @warn_unused; [[The list of font paths used.]]
}
image_cache_reload {
[[Reload the image cache.
See the full @ref Example_Evas_Events "example".
*/
- return: free(own(list<Eina.Rectangle *> *), evas_render_updates_free)
+ return: free(own(list<Eina.Rectangle *>), evas_render_updates_free)
@warn_unused; [[
A newly allocated list of updated rectangles of the canvas
($Eina.Rectangle structs). Free this list with
objects, acting only on the ones at the "top level", with
regard to object parenting.
]]
- return: Evas.Object * @warn_unused; [[
+ return: Evas.Object @warn_unused; [[
The Evas object that is over all other objects at the given
rectangular region.
]]
If the nodes are $null or nodes type mismatch error wrong type of nodes will be generated and returned $false.]]
return: bool; [[$true in frustum, $false otherwise]]
params {
- @in camera_node: Evas.Canvas3D.Node *; [[The given camera node.]]
- @in node: Evas.Canvas3D.Node *; [[The given node.]]
+ @in camera_node: Evas.Canvas3D.Node; [[The given camera node.]]
+ @in node: Evas.Canvas3D.Node; [[The given node.]]
@in key: Evas.Canvas3D.Frustum_Mode;
}
}
attrib: Evas.Canvas3D.Material_Attrib; [[Material attribute ID.]]
}
values {
- texture: Evas.Canvas3D.Texture *; [[The texture set to the attribute.]]
+ texture: Evas.Canvas3D.Texture; [[The texture set to the attribute.]]
}
}
}
[[Set the data of given mesh frame from the given primitive.]]
params {
@in frame: int; [[Specifies data of which frame of given mesh will be set.]]
- @in primitive: Evas.Canvas3D.Primitive *; [[Specifies which data will be set.]]
+ @in primitive: Evas.Canvas3D.Primitive; [[Specifies which data will be set.]]
}
}
@property shader_mode {
frame: int; [[The number of the key frame.]]
}
values {
- material: Evas.Canvas3D.Material *; [[The material to be set to the key frame.]]
+ material: Evas.Canvas3D.Material; [[The material to be set to the key frame.]]
}
}
See also @Evas.Canvas3D.Node.parent_get.]]
params {
- @in member: Evas.Canvas3D.Node *; [[Node object to be added.]]
+ @in member: Evas.Canvas3D.Node; [[Node object to be added.]]
}
}
member_del {
See also @Evas.Canvas3D.Node.member_add.]]
params {
- @in member: Evas.Canvas3D.Node *; [[Member node to be deleted from the given node.]]
+ @in member: Evas.Canvas3D.Node; [[Member node to be deleted from the given node.]]
}
}
[[Get the parent node of the given node.
See also @Evas.Canvas3D.Node.member_add.]]
- return: Evas.Canvas3D.Node *; [[The parent node of the given node.]]
+ return: Evas.Canvas3D.Node; [[The parent node of the given node.]]
}
member_list_get @const {
[[Get the list of member nodes of the given node.
See also @Evas.Canvas3D.Node.member_add.]]
- return: const(list<Evas.Canvas3D.Node *>)*; [[The list of member nodes if any or $null if there are none.]]
+ return: const(list<Evas.Canvas3D.Node>); [[The list of member nodes if any or $null if there are none.]]
}
scene_root_get {
[[Get hash table of scenes using this node as root.]]
- return: hash<Evas.Canvas3D.Object *, uintptr> *; [[ scenes using this node as root. FIXME: Actually a scene, not object.]]
+ return: hash<Evas.Canvas3D.Object, uintptr>; [[ scenes using this node as root. FIXME: Actually a scene, not object.]]
}
position_set {
[[Set the position of the given node.
See also @Evas.Canvas3D.Node.member_add.]]
params {
- @in mesh: Evas.Canvas3D.Mesh *; [[The mesh to be added.]]
+ @in mesh: Evas.Canvas3D.Mesh; [[The mesh to be added.]]
}
}
See also @Evas.Canvas3D.Node.mesh_add.]]
params {
- @in mesh: Evas.Canvas3D.Mesh *; [[The mesh to be deleted.]]
+ @in mesh: Evas.Canvas3D.Mesh; [[The mesh to be deleted.]]
}
}
node, $null will be returned.
See also @Evas.Canvas3D.Node.mesh_add.]]
- return: const(list<Evas.Canvas3D.Mesh *>)*; [[The list of meshes if any, or $null if there're none.]]
+ return: const(list<Evas.Canvas3D.Mesh>); [[The list of meshes if any, or $null if there're none.]]
}
bounding_box_get{
}
values {
// FIXME: Evas_Canvas3D_Camera is necessary, but that introduces a cycle
- camera: Evas.Canvas3D.Object *; [[The camera of the given node if any, or $null if there're none.]]
+ camera: Evas.Canvas3D.Object; [[The camera of the given node if any, or $null if there're none.]]
}
}
See also @Evas.Canvas3D.Node.light.set.]]
}
values {
- light: Evas.Canvas3D.Light *; [[The light of the given node if any, or $null if there're none.]]
+ light: Evas.Canvas3D.Light; [[The light of the given node if any, or $null if there're none.]]
}
}
See also @Evas.Canvas3D.Node.mesh_add.]]
}
keys {
- mesh: Evas.Canvas3D.Mesh *; [[The given mesh.]]
+ mesh: Evas.Canvas3D.Mesh; [[The given mesh.]]
}
values {
frame: int; [[The animation frame number.]]
See also @Evas.Canvas3D.Node.billboard_target.set.]]
}
values {
- target: Evas.Canvas3D.Node *; [[The pointer to target node for billboard object,
- or $null if there're none.]]
+ target: Evas.Canvas3D.Node; [[The pointer to target node for billboard object,
+ or $null if there're none.]]
}
}
@property lod_enable {
[[Notify the object regarding its state change.]]
params {
@in state: Evas.Canvas3D.State; [[State that is changed.]]
- @in ref: Evas.Canvas3D.Object *; [[The Object that caused the change.]]
+ @in ref: Evas.Canvas3D.Object; [[The Object that caused the change.]]
}
}
type_get @const {
Update request for the object.]]
params {
@in state: Evas.Canvas3D.State; [[State that is changed.]]
- @in ref: Evas.Canvas3D.Object *; [[The Object that caused the change.]]
+ @in ref: Evas.Canvas3D.Object; [[The Object that caused the change.]]
}
}
callback_register @virtual_pure {
]]
return: bool;
params {
- @in x: Evas.Real; [[X coordinate of the picking position.]]
- @in y: Evas.Real; [[Y coordinate of the picking position.]]
- @out node: Evas.Canvas3D.Node *; [[Pointer to receive the node contains the picked mesh.]]
- @out mesh: Evas.Canvas3D.Mesh *; [[Pointer to receive the picked mesh.]]
- @out s: Evas.Real; [[Pointer to receive the texture "s" coordinate.]]
- @out t: Evas.Real; [[Pointer to receive the texture "t" coordinate.]]
+ @in x: Evas.Real; [[X coordinate of the picking position.]]
+ @in y: Evas.Real; [[Y coordinate of the picking position.]]
+ @out node: Evas.Canvas3D.Node; [[Pointer to receive the node contains the picked mesh.]]
+ @out mesh: Evas.Canvas3D.Mesh; [[Pointer to receive the picked mesh.]]
+ @out s: Evas.Real; [[Pointer to receive the texture "s" coordinate.]]
+ @out t: Evas.Real; [[Pointer to receive the texture "t" coordinate.]]
}
}
exist @const {
[[Search given node in the given position.]]
- return: Evas.Canvas3D.Node *;
+ return: Evas.Canvas3D.Node;
params {
@in x: Evas.Real; [[X coordinate of the picking position.]]
@in y: Evas.Real; [[Y coordinate of the picking position.]]
- @in node: Evas.Canvas3D.Node *; [[Node for search.]]
+ @in node: Evas.Canvas3D.Node; [[Node for search.]]
}
}
pick_member_list_get @const {
[[Get list of the all root members from scene in the given position.]]
- return: list<Evas.Canvas3D.Node *> *;
+ return: list<Evas.Canvas3D.Node>;
params {
@in x: Evas.Real; [[X coordinate of the picking position.]]
@in y: Evas.Real; [[Y coordinate of the picking position.]]
[[Get the root node of a scene.]]
}
values {
- node: Evas.Canvas3D.Node *; [[A node which will be used as a
- root node for the scene.]]
+ node: Evas.Canvas3D.Node; [[A node which will be used as a
+ root node for the scene.]]
}
}
[[Get the camera node of a scene.]]
}
values {
- node: Evas.Canvas3D.Node *; [[A node which will be used as a
- camera node for the scene.]]
+ node: Evas.Canvas3D.Node; [[A node which will be used as a
+ camera node for the scene.]]
}
}
@property shadows_depth {
]]
params {
- @in source: Evas.Object *; [[Source evas object to be used as
+ @in source: Evas.Object; [[Source evas object to be used as
the texture data.]]
}
}
}
values {
/* FIXME: This is actually wrong, should return Evas. */
- ret: Evas.Common_Interface *;
+ ret: Evas.Common_Interface;
}
}
}
list, but these removals won't be reflected on it.
@since 1.1]]
- return: free(own(list<Evas.Object *> *), eina_list_free) @warn_unused;
+ return: free(own(list<Evas.Object>), eina_list_free) @warn_unused;
}
}
accessor_new @const {
Note: Do not remove or delete objects while walking the list.
@since 1.1]]
- return: free(own(accessor<Evas.Object *> *), eina_accessor_free)
+ return: free(own(accessor<Evas.Object>), eina_accessor_free)
@warn_unused;
}
clear {
Note: Do not remove or delete objects while walking the list.
@since 1.1]]
- return: free(own(iterator<Evas.Object *> *), eina_iterator_free)
+ return: free(own(iterator<Evas.Object>), eina_iterator_free)
@warn_unused;
}
add_to {
@since 1.1]]
- return: Evas.Object * @warn_unused;
+ return: Evas.Object @warn_unused;
}
unpack {
[[Remove child from grid.
return: bool; [[1 on success, 0 on failure.]]
params {
- @in child: Evas.Object * @nonull;
+ @in child: Evas.Object @nonull;
}
}
pack_get @const {
@since 1.1]]
return: bool; [[1 on success, 0 on failure.]]
params {
- @in child: Evas.Object *; [[The grid child to query for coordinates.]]
+ @in child: Evas.Object; [[The grid child to query for coordinates.]]
@out x: int; [[The pointer to where the x coordinate will be returned.]]
@out y: int; [[The pointer to where the y coordinate will be returned.]]
@out w: int; [[The pointer to where the width will be returned.]]
return: bool; [[1 on success, 0 on failure.]]
params {
- @in child: Evas.Object * @nonull; [[The child object to add.]]
+ @in child: Evas.Object @nonull; [[The child object to add.]]
@in x: int; [[The virtual x coordinate of the child.]]
@in y: int; [[The virtual y coordinate of the child.]]
@in w: int; [[The virtual width of the child.]]
*/
}
values {
- clip: Evas.Object * @nonull; [[The object to clip $obj by.]]
+ clip: Evas.Object @nonull; [[The object to clip $obj by.]]
}
}
@property size_hint_padding {
Use this function if you want to change any of this clipper's
properties, like colors.
]]
- return: Evas.Object * @warn_unused;
+ return: Evas.Object @warn_unused;
}
}
@property clipees {
evas_object_show(obj_tmp);
}
@endcode */
- return: const(list<Evas.Object*>)* @warn_unused; [[A list of objects being clipped by $obj.]]
+ return: const(list<Evas.Object>) @warn_unused; [[A list of objects being clipped by $obj.]]
}
}
@property render_parent @protected {
legacy: evas_object_smart_parent_get;
}
values {
- parent: Evas.Object *; [[The parent smart object of $obj or $null.]]
+ parent: Evas.Object; [[The parent smart object of $obj or $null.]]
}
}
@property size_hint_display_mode {
@since 1.2
]]
- return: Evas.Object * @warn_unused; [[The Evas object with the given name
+ return: Evas.Object @warn_unused; [[The Evas object with the given name
on success, Otherwise $null.]]
params {
@in name: const(char)*; [[The given name.]]
legacy: null;
}
values {
- clip: Evas.Object *;
+ clip: Evas.Object;
}
}
@property color {
See also @.member_add, @.member_del and @.iterator_new.
@since 1.7]]
- return: list<Evas.Object*> * @warn_unused; [[Returns the list of the member objects of $obj.]]
+ return: list<Evas.Object> @warn_unused; [[Returns the list of the member objects of $obj.]]
}
}
@property smart {
See also @.member_add and @.member_del
@since 1.8]]
- return: free(own(iterator<Evas.Object *> *), eina_iterator_free)
+ return: free(own(iterator<Evas.Object>), eina_iterator_free)
@warn_unused; [[Returns the iterator of the member objects of $obj.]]
}
callback_description_find @const {
See also @.member_del.]]
params {
- @in sub_obj: Evas.Object * @nonull; [[The member object.]]
+ @in sub_obj: Evas.Object @nonull; [[The member object.]]
}
legacy: null;
}
See also @.member_add for more details.]]
params {
- @in sub_obj: Evas.Object *; [[the member object.]]
+ @in sub_obj: Evas.Object; [[the member object.]]
}
legacy: null;
}
It's up to the user to destroy it when it no longer needs it.
It's possible to remove objects from the table when walking this
list, but these removals won't be reflected on it.]]
- return: free(own(list<Evas.Object *> *), eina_list_free) @warn_unused;
+ return: free(own(list<Evas.Object>), eina_list_free) @warn_unused;
}
}
@property child {
row: ushort;
}
values {
- child: Evas.Object *;
+ child: Evas.Object;
}
}
clear {
[[Get an accessor to get random access to the list of children for the table.
Note: Do not remove or delete objects while walking the list.]]
- return: free(own(accessor<Evas.Object *> *), eina_accessor_free)
+ return: free(own(accessor<Evas.Object>), eina_accessor_free)
@warn_unused;
}
iterator_new @const {
[[Get an iterator to walk the list of children for the table.
Note: Do not remove or delete objects while walking the list.]]
- return: free(own(iterator<Evas.Object *> *), eina_iterator_free)
+ return: free(own(iterator<Evas.Object>), eina_iterator_free)
@warn_unused;
}
add_to {
[[Create a table that is child of a given element $parent.]]
- return: Evas.Object * @warn_unused;
+ return: Evas.Object @warn_unused;
}
pack_get @const {
[[Get packing location of a child of table
@since 1.1]]
return: bool; [[$true on success, $false on failure.]]
params {
- @in child: Evas.Object *; [[The child object to add.]]
+ @in child: Evas.Object; [[The child object to add.]]
@out col: ushort; [[pointer to store relative-horizontal position to place child.]]
@out row: ushort; [[pointer to store relative-vertical position to place child.]]
@out colspan: ushort; [[pointer to store how many relative-horizontal position to use for this child.]]
return: bool; [[$true on success, $false on failure.]]
params {
- @in child: Evas.Object * @nonull; [[The child object to add.]]
+ @in child: Evas.Object @nonull; [[The child object to add.]]
@in col: ushort; [[relative-horizontal position to place child.]]
@in row: ushort; [[relative-vertical position to place child.]]
@in colspan: ushort; [[how many relative-horizontal position to use for this child.]]
return: bool; [[$true on success, $false on failure.]]
params {
- @in child: Evas.Object * @nonull;
+ @in child: Evas.Object @nonull;
}
}
count {
}
node_format_list_get @const {
legacy: evas_textblock_node_format_list_get;
- return: const(list<Evas.Object*>)*;
+ return: const(list<Evas.Object>);
params {
@in anchor: const(char)*;
}
@since 1.15
]]
params {
- @in eo_obs: Evas.Object *;
+ @in eo_obs: Evas.Object;
}
return: bool; [[$true on success, $false otherwise.]]
}
@since 1.15
]]
params {
- @in eo_obs: Evas.Object *;
+ @in eo_obs: Evas.Object;
}
return: bool; [[$true on success, $false otherwise.]]
}
@since 1.14]]
}
values {
- container: Eo.Base *; [[Root node of the VG canvas.]] /* FIXME: Should be Efl.VG */
+ container: Eo.Base; [[Root node of the VG canvas.]] /* FIXME: Should be Efl.VG */
}
}
}
get {}
set { [[This Buffer will hold a reference to the evas image struct.]] }
values {
- evas: Evas.Canvas *; [[The current Evas.]]
+ evas: Evas.Canvas; [[The current Evas.]]
image: void *; [[The engine-specific image struct.]]
}
}
params { one: int; two: int; three: int; four: int; five: int; six: int; seven: int; eight: int; nine: int; ten: int; }
}
onecomplexarg {
- params { one: list<int>*; }
+ params { one: list<int>; }
}
tencomplexarg {
- params { one: list<int>*; two: list<int>*; three: list<int>*; four: list<int>*; five: list<int>*; six: list<int>*; seven: list<int>*; eight: list<int>*; nine: list<int>*; ten: list<int>*; }
+ params { one: list<int>; two: list<int>; three: list<int>; four: list<int>; five: list<int>; six: list<int>; seven: list<int>; eight: list<int>; nine: list<int>; ten: list<int>; }
}
}
}
methods {
@property a {
set {
- return: own(list<array<own(Eo**)>*>*);
+ return: own(list<array<own(Eo**)> >);
}
get {
}
values {
- value: own(list<int>*);
+ value: own(list<int>);
}
}
foo {
params {
buf: own(char*);
}
- return: own(list<Eina.Stringshare*>*); [[comment for method return]]
+ return: own(list<Eina.Stringshare*>); [[comment for method return]]
}
}
}
@property a {
set {
values {
- value: const(list<int>)*;
+ value: const(list<int>);
}
return: bool (false);
}
part: const(char)*;
}
values {
- value: own(list<int>*);
+ value: own(list<int>);
}
}
@property b {
/* set as virtual pure - no implementation expected */
}
values {
- value: own(list<int>*);
+ value: own(list<int>);
}
}
constructor_1 {
/* set as virtual pure - no implementation expected */
}
values {
- value: own(list<int>*);
+ value: own(list<int>);
}
}
}
type Evas.Coord: int; /* Simple type definition */
-type List_Objects: own(list<Eo *>*); /* A little more complex */
+type List_Objects: own(list<Eo *>); /* A little more complex */
type Evas.Coord2: Evas.Coord;
type Evas.Coord3: Evas.Coord2;
fail_if(!eolian_type_is_own(type));
fail_if(strcmp(type_name, "Eina_List *"));
eina_stringshare_del(type_name);
- fail_if(!(type = eolian_type_base_type_get(type)));
fail_if(!(iter = eolian_type_subtypes_get(type)));
fail_if(!eina_iterator_next(iter, (void**)&type));
fail_if(!(type_name = eolian_type_c_type_get(type)));
fail_if(!eolian_type_is_own(type));
fail_if(strcmp(type_name, "Eina_List *"));
eina_stringshare_del(type_name);
- fail_if(!(type = eolian_type_base_type_get(type)));
fail_if(!(iter = eolian_type_subtypes_get(type)));
fail_if(!eina_iterator_next(iter, (void**)&type));
fail_if(!(type_name = eolian_type_c_type_get(type)));
fail_if(strcmp(type_name, "Eina_Array *"));
eina_stringshare_del(type_name);
eina_iterator_free(iter);
- fail_if(!(type = eolian_type_base_type_get(type)));
fail_if(!(iter = eolian_type_subtypes_get(type)));
fail_if(!eina_iterator_next(iter, (void**)&type));
fail_if(!(type_name = eolian_type_c_type_get(type)));
fail_if(!eolian_type_is_own(type));
fail_if(strcmp(type_name, "Eina_List *"));
eina_stringshare_del(type_name);
- fail_if(!(type = eolian_type_base_type_get(type)));
fail_if(!(iter = eolian_type_subtypes_get(type)));
fail_if(!eina_iterator_next(iter, (void**)&type));
fail_if(!(type_name = eolian_type_c_type_get(type)));
fail_if(!eolian_type_is_own(type));
fail_if(strcmp(type_name, "Eina_List *"));
eina_stringshare_del(type_name);
- fail_if(!(type = eolian_type_base_type_get(type)));
fail_if(!(iter = eolian_type_subtypes_get(type)));
fail_if(!eina_iterator_next(iter, (void**)&type));
fail_if(!(type_name = eolian_type_c_type_get(type)));
methods {
method1 {
params {
- @inout promise1: promise<int>*;
+ @inout promise1: promise<int>;
}
}
method_multiple_args_1 {
params {
- @inout promise1: promise<int>*;
+ @inout promise1: promise<int>;
@in data: void*;
}
}
method_multiple_args_2 {
params {
@in data: void*;
- @inout promise1: promise<int>*;
+ @inout promise1: promise<int>;
}
}
method2 {
params {
- @out promise1: promise<int>*;
+ @out promise1: promise<int>;
}
}
method3 {
params {
- @in promise1: promise<int>*;
+ @in promise1: promise<int>;
}
}
@property prop1 {
get {}
values {
- promise1: promise<int>*;
+ promise1: promise<int>;
}
}
@property prop2 {
get {}
values {
i: int;
- promise1: promise<int>*;
+ promise1: promise<int>;
}
}
@property prop3 {
set {}
values {
- promise1: promise<int>*;
+ promise1: promise<int>;
}
}
}
method_array_at_check {
[[ tests array ]]
params {
- array: array<int>*;
+ array: array<int>;
index: int;
}
return: int;
}
method_array_with_42_check {
[[ tests parameters ]]
- return: free(own(array<int> *), eina_array_free) @warn_unused;
+ return: free(own(array<int>), eina_array_free) @warn_unused;
}
method_array_in_array_out_check {
[[ tests parameters ]]
params {
- @in a_in: array<int> *;
- @out a_out: array<int> *;
+ @in a_in: array<int>;
+ @out a_out: array<int>;
}
}
method_array_of_objects_check {
params {
- @in a_in: array<Test.Object *> *;
+ @in a_in: array<Test.Object>;
}
- return: array<Test.Object *> *;
+ return: array<Test.Object>;
}
method_array_of_strings_check {
params {
- @in a_in: array<const(char) *> *;
+ @in a_in: array<const(char) *>;
}
- return: array<const(char) *> *;
+ return: array<const(char) *>;
}
method_array_of_ints_check {
params {
- @in a_in: array<int> *;
+ @in a_in: array<int>;
}
- return: array<int> *;
+ return: array<int>;
}
method_array_of_bools_check {
params {
- @in a_in: array<bool> *;
+ @in a_in: array<bool>;
}
- return: array<bool> *;
+ return: array<bool>;
}
method_array_of_doubles_check {
params {
- @in a_in: array<double> *;
+ @in a_in: array<double>;
}
- return: array<double> *;
+ return: array<double>;
}
method_array_of_enums_check {
params {
- @in a_in: array<Test.Enum_Ex> *;
+ @in a_in: array<Test.Enum_Ex>;
}
- return: array<Test.Enum_Ex> *;
+ return: array<Test.Enum_Ex>;
}
method_array_of_structs_check {
params {
- @in a_in: array<Test.Struct_Ex> *;
+ @in a_in: array<Test.Struct_Ex>;
}
- return: array<Test.Struct_Ex> *;
+ return: array<Test.Struct_Ex>;
}
method_list_with_42_check {
[[ tests parameters ]]
- return: free(own(list<int> *), eina_list_free) @warn_unused;
+ return: free(own(list<int>), eina_list_free) @warn_unused;
}
method_list_in_list_out_check {
[[ tests parameters ]]
params {
- @in l_in: list<int> *;
- @out l_out: list<int> *;
+ @in l_in: list<int>;
+ @out l_out: list<int>;
}
}
method_list_of_objects_check {
params {
- @in l_in: list<Test.Object *> *;
+ @in l_in: list<Test.Object>;
}
- return: list<Test.Object *> *;
+ return: list<Test.Object>;
}
method_list_of_strings_check {
params {
- @in l_in: list<const(char) *> *;
+ @in l_in: list<const(char) *>;
}
- return: list<const(char) *> *;
+ return: list<const(char) *>;
}
method_list_of_ints_check {
params {
- @in l_in: list<int> *;
+ @in l_in: list<int>;
}
- return: list<int> *;
+ return: list<int>;
}
method_list_of_bools_check {
params {
- @in l_in: list<bool> *;
+ @in l_in: list<bool>;
}
- return: list<bool> *;
+ return: list<bool>;
}
method_list_of_doubles_check {
params {
- @in l_in: list<double> *;
+ @in l_in: list<double>;
}
- return: list<double> *;
+ return: list<double>;
}
method_list_of_enums_check {
params {
- @in l_in: list<Test.Enum_Ex> *;
+ @in l_in: list<Test.Enum_Ex>;
}
- return: list<Test.Enum_Ex> *;
+ return: list<Test.Enum_Ex>;
}
method_list_of_structs_check {
params {
- @in l_in: list<Test.Struct_Ex> *;
+ @in l_in: list<Test.Struct_Ex>;
}
- return: list<Test.Struct_Ex> *;
+ return: list<Test.Struct_Ex>;
}
method_accessor_of_objects_check {
params {
- @in a_in: accessor<Test.Object *> *;
+ @in a_in: accessor<Test.Object>;
}
- return: accessor<Test.Object *> *;
+ return: accessor<Test.Object>;
}
method_accessor_of_strings_check {
params {
- @in a_in: accessor<const(char) *> *;
+ @in a_in: accessor<const(char) *>;
}
- return: accessor<const(char) *> *;
+ return: accessor<const(char) *>;
}
method_accessor_of_ints_check {
params {
- @in a_in: accessor<int> *;
+ @in a_in: accessor<int>;
}
- return: accessor<int> *;
+ return: accessor<int>;
}
method_accessor_of_bools_check {
params {
- @in a_in: accessor<bool> *;
+ @in a_in: accessor<bool>;
}
- return: accessor<bool> *;
+ return: accessor<bool>;
}
method_accessor_of_doubles_check {
params {
- @in a_in: accessor<double> *;
+ @in a_in: accessor<double>;
}
- return: accessor<double> *;
+ return: accessor<double>;
}
method_accessor_of_enums_check {
params {
- @in a_in: accessor<Test.Enum_Ex> *;
+ @in a_in: accessor<Test.Enum_Ex>;
}
- return: accessor<Test.Enum_Ex> *;
+ return: accessor<Test.Enum_Ex>;
}
method_accessor_of_structs_check {
params {
- @in a_in: accessor<Test.Struct_Ex> *;
+ @in a_in: accessor<Test.Struct_Ex>;
}
- return: accessor<Test.Struct_Ex> *;
+ return: accessor<Test.Struct_Ex>;
}
method_iterator_of_objects_check {
params {
- @in i_in: iterator<Test.Object *> *;
+ @in i_in: iterator<Test.Object>;
}
- return: iterator<Test.Object *> *;
+ return: iterator<Test.Object>;
}
method_iterator_of_strings_check {
params {
- @in i_in: iterator<const(char) *> *;
+ @in i_in: iterator<const(char) *>;
}
- return: iterator<const(char) *> *;
+ return: iterator<const(char) *>;
}
method_iterator_of_ints_check {
params {
- @in i_in: iterator<int> *;
+ @in i_in: iterator<int>;
}
- return: iterator<int> *;
+ return: iterator<int>;
}
method_iterator_of_bools_check {
params {
- @in i_in: iterator<bool> *;
+ @in i_in: iterator<bool>;
}
- return: iterator<bool> *;
+ return: iterator<bool>;
}
method_iterator_of_doubles_check {
params {
- @in i_in: iterator<double> *;
+ @in i_in: iterator<double>;
}
- return: iterator<double> *;
+ return: iterator<double>;
}
method_iterator_of_enums_check {
params {
- @in i_in: iterator<Test.Enum_Ex> *;
+ @in i_in: iterator<Test.Enum_Ex>;
}
- return: iterator<Test.Enum_Ex> *;
+ return: iterator<Test.Enum_Ex>;
}
method_iterator_of_structs_check {
params {
- @in i_in: iterator<Test.Struct_Ex> *;
+ @in i_in: iterator<Test.Struct_Ex>;
}
- return: iterator<Test.Struct_Ex> *;
+ return: iterator<Test.Struct_Ex>;
}
method_array_of_arrays_of_ints_check {
params {
- @in a_in: array<array<int> *> *;
+ @in a_in: array<array<int> >;
}
- return: array<array<int> *> *;
+ return: array<array<int> >;
}
method_list_of_lists_of_ints_check {
params {
- @in l_in: list<list<int> *> *;
+ @in l_in: list<list<int> >;
}
- return: list<list<int> *> *;
+ return: list<list<int> >;
}
method_array_of_lists_of_ints_check {
params {
- @in a_in: array<list<int> *> *;
+ @in a_in: array<list<int> >;
}
- return: array<list<int> *> *;
+ return: array<list<int> >;
}
method_list_of_arrays_of_ints_check {
params {
- @in l_in: list<array<int> *> *;
+ @in l_in: list<array<int> >;
}
- return: list<array<int> *> *;
+ return: list<array<int> >;
}
method_list_with_opaque_elements_check {
- return: const(list<Elm.Calendar.Mark*>)*;
+ return: const(list<Elm.Calendar.Mark*>);
}
method_in_enum_return_enum_check {
params { e: Test.Enum_Ex; }
projects / platform / upstream / efl.git / commitdiff