summaryrefslogtreecommitdiff
path: root/src/lib/evas/canvas/efl_canvas_group.eo
blob: 77bfecf3c1ae984bc39949152fb9f9d6a76bb146 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
class Efl.Canvas.Group (Efl.Canvas.Object)
{
   [[A group object is a container of other canvas objects. Its children
     move along their parent, are often clipped with a common clipper.
     This is part of the legacy smart object concept.

     A group is not necessarily a container (see @Efl.Container), in the
     sense that a standard widget may not have any empty slots for content,
     but is still a group of low-level canvas objects (clipper, raw objects,
     etc...).
   ]]
   legacy_prefix: evas_object_smart;
   data: Evas_Smart_Data;
   methods {
      @property group_need_recalculate {
         [[Indicates that the group's layout need to be recalculated.

           If this flag is set, then the @.group_calculate function will
           be called, during rendering phase of the canvas. After that,
           this flag will be automatically unset.

           Note: just setting this flag will not make the canvas' whole scene
           dirty, by itself, and evas_render() will have no effect. To
           force that, use @.group_change, that will also call this function
           automatically, with $true as parameter.

           See also @.group_calculate.
         ]]
         set {
            legacy: evas_object_smart_need_recalculate_set;
         }
         get {
            legacy: evas_object_smart_need_recalculate_get;
         }
         values {
            value: bool; [[$true if the group layout needs to be recalculated, $false otherwise]]
         }
      }
      group_change {
         [[Marks the object as dirty.

           This also forcefully marks the given object as needing
           recalculation. As an effect, on the next rendering cycle its
           @.group_calculate method will be called.
         ]]
         legacy: evas_object_smart_changed;
      }
      group_calculate {
         [[Triggers an immediate recalculation of this object's geometry.

           This will also reset the flag @.group_need_recalculate.
         ]]
         legacy: evas_object_smart_calculate;
      }
      group_members_iterate @const {
         [[Returns an iterator over the children of this object, that are
           canvas objects.

           This returns the list of "smart" children. This might be different
           from both the @Efl.Object children list as well as the @Efl.Container
           content list.
         ]]
         return: iterator<Efl.Canvas.Object> @owned;
            [[Iterator to object children]]
         legacy: evas_object_smart_iterator_new;
      }
      group_member_add {
         [[Set a canvas object as a member of a given group (or smart object).

           Members will automatically be stacked and layered together with the
           smart object. The various stacking functions will operate on
           members relative to the other members instead of the entire canvas,
           since they now live on an exclusive layer (see
           @Efl.Gfx.Stack.stack_above(), for more details).

           Subclasses inheriting from this one may override this function
           to ensure the proper stacking of special objects, such as clippers,
           event rectangles, etc...

           See also @.group_member_del.
           See also @.group_member_is.
         ]]
         params {
            @in sub_obj: Efl.Canvas.Object @nonull; [[The member object.]]
         }
         legacy: null;
      }
      group_member_del {
         [[Removes a member object from a given smart object.

           This removes a member object from a smart object, if it was added
           to any. The object will still be on the canvas, but no longer
           associated with whichever smart object it was associated with.

           See also @.group_member_add.
           See also @.group_member_is.
         ]]
         params {
            @in sub_obj: Efl.Canvas.Object; [[The member object to remove.]]
         }
         legacy: null;
      }
      group_member_is @const {
         [[Finds out if a given object is a member of this group.]]
         params {
            @in sub_obj: const(Efl.Canvas.Object); [[A potential sub object.]]
         }
         return: bool; [[$true if $sub_obj is a member of this group.]]
         legacy: null;
      }
      @property group_clipper @protected {
         [[The internal clipper object used by this group.

           This is the object clipping all the child objects. Do not delete
           or otherwise modify this clipper!
         ]]
         values {
            clipper: const(Efl.Canvas.Object); [[A clipper rectangle.]]
         }
         get {
            [[Get the internal clipper.]]
            legacy: null;
         }
      }
   }
   implements {
      class.constructor;
      class.destructor;
      Efl.Object.constructor;
      Efl.Object.destructor;
      Efl.Object.debug_name_override;
      Efl.Gfx.color { set; }
      Efl.Gfx.visible { set; }
      Efl.Gfx.position { set; }
      Efl.Canvas.Object.clip { set; }
      Efl.Canvas.Object.no_render { set; }
      Efl.Canvas.Object.paragraph_direction { get; set; }
   }
}