2015-06-10 08:56:43 -07:00
|
|
|
import edje_types;
|
|
|
|
|
2014-07-21 03:47:23 -07:00
|
|
|
class Edje.Object (Evas.Smart_Clipped, Efl.File)
|
2014-03-18 07:00:14 -07:00
|
|
|
{
|
|
|
|
legacy_prefix: edje_object;
|
|
|
|
eo_prefix: edje_obj;
|
|
|
|
data: Edje;
|
2015-05-07 08:36:45 -07:00
|
|
|
methods {
|
|
|
|
@property update_hints {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Edje will automatically update the size hints on itself.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
By default edje doesn't set size hints on itself. With this function
|
|
|
|
call, it will do so if update is true. Be carefully, it cost a lot to
|
|
|
|
trigger this feature as it will recalc the object every time it make
|
|
|
|
sense to be sure that's its minimal size hint is always accurate.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Whether or not Edje will update size hints on itself.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
update: bool; [[Whether or not update the size hints.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property mirrored {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the RTL orientation for this object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the RTL orientation for this object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
You can RTL orientation explicitly with edje_object_mirrored_set.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
rtl: bool; [[new value of flag true/false]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-06-01 08:38:04 -07:00
|
|
|
@property language {
|
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the language for this object.
|
2015-06-01 08:38:04 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
2015-06-01 08:38:04 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the language for this object.
|
2015-06-01 08:38:04 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
2015-06-01 08:38:04 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
language: const(char)*; [[The language value]]
|
2015-06-01 08:38:04 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property animation {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the object's animation state.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function starts or stops an Edje object's animation. The
|
|
|
|
information if it's stopped can be retrieved by
|
|
|
|
edje_object_animation_get().
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.animation.get()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the Edje object's animation state.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns if the animation is stopped or not. The
|
|
|
|
animation state is set by edje_object_animation_set().
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.animation.set().]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
on: bool; [[The animation state. $true to starts or
|
|
|
|
$false to stops.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property play {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the Edje object to playing or paused states.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function sets the Edje object obj to playing or paused
|
|
|
|
states, depending on the parameter play. This has no effect if
|
|
|
|
the object was already at that state.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.play.get().]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the Edje object's state.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function tells if an Edje object is playing or not. This state
|
|
|
|
is set by edje_object_play_set().
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.play.set().]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
play: bool; [[Object state ($true to playing,
|
|
|
|
$false to paused).]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property perspective {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the given perspective object on this Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Make the given perspective object be the default perspective for this Edje
|
|
|
|
object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
There can be only one perspective object per Edje object, and if a
|
|
|
|
previous one was set, it will be removed and the new perspective object
|
|
|
|
will be used.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
An Edje perspective will only affect a part if it doesn't point to another
|
|
|
|
part to be used as perspective.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
\@ref edje_object_perspective_new()
|
|
|
|
See also @.perspective.get()
|
|
|
|
\@ref edje_perspective_set()]]
|
2015-05-20 09:48:52 -07:00
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
ps: Edje.Perspective*; [[The perspective object that will be used.]]
|
2015-05-20 09:48:52 -07:00
|
|
|
}
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the current perspective used on this Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.perspective.set()]]
|
2015-05-20 09:48:52 -07:00
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
ps: const(Edje.Perspective)*; [[The perspective object that will be used.]]
|
2015-05-20 09:48:52 -07:00
|
|
|
}
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property scale {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the scaling factor for a given Edje object.
|
|
|
|
|
|
|
|
This function sets an individual scaling factor on the obj
|
|
|
|
Edje object. This property (or Edje's global scaling factor, when
|
|
|
|
applicable), will affect this object's part sizes. If scale is
|
|
|
|
not zero, than the individual scaling will override any global
|
|
|
|
scaling set, for the object obj's parts. Put it back to zero to
|
|
|
|
get the effects of the global scaling again.
|
|
|
|
|
|
|
|
Warning: Only parts which, at EDC level, had the @"scale"
|
|
|
|
property set to @1, will be affected by this function. Check the
|
|
|
|
complete \@ref edcref "syntax reference" for EDC files.
|
|
|
|
|
|
|
|
See also @.scale.get()
|
|
|
|
\@ref edje_scale_get() for more details]]
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get a given Edje object's scaling factor.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns the individual scaling factor set on the
|
|
|
|
obj Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.scale.set() for more details]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
scale: double; [[The scaling factor (the default value is @0.0,
|
|
|
|
meaning individual scaling not set)]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property base_scale {
|
2014-10-15 21:15:38 -07:00
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get a given Edje object's base_scale factor.
|
2014-10-15 21:15:38 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns the base_scale factor set on the
|
|
|
|
obj Edje object.
|
|
|
|
The base_scale can be set in the collection of edc.
|
|
|
|
If it isn't set, the default value is 1.0]]
|
2014-10-15 21:15:38 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-14 20:22:41 -07:00
|
|
|
base_scale: double(1.0); [[The base_scale factor (the default value is @ 1.0,
|
2015-07-10 03:07:00 -07:00
|
|
|
that means the edc file is made based on scale 1.0.]]
|
2014-10-15 21:15:38 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property text_change_cb {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the object text callback.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function sets the callback to be called when the text changes.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
func: Edje.Text.Change_Cb; [[The callback function to handle the text change]]
|
|
|
|
data: void *; [[The data associated to the callback function.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property part_text_cursor_begin {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Moves the cursor to the beginning of the text part
|
|
|
|
\@ref evas_textblock_cursor_paragraph_first]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
part: const(char)*; [[The part name]]
|
|
|
|
cur: Edje.Cursor; [[the edje cursor to work on]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property part_text_cursor_line_end {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Move the cursor to the end of the line.
|
|
|
|
\@ref evas_textblock_cursor_line_char_last]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
part: const(char)*; [[The part name]]
|
|
|
|
cur: Edje.Cursor; [[the edje cursor to work on]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property text_class {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets Edje text class.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function sets the text class for the Edje.]]
|
|
|
|
return: bool; [[$true, on success or $false, on error]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
text_class: const(char)*; [[The text class name]]
|
|
|
|
font: const(char)*; [[Font name]]
|
|
|
|
size: Evas.Font.Size; [[Font Size]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property part_text_cursor_coord {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Position the given cursor to a X,Y position.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This is frequently used with the user cursor.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[True on success, false on error.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
part: const(char)*; [[The part containing the object.]]
|
|
|
|
cur: Edje.Cursor; [[The cursor to adjust.]]
|
|
|
|
x: Evas.Coord; [[X Coordinate.]]
|
|
|
|
y: Evas.Coord; [[Y Coordinate.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property part_text_cursor_end {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Moves the cursor to the end of the text part.
|
|
|
|
\@ref evas_textblock_cursor_paragraph_last]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
part: const(char)*; [[The part name]]
|
|
|
|
cur: Edje.Cursor; [[the edje cursor to work on]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property part_text_escaped {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the text for an object part, but converts HTML escapes to UTF8
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This converts the given string text to UTF8 assuming it contains HTML
|
|
|
|
style escapes like "&" and "©" etc. IF the part is of type TEXT,
|
|
|
|
as opposed to TEXTBLOCK.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2]]
|
|
|
|
return: bool; [[$true on success, $false otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
part: const(char)*; [[The part name]]
|
|
|
|
text: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property item_provider {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the function that provides item objects for named items in an edje entry text
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Item objects may be deleted any time by Edje, and will be deleted when the
|
|
|
|
Edje object is deleted (or file is set to a new file).]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 06:02:32 -07:00
|
|
|
func: Edje.Item_Provider_Cb; [[The function to call (or $null to disable) to get item objects]]
|
2015-07-10 03:07:00 -07:00
|
|
|
data: void *; [[The data pointer to pass to the func callback]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property part_text_cursor_line_begin {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Move the cursor to the beginning of the line.
|
|
|
|
\@ref evas_textblock_cursor_line_char_first]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
part: const(char)*; [[The part name]]
|
|
|
|
cur: Edje.Cursor; [[the edje cursor to work on]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property message_handler {
|
2014-03-18 07:00:14 -07:00
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set an Edje message handler function for a given Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
For scriptable programs on an Edje object's defining EDC file which
|
|
|
|
send messages with the send_message() primitive, one can attach
|
2015-07-10 06:02:32 -07:00
|
|
|
handler functions, to be called in the code which creates
|
2015-07-10 03:07:00 -07:00
|
|
|
that object (see \@ref edcref "the syntax" for EDC files).
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function associates a message handler function and the
|
|
|
|
attached data pointer to the object obj.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.message_send()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
func: Edje.Message_Handler_Cb; [[The function to handle messages coming from obj]]
|
|
|
|
data: void *; [[Auxiliary data to be passed to func]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property size_min {
|
2014-03-18 07:00:14 -07:00
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the minimum size specified -- as an EDC property -- for a
|
|
|
|
given Edje object
|
|
|
|
|
|
|
|
This function retrieves the obj object's minimum size values,
|
2015-07-10 06:02:32 -07:00
|
|
|
as declared in its EDC group definition.
|
2015-07-10 03:07:00 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: If the $min EDC property was not declared for obj, this
|
2015-07-10 03:07:00 -07:00
|
|
|
call will return the value 0, for each axis.
|
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: On failure, this function will make all non-$null size
|
2015-07-10 03:07:00 -07:00
|
|
|
pointers' pointed variables be set to zero.
|
|
|
|
|
|
|
|
See also @.size_max.get()]]
|
|
|
|
/* FIXME-doc
|
|
|
|
* Minimum size of groups have the following syntax
|
|
|
|
* @code
|
|
|
|
* collections
|
|
|
|
* {
|
|
|
|
* group
|
|
|
|
* {
|
|
|
|
* name: "a_group";
|
|
|
|
* min: 100 100;
|
|
|
|
* }
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
* where one declares a minimum size of 100 pixels both for width and
|
|
|
|
* height. Those are (hint) values which should be respected when the
|
|
|
|
* given object/group is to be controlled by a given container object
|
2015-07-10 06:02:32 -07:00
|
|
|
* (e.g. an Edje object being "swallowed" into a given $SWALLOW
|
2015-07-10 03:07:00 -07:00
|
|
|
* typed part, as in edje_object_part_swallow()). Check the complete
|
|
|
|
* \@ref edcref "syntax reference" for EDC files.
|
|
|
|
*/
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
minw: Evas.Coord; [[Pointer to a variable where to store the minimum width]]
|
|
|
|
minh: Evas.Coord; [[Pointer to a variable where to store the minimum height]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property access_part_list {
|
2014-03-18 07:00:14 -07:00
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Retrieve a list all accessibility part names
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.7.0]]
|
|
|
|
return: list<const(char)*> *; [[A list all accessibility part names on obj]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property load_error {
|
2014-03-18 07:00:14 -07:00
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets the (last) file loading error for a given Edje object
|
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
This function is meant to be used after an Edje EDJ file
|
|
|
|
loading, what takes place with the edje_object_file_set()
|
2015-07-10 03:07:00 -07:00
|
|
|
function. If that function does not return $true, one should
|
|
|
|
check for the reason of failure with this one.
|
|
|
|
|
|
|
|
\@ref edje_load_error_str()]]
|
|
|
|
return: Edje.Load_Error; [[The Edje loading error, one of:
|
|
|
|
- #EDJE_LOAD_ERROR_NONE
|
|
|
|
- #EDJE_LOAD_ERROR_GENERIC
|
|
|
|
- #EDJE_LOAD_ERROR_DOES_NOT_EXIST
|
|
|
|
- #EDJE_LOAD_ERROR_PERMISSION_DENIED
|
|
|
|
- #EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED
|
|
|
|
- #EDJE_LOAD_ERROR_CORRUPT_FILE
|
|
|
|
- #EDJE_LOAD_ERROR_UNKNOWN_FORMAT
|
|
|
|
- #EDJE_LOAD_ERROR_INCOMPATIBLE_FILE
|
|
|
|
- #EDJE_LOAD_ERROR_UNKNOWN_COLLECTION
|
|
|
|
- #EDJE_LOAD_ERROR_RECURSIVE_REFERENCE]]
|
|
|
|
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-05-07 08:36:45 -07:00
|
|
|
@property size_max {
|
2014-03-18 07:00:14 -07:00
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the maximum size specified -- as an EDC property -- for a
|
|
|
|
given Edje object
|
|
|
|
|
|
|
|
This function retrieves the obj object's maximum size values,
|
2015-07-10 06:02:32 -07:00
|
|
|
as declared in its EDC group definition.
|
2015-07-10 03:07:00 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: If the $max EDC property was not declared for obj, this
|
2015-07-10 03:07:00 -07:00
|
|
|
call will return the maximum size a given Edje object may have, for
|
|
|
|
each axis.
|
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: On failure, this function will make all non-$null size
|
2015-07-10 03:07:00 -07:00
|
|
|
pointers' pointed variables be set to zero.
|
|
|
|
|
|
|
|
See also @.size_min.get()]]
|
|
|
|
/* FIXME-doc
|
|
|
|
* Maximum size of groups have the following syntax
|
|
|
|
* @code
|
|
|
|
* collections
|
|
|
|
* {
|
|
|
|
* group
|
|
|
|
* {
|
|
|
|
* name: "a_group";
|
|
|
|
* max: 100 100;
|
|
|
|
* }
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
* where one declares a maximum size of 100 pixels both for width and
|
|
|
|
* height. Those are (hint) values which should be respected when the
|
|
|
|
* given object/group is to be controlled by a given container object
|
2015-07-10 06:02:32 -07:00
|
|
|
* (e.g. an Edje object being "swallowed" into a given $SWALLOW
|
2015-07-10 03:07:00 -07:00
|
|
|
* typed part, as in edje_object_part_swallow()). Check the complete
|
|
|
|
* \@ref edcref "syntax reference" for EDC files.
|
|
|
|
*/
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
maxw: Evas.Coord; [[Pointer to a variable where to store the maximum width]]
|
|
|
|
maxh: Evas.Coord; [[Pointer to a variable where to store the maximum height]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_table_clear {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Removes all object from the table.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Removes all object from the table indicated by part, except the
|
|
|
|
internal ones set from the theme.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true clear the table, $false on failure]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in clear: bool; [[If set, will delete subobjs on remove]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_external_param_type_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Facility to query the type of the given parameter of the given part.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: Edje.External.Param_Type; [[#EDJE_EXTERNAL_PARAM_TYPE_MAX on errors, or another value
|
|
|
|
from #Edje_External_Param_Type on success.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@out param: const(char); [[the parameter name to use.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_select_allow_set @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Enables selection if the entry is an EXPLICIT selection mode
|
|
|
|
type.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The default is to not allow selection. This function only affects user
|
|
|
|
selection, functions such as edje_object_part_text_select_all() and
|
|
|
|
edje_object_part_text_select_none() are not affected.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in allow: bool; [[true to enable, false otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_state_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Returns the state of the Edje part.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: const(char)*; [[The part state:
|
|
|
|
"default" for the default state
|
|
|
|
"" for other states]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2015-05-18 08:13:08 -07:00
|
|
|
@out val_ret: double;
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
text_markup_filter_callback_del_full {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Delete a function and matching user data from the markup filter list.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Delete the given func filter and data user data from the list
|
|
|
|
in part.
|
|
|
|
Returns the user data pointer given when added.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.text_markup_filter_callback_add and @.text_markup_filter_callback_del
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
return: void *; [[The same data pointer if successful, or $null otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in func: Edje.Markup_Filter_Cb; [[The function callback to remove]]
|
|
|
|
@in data: void *; [[The data passed to the callback function]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_drag_step_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the drag step increment.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Sets the x,y step increments for a dragable object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Values for dx and dy are real numbers that range from 0 to 1,
|
|
|
|
representing the relative size of the dragable area on that axis by which the
|
|
|
|
part will be moved.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_step_get()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in dx: double; [[The x step amount]]
|
|
|
|
@in dy: double; [[The y step amount]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_drag_step_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets the drag step increment values.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Gets the x and y step increments for the dragable object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_step_set()]]
|
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part]]
|
|
|
|
@out dx: double; [[The x step increment pointer]]
|
|
|
|
@out dy: double; [[The y step increment pointer]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_imf_context_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the input method context in entry.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
If ecore_imf was not available when edje was compiled, this function returns $null
|
2015-07-10 03:07:00 -07:00
|
|
|
otherwise, the returned pointer is an Ecore_IMF
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
|
|
|
return: void *; [[The input method context (Ecore_IMF_Context *) in entry]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_select_begin @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Starts selecting at current cursor position]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_style_user_peek @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return the text of the object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns the style associated with the textblock part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
|
|
|
return: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
signal_callback_del {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Remove a signal-triggered callback from an object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function removes a callback, previously attached to the
|
2015-07-10 06:02:32 -07:00
|
|
|
emittion of a signal, from the object obj. The parameters
|
2015-07-10 03:07:00 -07:00
|
|
|
emission, source and func must match exactly those passed to
|
|
|
|
a previous call to edje_object_signal_callback_add(). The data
|
|
|
|
pointer that was passed to this call will be returned.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.signal_callback_add().
|
|
|
|
\@ref edje_object_signal_callback_del_full().]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
legacy: null;
|
2015-07-10 03:07:00 -07:00
|
|
|
return: void *; [[The data pointer]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in emission: const(char)*; [[The emission string.]]
|
|
|
|
@in source: const(char)*; [[The source string.]]
|
|
|
|
@in func: Edje.Signal_Cb; [[The callback function.]]
|
|
|
|
@in data: void *; [[The callback function.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_cursor_next {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Advances the cursor to the next cursor position.
|
|
|
|
\@ref evas_textblock_cursor_char_next]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[The edje cursor to advance]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_style_user_push {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the style of the
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function sets the style associated with the textblock part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in style: const(char)*; [[The style to set (textblock conventions).]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_append {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Insert text for an object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function inserts the text for an object part at the end; It does not
|
|
|
|
move the cursor.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in text: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_geometry_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Retrieve the geometry of a given Edje part, in a given Edje
|
2015-07-10 06:02:32 -07:00
|
|
|
object's group definition, relative to the object's area.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function gets the geometry of an Edje part within its
|
|
|
|
group. The x and y coordinates are relative to the top left
|
|
|
|
corner of the whole obj object's area.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: Use $null pointers on the geometry components you're not
|
2015-07-10 03:07:00 -07:00
|
|
|
interested in: they'll be ignored by the function.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: On failure, this function will make all non-$null geometry
|
2015-07-10 03:07:00 -07:00
|
|
|
pointers' pointed variables be set to zero.]]
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The Edje part's name]]
|
|
|
|
@out x: Evas.Coord; [[A pointer to a variable where to store the part's x
|
|
|
|
coordinate]]
|
|
|
|
@out y: Evas.Coord; [[A pointer to a variable where to store the part's y
|
|
|
|
coordinate]]
|
|
|
|
@out w: Evas.Coord; [[A pointer to a variable where to store the part's width]]
|
|
|
|
@out h: Evas.Coord; [[A pointer to a variable where to store the part's height]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_hide @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Hide the input panel (virtual keyboard).
|
|
|
|
See also @.part_text_input_panel_show
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note that input panel is shown or hidden automatically according to the focus state.
|
|
|
|
This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_item_geometry_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return item geometry.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function return a list of Evas_Textblock_Rectangle item
|
|
|
|
rectangles.]]
|
|
|
|
return: bool; [[1 if item exists, 0 if not]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in item: const(char)*; [[The item name]]
|
|
|
|
@out cx: Evas.Coord; [[Item x return (relative to entry part)]]
|
|
|
|
@out cy: Evas.Coord; [[Item y return (relative to entry part)]]
|
|
|
|
@out cw: Evas.Coord; [[Item width return]]
|
|
|
|
@out ch: Evas.Coord; [[Item height return]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_table_unpack {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Removes an object from the table.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Removes an object from the table indicated by part.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true object removed, $false on failure]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in child_obj: Evas.Object *; [[The object to pack in]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_select_abort @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Aborts any selection action on a part.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
text_insert_filter_callback_del_full {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Delete a function and matching user data from the filter list.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Delete the given func filter and data user data from the list
|
|
|
|
in part.
|
|
|
|
Returns the user data pointer given when added.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.text_insert_filter_callback_add and @.text_insert_filter_callback_del]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
return: void *; [[The same data pointer if successful, or $null otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in func: Edje.Text.Filter_Cb; [[The function callback to remove]]
|
|
|
|
@in data: void *; [[The data passed to the callback function]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_style_user_pop {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Delete the top style form the user style stack.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_imdata_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the input panel-specific data to deliver to the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This API is used by applications to deliver specific data to the input panel.
|
|
|
|
The data format MUST be negotiated by both application and the input panel.
|
|
|
|
The size and format of data are defined by the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in data: const(void)*; [[The specific data to be set to the input panel.]]
|
|
|
|
@in len: int; [[the length of data, in bytes, to send to the input panel]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_imdata_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the specific data of the current active input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in data: void *; [[The specific data to be got from the input panel]]
|
|
|
|
@in len: int *; [[The length of data]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_insert {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Insert text for an object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function inserts the text for an object part just before the
|
|
|
|
cursor position.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in text: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_box_remove_at {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Removes an object from the box.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Removes from the box indicated by part, the object in the position
|
|
|
|
pos.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_box_remove() and @.part_box_remove_all()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
return: Evas.Object *; [[Pointer to the object removed, or $null.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in pos: uint; [[The position index of the object (starts counting from 0)]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_cursor_copy {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Copy the cursor to another cursor.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in src: Edje.Cursor; [[the cursor to copy from]]
|
|
|
|
@in dst: Edje.Cursor; [[the cursor to copy to]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
parts_extends_calc {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Calculate the geometry of the region, relative to a given Edje
|
2015-07-10 06:02:32 -07:00
|
|
|
object's area, occupied by all parts in the object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function gets the geometry of the rectangle equal to the area
|
|
|
|
required to group all parts in obj's group/collection. The x
|
|
|
|
and y coordinates are relative to the top left corner of the
|
|
|
|
whole obj object's area. Parts placed out of the group's
|
|
|
|
boundaries will also be taken in account, so that x and y
|
2015-07-10 06:02:32 -07:00
|
|
|
may be negative.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: Use $null pointers on the geometry components you're not
|
2015-07-10 03:07:00 -07:00
|
|
|
interested in: they'll be ignored by the function.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
Note: On failure, this function will make all non-$null geometry
|
2015-07-10 03:07:00 -07:00
|
|
|
pointers' pointed variables be set to zero.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@out x: Evas.Coord; [[A pointer to a variable where to store the parts region's
|
|
|
|
x coordinate]]
|
|
|
|
@out y: Evas.Coord; [[A pointer to a variable where to store the parts region's
|
|
|
|
y coordinate]]
|
|
|
|
@out w: Evas.Coord; [[A pointer to a variable where to store the parts region's
|
|
|
|
width]]
|
|
|
|
@out h: Evas.Coord; [[A pointer to a variable where to store the parts region's
|
|
|
|
height]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_drag_value_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the dragable object location.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Places the dragable object at the given location.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Values for dx and dy are real numbers that range from 0 to 1,
|
|
|
|
representing the relative position to the dragable area on that axis.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This value means, for the vertical axis, that 0.0 will be at the top if the
|
2015-07-10 06:02:32 -07:00
|
|
|
first parameter of $y in the dragable part theme is 1, and at bottom if it
|
2015-07-10 03:07:00 -07:00
|
|
|
is -1.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
For the horizontal axis, 0.0 means left if the first parameter of $x in the
|
2015-07-10 03:07:00 -07:00
|
|
|
dragable part theme is 1, and right if it is -1.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_value_get()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in dx: double; [[The x value]]
|
|
|
|
@in dy: double; [[The y value]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_drag_value_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the dragable object location.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Values for dx and dy are real numbers that range from 0 to 1,
|
|
|
|
representing the relative position to the dragable area on that axis.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_value_set()
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Gets the drag location values.]]
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@out dx: double; [[The X value pointer]]
|
|
|
|
@out dy: double; [[The Y value pointer]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
calc_force {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Force a Size/Geometry calculation.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Forces the object obj to recalculation layout regardless of
|
|
|
|
freeze/thaw.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
}
|
|
|
|
part_text_cursor_pos_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the cursor position to the given value
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[The cursor to move]]
|
|
|
|
@in pos: int; [[the position of the cursor]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_cursor_pos_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Retrieves the current position of the cursor
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
|
|
|
return: int; [[The cursor position]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[The cursor to get the position]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
freeze {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Freezes the Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function puts all changes on hold. Successive freezes will
|
|
|
|
nest, requiring an equal number of thaws.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.thaw()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: int; [[The frozen state or 0 on Error]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_cursor_content_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Returns the content (char) at the cursor position.
|
|
|
|
\@ref evas_textblock_cursor_content_get
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
You must free the return (if not $null) after you are done with it.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: char *; [[The character string pointed to (may be a multi-byte utf8 sequence) terminated by a nul byte.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[The cursor to use]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_layout_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the layout of the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The layout of the input panel or virtual keyboard can make it easier or
|
|
|
|
harder to enter content. This allows you to hint what kind of input you
|
|
|
|
are expecting to enter and thus have the input panel automatically
|
|
|
|
come up with the right mode.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in layout: Edje.Input_Panel.Layout; [[layout type]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_layout_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the layout of the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_input_panel_layout_set
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1]]
|
|
|
|
return: Edje.Input_Panel.Layout; [[Layout type of the input panel]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_table_pack {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Packs an object into the table.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Packs an object into the table indicated by part.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true object was added, $false on failure]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in child_obj: Evas.Object *; [[The object to pack in]]
|
|
|
|
@in col: ushort; [[The column to place it in]]
|
|
|
|
@in row: ushort; [[The row to place it in]]
|
|
|
|
@in colspan: ushort; [[Columns the child will take]]
|
|
|
|
@in rowspan: ushort; [[Rows the child will take]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_language_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the language mode of the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This API can be used if you want to show the Alphabet keyboard.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in lang: Edje.Input_Panel.Lang; [[the language to be set to the input panel.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_language_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the language mode of the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_input_panel_language_set for more details.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
|
|
|
return: Edje.Input_Panel.Lang; [[input panel language type]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_table_col_row_size_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets the number of columns and rows the table has.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Retrieves the size of the table in number of columns and rows.]]
|
|
|
|
return: bool; [[$true get some data, $false on failure]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2015-07-10 06:02:32 -07:00
|
|
|
@out cols: int; [[Pointer where to store number of columns (can be $null)]]
|
|
|
|
@out rows: int; [[Pointer where to store number of rows (can be $null)]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_external_object_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the object created by this external part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Parts of type external creates the part object using information
|
|
|
|
provided by external plugins. It's somehow like "swallow"
|
|
|
|
(edje_object_part_swallow()), but it's all set automatically.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns the part created by such external plugins and
|
|
|
|
being currently managed by this Edje.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
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!]]
|
2015-07-10 06:02:32 -07:00
|
|
|
return: Evas.Object *; [[The externally created object, or $null if there is none or
|
2015-07-10 03:07:00 -07:00
|
|
|
part is not an external.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_external_content_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get an object contained in an part of type EXTERNAL
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
The content string must not be $null. Its actual value depends on the
|
2015-07-10 03:07:00 -07:00
|
|
|
code providing the EXTERNAL.]]
|
2015-06-01 06:01:11 -07:00
|
|
|
return: Evas.Object *;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@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]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
preload {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Preload the images on the Edje Object in the background.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function requests the preload of all data images (on the given
|
|
|
|
object) in the background. The work is queued before being processed
|
|
|
|
(because there might be other pending requests of this type).
|
|
|
|
It emits a signal "preload,done" when finished.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note: Use $true on scenarios where you don't need
|
|
|
|
the image data preloaded anymore.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$false if obj was not a valid Edje object
|
|
|
|
otherwise $true]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in cancel: bool; [[$false will add it the preloading work queue,
|
|
|
|
$true will remove it (if it was issued before).]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_enabled_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the attribute to show the input panel automatically.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in enabled: bool; [[If true, the input panel is appeared when entry is clicked or has a focus]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_enabled_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Retrieve the attribute to show the input panel automatically.
|
|
|
|
See also @.part_text_input_panel_enabled_set
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
|
|
|
return: bool; [[true if it supports or false otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_select_extend @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Extends the current selection to the current cursor position]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_box_insert_at {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Inserts an object to the box.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Adds child to the box indicated by part, in the position given by
|
|
|
|
pos.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_box_append(), @.part_box_prepend() and @.part_box_insert_before()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true: Successfully added.
|
|
|
|
$false: An error occurred.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in child: Evas.Object *; [[The object to insert]]
|
|
|
|
@in pos: uint; [[The position where to insert child]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_anchor_geometry_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return a list of Evas_Textblock_Rectangle anchor rectangles.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
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.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in anchor: const(char)*; [[The anchor name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_cursor_down {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Moves the cursor to the char below the current cursor position.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[the edje cursor to work on]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_drag_page_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the page step increments.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Sets the x,y page step increment values.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Values for dx and dy are real numbers that range from 0 to 1,
|
|
|
|
representing the relative size of the dragable area on that axis by which the
|
|
|
|
part will be moved.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_page_get()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in dx: double; [[The x page step increment]]
|
|
|
|
@in dy: double; [[The y page step increment]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_drag_page_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets the page step increments.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Gets the x,y page step increments for the dragable object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_page_set()]]
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@out dx: double; [[The dx page increment pointer]]
|
|
|
|
@out dy: double; [[The dy page increment pointer]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_box_prepend {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Prepends an object to the box.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Prepends child to the box indicated by part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_box_append(), @.part_box_insert_before() and @.part_box_insert_at()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true: Successfully added.
|
|
|
|
$false: An error occurred.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in child: Evas.Object *; [[The object to prepend]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
signal_emit {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Send/emit an Edje signal to a given Edje object
|
|
|
|
|
|
|
|
This function sends a signal to the object obj. An Edje program,
|
|
|
|
at obj's EDC specification level, can respond to a signal by
|
|
|
|
having declared matching @'signal' and @'source' fields on its
|
|
|
|
block (see \@ref edcref "the syntax" for EDC files).
|
|
|
|
|
|
|
|
See also @.signal_callback_add() for more on Edje signals.]]
|
|
|
|
/* FIXME-doc
|
|
|
|
* @code
|
|
|
|
* program
|
|
|
|
* {
|
|
|
|
* name: "a_program";
|
|
|
|
* signal: "a_signal";
|
|
|
|
* source: "";
|
|
|
|
* action: ...
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
*/
|
|
|
|
params {
|
|
|
|
@in emission: const(char)*; [[The signal's "emission" string]]
|
|
|
|
@in source: const(char)*; [[The signal's "source" string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_layout_variation_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the layout variation of the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The layout variation of the input panel or virtual keyboard can make it easier or
|
|
|
|
harder to enter content. This allows you to hint what kind of input you
|
|
|
|
are expecting to enter and thus have the input panel automatically
|
|
|
|
come up with the right mode.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.8]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in variation: int; [[layout variation type]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_layout_variation_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the layout variation of the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_input_panel_layout_variation_set
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.8]]
|
|
|
|
return: int; [[Layout variation type of the input panel]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
message_send {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Send an (Edje) message to a given Edje object
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function sends an Edje message to obj and to all of its
|
|
|
|
child objects, if it has any (swallowed objects are one kind of
|
|
|
|
child object). type and msg must be matched accordingly,
|
|
|
|
as documented in #Edje_Message_Type.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The id argument as a form of code and theme defining a common
|
|
|
|
interface on message communication. One should define the same IDs
|
|
|
|
on both code and EDC declaration (see \@ref edcref "the syntax" for
|
|
|
|
EDC files), to individualize messages (binding them to a given
|
|
|
|
context).
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The function to handle messages arriving from obj is set with
|
|
|
|
edje_object_message_handler_set().]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in type: Edje.Message_Type; [[The type of message to send to obj]]
|
|
|
|
@in id: int; [[A identification number for the message to be sent]]
|
|
|
|
@in msg: void *; [[The message's body, a struct depending on type]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_select_none @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the selection to be none.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function sets the selection text to be none.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_object_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get a handle to the Evas object implementing a given Edje
|
|
|
|
part, in an Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function gets a pointer of the Evas object corresponding to a
|
|
|
|
given part in the obj object's group.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
You should never modify the state of the returned object (with
|
|
|
|
\@ref evas_object_move() or \@ref evas_object_hide() for example),
|
|
|
|
because it's meant to be managed by Edje, solely. You are safe to
|
|
|
|
query information about its current state (with
|
|
|
|
evas_object_visible_get() or \@ref evas_object_color_get() for
|
|
|
|
example), though.]]
|
|
|
|
return: const(Evas.Object)*; [[A pointer to the Evas object implementing the given part,
|
2015-07-10 06:02:32 -07:00
|
|
|
or $null on failure (e.g. the given part doesn't exist)]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The Edje part's name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_drag_size_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the dragable object size.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Values for dw and dh are real numbers that range from 0 to 1,
|
|
|
|
representing the relative size of the dragable area on that axis.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Sets the size of the dragable object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_size_get()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in dw: double; [[The drag width]]
|
|
|
|
@in dh: double; [[The drag height]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_drag_size_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the dragable object size.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Gets the dragable object size.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_size_set()]]
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@out dw: double; [[The drag width pointer]]
|
|
|
|
@out dh: double; [[The drag height pointer]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
text_insert_filter_callback_del {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Delete a function from the filter list.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Delete the given func filter from the list in part. Returns
|
|
|
|
the user data pointer given when added.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.text_insert_filter_callback_add and @.text_insert_filter_callback_del_full]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
return: void *; [[The user data pointer if successful, or $null otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in func: Edje.Text.Filter_Cb; [[The function callback to remove]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_drag_dir_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Determine dragable directions.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The dragable directions are defined in the EDC file, inside the \@ref dragable
|
2015-07-10 06:02:32 -07:00
|
|
|
section, by the attributes $x and $y. See the \@ref edcref for more
|
2015-07-10 03:07:00 -07:00
|
|
|
information.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: Edje.Drag_Dir; [[#EDJE_DRAG_DIR_NONE: Not dragable
|
|
|
|
#EDJE_DRAG_DIR_X: Dragable in X direction
|
|
|
|
#EDJE_DRAG_DIR_Y: Dragable in Y direction
|
|
|
|
#EDJE_DRAG_DIR_XY: Dragable in X & Y directions]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_unescaped_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the raw (non escaped) text for an object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-09-18 20:54:58 -07:00
|
|
|
This function will not do escape for you if it is a TEXTBLOCK part, that is,
|
2015-07-10 03:07:00 -07:00
|
|
|
if text contain tags, these tags will not be interpreted/parsed by TEXTBLOCK.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_unescaped_get().]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in text_to_escape: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_unescaped_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Returns the text of the object part, without escaping.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function is the counterpart of
|
|
|
|
edje_object_part_text_unescaped_set(). Please notice that the
|
|
|
|
result is newly allocated memory and should be released with free()
|
|
|
|
when done.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_unescaped_set().]]
|
2015-07-10 06:02:32 -07:00
|
|
|
return: char *; [[The allocated text string without escaping, or $null on
|
2015-07-10 03:07:00 -07:00
|
|
|
problems.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
signal_callback_add {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Add a callback for an arriving Edje signal, emitted by
|
|
|
|
a given Edje object.
|
|
|
|
|
|
|
|
Edje signals are one of the communication interfaces between
|
|
|
|
code and a given Edje object's theme. With signals, one can
|
|
|
|
communicate two string values at a time, which are:
|
|
|
|
- "emission" value: the name of the signal, in general
|
|
|
|
- "source" value: a name for the signal's context, in general
|
|
|
|
|
|
|
|
Though there are those common uses for the two strings, one is free
|
|
|
|
to use them however they like.
|
|
|
|
|
|
|
|
Signal callback registration is powerful, in the way that blobs
|
2015-07-10 06:02:32 -07:00
|
|
|
may be used to match multiple signals at once. All the
|
|
|
|
"*?[\" set of $fnmatch() operators can be used, both for
|
2015-07-10 03:07:00 -07:00
|
|
|
emission and source.
|
|
|
|
|
|
|
|
Edje has internal signals it will emit, automatically, on
|
|
|
|
various actions taking place on group parts. For example, the mouse
|
|
|
|
cursor being moved, pressed, released, etc., over a given part's
|
|
|
|
area, all generate individual signals.
|
|
|
|
|
|
|
|
By using something like
|
|
|
|
edje_object_signal_callback_add(obj, "mouse,down,*", "button.*",
|
|
|
|
signal_cb, NULL);
|
|
|
|
being \@ref "button.*" the pattern for the names of parts implementing
|
|
|
|
buttons on an interface, you'd be registering for notifications on
|
|
|
|
events of mouse buttons being pressed down on either of those parts
|
|
|
|
(those events all have the @"mouse,down," common prefix on their
|
|
|
|
names, with a suffix giving the button number). The actual emission
|
|
|
|
and source strings of an event will be passed in as the emission
|
|
|
|
and source parameters of the callback function (e.g.
|
|
|
|
"mouse,down,2" and @"button.close"), for each of those events.
|
|
|
|
|
|
|
|
Note: See \@ref edcref "the syntax" for EDC files
|
|
|
|
See also @.signal_emit() on how to emits Edje signals from
|
|
|
|
code to a an object
|
|
|
|
\@ref edje_object_signal_callback_del_full()]]
|
|
|
|
/* FIXME-doc
|
|
|
|
* This function adds a callback function to a signal emitted by obj, to
|
|
|
|
* be issued every time an EDC program like the following
|
|
|
|
* @code
|
|
|
|
* program
|
|
|
|
* {
|
|
|
|
* name: "emit_example";
|
|
|
|
* action: SIGNAL_EMIT "a_signal" "a_source";
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
* is run, if emission and source are given those same values,
|
|
|
|
* here.
|
|
|
|
*/
|
|
|
|
|
|
|
|
params {
|
|
|
|
@in emission: const(char)*; [[The signal's "emission" string]]
|
|
|
|
@in source: const(char)*; [[The signal's "source" string]]
|
|
|
|
@in func: Edje.Signal_Cb; [[The callback function to be executed when the signal is
|
|
|
|
emitted.]]
|
|
|
|
@in data: void *; [[A pointer to data to pass in to func.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_select_all @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the selection to be everything.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function selects all text of the object of the part.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_return_key_disabled_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the return key on the input panel to be disabled.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in disabled: bool; [[The state]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_return_key_disabled_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get whether the return key on the input panel should be disabled or not.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
|
|
|
return: bool; [[true if it should be disabled]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_autocapital_type_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the autocapitalization type on the immodule.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in autocapital_type: Edje.Text.Autocapital_Type; [[The type of autocapitalization]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_autocapital_type_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Retrieves the autocapitalization type
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.1.0]]
|
|
|
|
return: Edje.Text.Autocapital_Type; [[The autocapitalization type]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_unswallow {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Unswallow an object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Causes the edje to regurgitate a previously swallowed object. :)
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note: obj_swallow will not be deleted or hidden.
|
|
|
|
Note: obj_swallow may appear shown on the evas depending on its state when
|
|
|
|
it got unswallowed. Make sure you delete it or hide it if you do not want it to.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in obj_swallow: Evas.Object *; [[The swallowed object]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_prediction_allow_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set whether the prediction is allowed or not.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in prediction: bool; [[If true, the prediction feature is allowed.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_prediction_allow_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get whether the prediction is allowed or not.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
|
|
|
return: bool; [[true if prediction feature is allowed.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
data_get @const {
|
2015-07-10 06:02:32 -07:00
|
|
|
[[Retrive an EDC data field's value from a given Edje object's group.
|
2015-07-10 03:07:00 -07:00
|
|
|
|
|
|
|
This function fetches an EDC data field's value, which is declared
|
2015-07-10 06:02:32 -07:00
|
|
|
on the objects building EDC file, under its group. EDC data blocks
|
|
|
|
are most commonly used to pass arbitrary parameters from an
|
2015-07-10 03:07:00 -07:00
|
|
|
application's theme to its code.
|
|
|
|
|
|
|
|
EDC data fields always hold strings as values, hence the return
|
|
|
|
type of this function. Check the complete \@ref edcref "syntax reference"
|
|
|
|
for EDC files.
|
|
|
|
|
|
|
|
Warning: Do not confuse this call with edje_file_data_get(), which
|
|
|
|
queries for a global EDC data field on an EDC declaration file.
|
|
|
|
|
|
|
|
\@ref edje_object_file_set()]]
|
|
|
|
/* FIXME-doc
|
|
|
|
* They look like the following:
|
|
|
|
* @code
|
|
|
|
* collections
|
|
|
|
* {
|
|
|
|
* group
|
|
|
|
* {
|
|
|
|
* name: "a_group";
|
|
|
|
* data
|
|
|
|
* {
|
|
|
|
* item: "key1" "value1";
|
|
|
|
* item: "key2" "value2";
|
|
|
|
* }
|
|
|
|
* }
|
|
|
|
* }
|
|
|
|
* @endcode
|
|
|
|
*/
|
|
|
|
return: const(char)*; [[The data's value string. Must not be freed.]]
|
|
|
|
params {
|
|
|
|
@in key: const(char)*; [[The data field's key string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
text_markup_filter_callback_add {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Add a markup filter function for newly inserted text.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Whenever text is inserted (not the same as set) into the given part,
|
|
|
|
the list of markup filter functions will be called to decide if and how
|
|
|
|
the new text will be accepted.
|
|
|
|
The text parameter in the func filter is always markup. It can be
|
|
|
|
modified by the user and it's up to him to free the one passed if he's to
|
|
|
|
change the pointer. If doing so, the newly set text should be malloc'ed,
|
|
|
|
as once all the filters are called Edje will free it.
|
2015-07-10 06:02:32 -07:00
|
|
|
If the text is to be rejected, freeing it and setting the pointer to $null
|
2015-07-10 03:07:00 -07:00
|
|
|
will make Edje break out of the filter cycle and reject the inserted
|
|
|
|
text.
|
|
|
|
This function is different from edje_object_text_insert_filter_callback_add()
|
|
|
|
in that the text parameter in the fucn filter is always markup.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Warning: If you use this function with
|
|
|
|
edje_object_text_insert_filter_callback_add() togehter, all
|
|
|
|
Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
|
|
|
|
will be executed, and then filtered text will be inserted.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.text_markup_filter_callback_del, @.text_markup_filter_callback_del_full
|
|
|
|
and @.text_insert_filter_callback_add
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in func: Edje.Markup_Filter_Cb; [[The callback function that will act as markup filter]]
|
|
|
|
@in data: void *; [[User provided data to pass to the filter function]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
message_signal_process {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Process an object's message queue.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function goes through the object message queue processing the
|
|
|
|
pending messages for this specific Edje object. Normally they'd
|
|
|
|
be processed only at idle time.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
}
|
|
|
|
part_box_remove {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Removes an object from the box.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Removes child from the box indicated by part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_box_remove_at() and @.part_box_remove_all()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
return: Evas.Object *; [[Pointer to the object removed, or $null.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in child: Evas.Object *; [[The object to remove]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
thaw {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Thaws the Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function thaws the given Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note:: If sucessives freezes were done, an equal number of
|
|
|
|
thaws will be required.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.freeze()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: int; [[The frozen state or 0 if the object is not frozen or on error.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_swallow_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the object currently swallowed by a part.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
return: Evas.Object *; [[The swallowed object, or $null if there is none.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_imf_context_reset @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Reset the input method context if needed.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This can be necessary in the case where modifying the buffer would confuse on-going input method behavior
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_return_key_type_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the "return" key type. This type is used to set string or icon on the "return" key of the input panel.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
An input panel displays the string or icon associated with this type
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in return_key_type: Edje.Input_Panel.Return_Key_Type; [[The type of "return" key on the input panel]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_return_key_type_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the "return" key type.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_input_panel_return_key_type_set() for more details
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
|
|
|
return: Edje.Input_Panel.Return_Key_Type; [[The type of "return" key on the input panel]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_table_child_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Retrieve a child from a table]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: Evas.Object *; [[The child Evas.Object]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in col: uint; [[The column of the child to get]]
|
|
|
|
@in row: uint; [[The row of the child to get]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_box_insert_before {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Adds an object to the box.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Inserts child in the box given by part, in the position marked by
|
|
|
|
reference.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_box_append(), @.part_box_prepend() and @.part_box_insert_at()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true: Successfully added.
|
|
|
|
$false: An error occurred.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in child: Evas.Object *; [[The object to insert]]
|
|
|
|
@in reference: const(Evas.Object)*; [[The object to be used as reference]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_external_param_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the parameter for the external part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Parts of type external may carry extra properties that have
|
|
|
|
meanings defined by the external plugin. For instance, it may be a
|
|
|
|
string that defines a button label and setting this property will
|
|
|
|
change that label on the fly.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note: external parts have parameters set when they change
|
|
|
|
states. Those parameters will never be changed by this
|
|
|
|
function. The interpretation of how state_set parameters and
|
|
|
|
param_set will interact is up to the external plugin.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note: this function will not check if parameter value is valid
|
|
|
|
using #Edje_External_Param_Info minimum, maximum, valid
|
|
|
|
choices and others. However these should be checked by the
|
|
|
|
underlying implementation provided by the external
|
|
|
|
plugin. This is done for performance reasons.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true if everything went fine, $false on errors.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in param: const(Edje.External.Param)*; [[the parameter details, including its name, type and
|
|
|
|
actual value. This pointer should be valid, and the
|
|
|
|
parameter must exist in
|
|
|
|
#Edje_External_Type.parameters_info, with the exact type,
|
|
|
|
otherwise the operation will fail and $false will be
|
|
|
|
returned.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_external_param_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the parameter for the external part.
|
|
|
|
|
|
|
|
Parts of type external may carry extra properties that have
|
|
|
|
meanings defined by the external plugin. For instance, it may be a
|
|
|
|
string that defines a button label. This property can be modified by
|
|
|
|
state parameters, by explicit calls to
|
|
|
|
edje_object_part_external_param_set() or getting the actual object
|
|
|
|
with edje_object_part_external_object_get() and calling native
|
|
|
|
functions.
|
|
|
|
|
|
|
|
This function asks the external plugin what is the current value,
|
|
|
|
independent on how it was set.]]
|
|
|
|
|
|
|
|
return: bool; [[$true if everything went fine and param members
|
|
|
|
are filled with information, $false on errors and
|
|
|
|
param member values are not set or valid.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@out param: Edje.External.Param; [[the parameter details. It is used as both input and
|
|
|
|
output variable. This pointer should be valid, and the
|
|
|
|
parameter must exist in
|
|
|
|
#Edje_External_Type.parameters_info, with the exact type,
|
|
|
|
otherwise the operation will fail and $false will be
|
|
|
|
returned.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
size_min_calc {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Calculate the minimum required size for a given Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This call works exactly as edje_object_size_min_restricted_calc(),
|
|
|
|
with the last two arguments set to 0. Please refer to its
|
|
|
|
documentation, then.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@out minw: Evas.Coord; [[Pointer to a variable where to store the minimum
|
|
|
|
required width]]
|
|
|
|
@out minh: Evas.Coord; [[Pointer to a variable where to store the minimum
|
|
|
|
required height]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_box_append {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Appends an object to the box.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Appends child to the box indicated by part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_box_prepend(), @.part_box_insert_before()
|
|
|
|
and @.part_box_insert_at()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true: Successfully added.
|
|
|
|
$false: An error occurred.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in child: Evas.Object *; [[The object to append]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
size_min_restricted_calc {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Calculate the minimum required size for a given Edje object.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This call will trigger an internal recalculation of all parts of
|
|
|
|
the obj object, in order to return its minimum required
|
|
|
|
dimensions for width and height. The user might choose to impose
|
|
|
|
those minimum sizes, making the resulting calculation to get to values
|
|
|
|
equal or bigger than restrictedw and restrictedh, for width and
|
|
|
|
height, respectively.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note: At the end of this call, obj won't be automatically
|
|
|
|
resized to new dimensions, but just return the calculated
|
|
|
|
sizes. The caller is the one up to change its geometry or not.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Warning: Be advised that invisible parts in obj will be taken
|
|
|
|
into account in this calculation.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@out minw: Evas.Coord; [[Pointer to a variable where to store the minimum
|
|
|
|
required width]]
|
|
|
|
@out minh: Evas.Coord; [[Pointer to a variable where to store the minimum
|
|
|
|
required height]]
|
|
|
|
@in restrictedw: Evas.Coord; [[Do not allow object's calculated (minimum) width
|
|
|
|
to be less than this value]]
|
|
|
|
@in restrictedh: Evas.Coord; [[Do not allow object's calculated (minimum)
|
|
|
|
height to be less than this value]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_box_remove_all {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Removes all elements from the box.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Removes all the external objects from the box indicated by part.
|
|
|
|
Elements created from the theme will not be removed.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_box_remove() and @.part_box_remove_at()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[1: Successfully cleared.
|
|
|
|
0: An error occurred.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in clear: bool; [[Delete objects on removal]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_drag_page {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Pages x,y steps.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Pages x,y where the increment is defined by
|
|
|
|
edje_object_part_drag_page_set.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Values for dx and dy are real numbers that range from 0 to 1.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Warning: Paging is bugged!
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_step()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in dx: double; [[The x step]]
|
|
|
|
@in dy: double; [[The y step]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the text for an object part]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[$true on success, $false otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in text: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return the text of the object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns the text associated to the object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_set().]]
|
|
|
|
return: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_panel_show_on_demand_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set the attribute to show the input panel in case of only an user's explicit Mouse Up event.
|
|
|
|
It doesn't request to show the input panel even though it has focus.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.9.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in ondemand: bool; [[If true, the input panel will be shown in case of only Mouse up event. (Focus event will be ignored.)]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_show_on_demand_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get the attribute to show the input panel in case of only an user's explicit Mouse Up event.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.9.0]]
|
|
|
|
return: bool; [[$true if the input panel will be shown in case of only Mouse up event.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-09-01 03:01:54 -07:00
|
|
|
part_text_input_hint_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the input hint which allows input methods to fine-tune their behavior.
|
2014-09-01 03:01:54 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.12.0]]
|
2014-09-01 03:01:54 -07:00
|
|
|
|
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in input_hints: Edje.Input_Hints; [[input hints]]
|
2014-09-01 03:01:54 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_input_hint_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets the value of input hint
|
2014-09-01 03:01:54 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.12.0]]
|
|
|
|
return: Edje.Input_Hints; [[The value of input hint]]
|
2014-09-01 03:01:54 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-09-01 03:01:54 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_selection_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return the selection text of the object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns selection text of the object part.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_text_select_all() and @.part_text_select_none()]]
|
|
|
|
return: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_cursor_is_format_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Returns whether the cursor points to a format.
|
|
|
|
\@ref evas_textblock_cursor_is_format]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
return: bool; [[true if it's true, false otherwise.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[The cursor to adjust.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-03-25 10:45:59 -07:00
|
|
|
text_class_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets font and font size from edje text class.
|
2015-03-25 10:45:59 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function gets the font and the font size from the object
|
|
|
|
text class. The font string will only be valid until the text
|
|
|
|
class is changed or the edje object is deleted.]]
|
|
|
|
return: bool; [[$true, on success or $false, on error]]
|
2015-03-25 10:45:59 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in text_class: const(char)*; [[The text class name]]
|
|
|
|
@out font: const(char)*; [[Font name]]
|
|
|
|
@out size: Evas.Font.Size; [[Font Size]]
|
2015-03-25 10:45:59 -07:00
|
|
|
}
|
|
|
|
}
|
2014-03-18 07:00:14 -07:00
|
|
|
color_class_set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Sets the object color class.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function sets the color values for an object level color
|
|
|
|
class. This will cause all edje parts in the specified object that
|
|
|
|
have the specified color class to have their colors multiplied by
|
|
|
|
these values.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The first color is the object, the second is the text outline, and
|
|
|
|
the third is the text shadow. (Note that the second two only apply
|
|
|
|
to text parts).
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Setting color emits a signal "color_class,set" with source being
|
|
|
|
the given color.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note: unlike Evas, Edje colors are not pre-multiplied. That is,
|
|
|
|
half-transparent white is 255 255 255 128.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-05-18 08:13:08 -07:00
|
|
|
@in color_class: const(char)*;
|
2015-07-10 03:07:00 -07:00
|
|
|
@in r: int; [[Object Red value]]
|
|
|
|
@in g: int; [[Object Green value]]
|
|
|
|
@in b: int; [[Object Blue value]]
|
|
|
|
@in a: int; [[Object Alpha value]]
|
|
|
|
@in r2: int; [[Outline Red value]]
|
|
|
|
@in g2: int; [[Outline Green value]]
|
|
|
|
@in b2: int; [[Outline Blue value]]
|
|
|
|
@in a2: int; [[Outline Alpha value]]
|
|
|
|
@in r3: int; [[Shadow Red value]]
|
|
|
|
@in g3: int; [[Shadow Green value]]
|
|
|
|
@in b3: int; [[Shadow Blue value]]
|
|
|
|
@in a3: int; [[Shadow Alpha value]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
color_class_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets the object color class.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function gets the color values for an object level color
|
|
|
|
class. If no explicit object color is set, then global values will
|
|
|
|
be used.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
The first color is the object, the second is the text outline, and
|
|
|
|
the third is the text shadow. (Note that the second two only apply
|
|
|
|
to text parts).
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note: unlike Evas, Edje colors are not pre-multiplied. That is,
|
|
|
|
half-transparent white is 255 255 255 128.]]
|
|
|
|
return: bool; [[true if found or false if not found and all
|
|
|
|
values are zeroed.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-05-18 08:13:08 -07:00
|
|
|
@in color_class: const(char)*;
|
2015-07-10 03:07:00 -07:00
|
|
|
@out r: int; [[Object Red value]]
|
|
|
|
@out g: int; [[Object Green value]]
|
|
|
|
@out b: int; [[Object Blue value]]
|
|
|
|
@out a: int; [[Object Alpha value]]
|
|
|
|
@out r2: int; [[Outline Red value]]
|
|
|
|
@out g2: int; [[Outline Green value]]
|
|
|
|
@out b2: int; [[Outline Blue value]]
|
|
|
|
@out a2: int; [[Outline Alpha value]]
|
|
|
|
@out r3: int; [[Shadow Red value]]
|
|
|
|
@out g3: int; [[Shadow Green value]]
|
|
|
|
@out b3: int; [[Shadow Blue value]]
|
|
|
|
@out a3: int; [[Shadow Alpha value]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-03-07 10:38:57 -08:00
|
|
|
color_class_description_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Gets the description of an object color class.
|
2015-03-07 10:38:57 -08:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function gets the description of a color class in use by an object.]]
|
2015-07-10 06:02:32 -07:00
|
|
|
return: const(char)*; [[The description of the target color class or $null if not found]]
|
2015-03-07 10:38:57 -08:00
|
|
|
params {
|
2015-05-18 08:13:08 -07:00
|
|
|
@in color_class: const(char)*;
|
2015-03-07 10:38:57 -08:00
|
|
|
}
|
|
|
|
}
|
2014-03-18 07:00:14 -07:00
|
|
|
part_drag_step {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Steps the dragable x,y steps.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Steps x,y where the step increment is the amount set by
|
|
|
|
edje_object_part_drag_step_set.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Values for dx and dy are real numbers that range from 0 to 1.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.part_drag_page()]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in dx: double; [[The x step]]
|
|
|
|
@in dy: double; [[The y step]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_cursor_up {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Move the cursor to the char above the current cursor position.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[the edje cursor to work on]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_cursor_geometry_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Returns the cursor geometry of the part relative to the edje
|
|
|
|
object.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@out x: Evas.Coord; [[Cursor X position]]
|
|
|
|
@out y: Evas.Coord; [[Cursor Y position]]
|
|
|
|
@out w: Evas.Coord; [[Cursor width]]
|
|
|
|
@out h: Evas.Coord; [[Cursor height]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_anchor_list_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return a list of char anchor names.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns a list of char anchor names.]]
|
|
|
|
return: const(list<const(char)*>)*; [[The list of anchors (const char *), do not modify!]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
text_insert_filter_callback_add {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Add a filter function for newly inserted text.
|
|
|
|
|
|
|
|
Whenever text is inserted (not the same as set) into the given part,
|
|
|
|
the list of filter functions will be called to decide if and how the new
|
|
|
|
text will be accepted.
|
|
|
|
There are three types of filters, EDJE_TEXT_FILTER_TEXT,
|
|
|
|
EDJE_TEXT_FILTER_FORMAT and EDJE_TEXT_FILTER_MARKUP.
|
|
|
|
The text parameter in the func filter can be modified by the user and
|
|
|
|
it's up to him to free the one passed if he's to change the pointer. If
|
|
|
|
doing so, the newly set text should be malloc'ed, as once all the filters
|
|
|
|
are called Edje will free it.
|
2015-07-10 06:02:32 -07:00
|
|
|
If the text is to be rejected, freeing it and setting the pointer to $null
|
2015-07-10 03:07:00 -07:00
|
|
|
will make Edje break out of the filter cycle and reject the inserted
|
|
|
|
text.
|
|
|
|
|
|
|
|
Warning: This function will be deprecated because of difficulty in use.
|
|
|
|
The type(format, text, or markup) of text should be always
|
|
|
|
checked in the filter function for correct filtering.
|
|
|
|
Please use edje_object_text_markup_filter_callback_add() instead. There
|
|
|
|
is no need to check the type of text in the filter function
|
|
|
|
because the text is always markup.
|
|
|
|
Warning: If you use this function with
|
|
|
|
edje_object_text_markup_filter_callback_add() together, all
|
|
|
|
Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions
|
|
|
|
will be executed, and then filtered text will be inserted.
|
|
|
|
|
|
|
|
See also @.text_insert_filter_callback_del, @.text_insert_filter_callback_del_full
|
|
|
|
and @.text_markup_filter_callback_add]]
|
|
|
|
|
|
|
|
params {
|
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in func: Edje.Text.Filter_Cb; [[The callback function that will act as filter]]
|
|
|
|
@in data: void *; [[User provided data to pass to the filter function]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_input_panel_show @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Show the input panel (virtual keyboard) based on the input panel property such as layout, autocapital types, and so on.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Note that input panel is shown or hidden automatically according to the focus state.
|
|
|
|
This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_exists @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Check if an Edje part exists in a given Edje object's group
|
|
|
|
definition.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns if a given part exists in the Edje group
|
|
|
|
bound to object obj (with edje_object_file_set()).
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This call is useful, for example, when one could expect or not a
|
|
|
|
given GUI element, depending on the theme applied to obj.]]
|
|
|
|
return: bool; [[$true, if the Edje part exists in obj's group or
|
|
|
|
$false, otherwise (and on errors)]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part's name to check for existence in obj's
|
|
|
|
group]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
text_markup_filter_callback_del {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Delete a function from the markup filter list.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
Delete the given func filter from the list in part. Returns
|
|
|
|
the user data pointer given when added.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
See also @.text_markup_filter_callback_add and @.text_markup_filter_callback_del_full
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
return: void *; [[The user data pointer if successful, or $null otherwise]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in func: Edje.Markup_Filter_Cb; [[The function callback to remove]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_cursor_is_visible_format_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return true if the cursor points to a visible format
|
|
|
|
For example \\t, \\n, item and etc.
|
|
|
|
@ evas_textblock_cursor_format_is_visible_get]]
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[The cursor to adjust.]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_user_insert @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[This function inserts text as if the user has inserted it.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This means it actually registers as a change and emits signals, triggers
|
|
|
|
callbacks as appropriate.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
@since 1.2.0]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in text: const(char)*; [[The text string]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_text_cursor_prev {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Moves the cursor to the previous char
|
|
|
|
\@ref evas_textblock_cursor_char_prev]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
|
|
|
@in cur: Edje.Cursor; [[the edje cursor to work on]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2014-07-22 09:13:24 -07:00
|
|
|
part_text_item_list_get @const {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Return a list of char item names.
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This function returns a list of char item names.]]
|
|
|
|
return: const(list<const(char)*>)*; [[The list of items (const char *), do not modify!]]
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The part name]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
part_swallow {
|
2015-07-10 06:02:32 -07:00
|
|
|
[["Swallows" an object into one of the Edje object $SWALLOW
|
2015-07-10 03:07:00 -07:00
|
|
|
parts.
|
|
|
|
|
|
|
|
Swallowing an object into an Edje object is, for a given part of
|
2015-07-10 06:02:32 -07:00
|
|
|
type $SWALLOW in the EDC group which gave life to obj, to set
|
2015-07-10 03:07:00 -07:00
|
|
|
an external object to be controlled by obj, being displayed
|
|
|
|
exactly over that part's region inside the whole Edje object's
|
|
|
|
viewport.
|
|
|
|
|
|
|
|
From this point on, obj will have total control over
|
|
|
|
obj_swallow's geometry and visibility. For instance, if obj is
|
|
|
|
visible, as in \@ref evas_object_show(), the swallowed object will be
|
2015-07-10 06:02:32 -07:00
|
|
|
visible too -- if the given $SWALLOW part it's in is also visible.
|
|
|
|
Other actions on obj will also reflect on the swallowed object as
|
|
|
|
well (e.g. resizing, moving, raising/lowering, etc.).
|
2015-07-10 03:07:00 -07:00
|
|
|
|
|
|
|
Finally, all internal changes to part, specifically, will
|
|
|
|
reflect on the displaying of obj_swallow, for example state
|
|
|
|
changes leading to different visibility states, geometries,
|
|
|
|
positions, etc.
|
|
|
|
|
|
|
|
If an object has already been swallowed into this part, then it
|
|
|
|
will first be unswallowed (as in edje_object_part_unswallow())
|
|
|
|
before the new object is swallowed.
|
|
|
|
|
|
|
|
Note: obj won't delete the swallowed object once it is
|
|
|
|
deleted -- obj_swallow will get to an unparented state again.
|
|
|
|
|
2015-07-10 06:02:32 -07:00
|
|
|
For more details on EDC $SWALLOW parts, see \@ref edcref "syntax
|
2015-07-10 03:07:00 -07:00
|
|
|
reference".]]
|
2014-03-18 07:00:14 -07:00
|
|
|
|
2014-08-07 08:58:45 -07:00
|
|
|
return: bool;
|
2014-03-18 07:00:14 -07:00
|
|
|
params {
|
2015-07-10 03:07:00 -07:00
|
|
|
@in part: const(char)*; [[The swallow part's name]]
|
|
|
|
@in obj_swallow: Evas.Object *; [[The object to occupy that part]]
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
}
|
2015-06-22 09:46:12 -07:00
|
|
|
@property transition_duration_factor {
|
|
|
|
set {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Set transition duration factor.
|
2015-06-22 09:46:12 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This define the transition duration factor on this
|
|
|
|
specific object. By default all animation are run at a speed
|
|
|
|
factor of 1.0.]]
|
2015-06-22 09:46:12 -07:00
|
|
|
}
|
|
|
|
get {
|
2015-07-10 03:07:00 -07:00
|
|
|
[[Get transition duration factor.
|
2015-06-22 09:46:12 -07:00
|
|
|
|
2015-07-10 03:07:00 -07:00
|
|
|
This define the transition duration factor on this
|
|
|
|
specific object. By default all animation are run at a speed
|
|
|
|
factor of 1.0.]]
|
2015-06-22 09:46:12 -07:00
|
|
|
}
|
|
|
|
values {
|
2015-07-10 03:07:00 -07:00
|
|
|
scale: double; [[The transition duration factor]]
|
2015-06-22 09:46:12 -07:00
|
|
|
}
|
|
|
|
}
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
|
|
|
implements {
|
2014-06-20 03:14:59 -07:00
|
|
|
Eo.Base.constructor;
|
|
|
|
Eo.Base.destructor;
|
|
|
|
Eo.Base.dbg_info_get;
|
2014-06-27 15:22:28 -07:00
|
|
|
Evas.Object_Smart.hide;
|
|
|
|
Evas.Object_Smart.calculate;
|
|
|
|
Evas.Object_Smart.show;
|
|
|
|
Evas.Object_Smart.move;
|
|
|
|
Evas.Object_Smart.add;
|
|
|
|
Evas.Object_Smart.del;
|
|
|
|
Evas.Object_Smart.resize;
|
2014-07-21 03:47:23 -07:00
|
|
|
Efl.File.file.set;
|
|
|
|
Efl.File.file.get;
|
2015-04-03 07:23:13 -07:00
|
|
|
Efl.File.mmap.set;
|
|
|
|
Efl.File.mmap.get;
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|
2015-04-21 09:00:58 -07:00
|
|
|
events {
|
2015-06-11 09:09:02 -07:00
|
|
|
recalc; [[Edje re-calculated the object.]]
|
2015-04-21 09:00:58 -07:00
|
|
|
}
|
2014-03-18 07:00:14 -07:00
|
|
|
}
|