summaryrefslogtreecommitdiff
path: root/src/lib/evas/canvas/evas_vg_node.eo
blob: e989f7a3319a34ce6951c92fc75e6ed64052fadf (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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
abstract Evas.VG_Node (Eo.Base)
{
   eo_prefix: evas_vg_node;
   legacy_prefix: null;
   properties {
      transformation {
         set {
	 }
	 get {
	 }
	 values {
	    const(Eina_Matrix3) *m;
	 }
      }
      origin {
         set {
	 }
	 get {
	 }
	 values {
	    double x;
	    double y;
	 }
      }
      visibility {
         set {
            /*@ Makes the given Evas_VG node visible or invisible. */
	 }
	 get {
            /*@ Retrieves whether or not the given Evas_VG node is visible. */
	 }
	 values {
	    Eina_Bool v; /*@ @c EINA_TRUE if to make the object visible, @c EINA_FALSE otherwise */
	 }
      }
      color {
         set {
            /*@
            Sets the general/main color of the given Evas_VG node to the given
            one.

            @note These color values are expected to be premultiplied by @p a.

            @ingroup Evas_VG_Node_Group */
         }
         get {
            /*@
            Retrieves the general/main color of the given Evas_VG node.

            Retrieves the “main” color's RGB component (and alpha channel)
            values, <b>which range from 0 to 255</b>. For the alpha channel,
            which defines the object's transparency level, 0 means totally
            transparent, while 255 means opaque. These color values are
            premultiplied by the alpha value.

            @note Use @c NULL pointers on the components you're not interested
            in: they'll be ignored by the function.

            @ingroup Evas_VG_Node_Group */
	 }
	 values {
            int r; /*@ The red component of the given color. */
            int g; /*@ The green component of the given color. */
            int b; /*@ The blue component of the given color. */
            int a; /*@ The alpha component of the given color. */
	 }
      }
      mask {
         set {
	 }
	 get {
	 }
	 values {
	    Evas_VG_Node *m;
	 }
      }
/*      quality {
         set {
	 }
	 get {
	 }
	 values {
	    Evas_VG_Quality q;
	 }
      } */
   }
   methods {
      bound_get {
         return: bool @warn_unused;
	 params {
	    @out Eina_Rectangle r;
	 }
      }
      raise {
        /*@
         Raise @p obj to the top of its layer.

         @p obj will, then, be the highest one in the layer it belongs
         to. Object on other layers won't get touched.

         @see evas_vg_node_stack_above()
         @see evas_vg_node_stack_below()
         @see evas_vg_node_lower() */
      }
      stack_above {
         /*@
         Stack @p obj immediately above @p above

         Objects, in a given Evas_VG_Container, are stacked in the order they get added
         to it.  This means that, if they overlap, the highest ones will
         cover the lowest ones, in that order. This function is a way to
         change the stacking order for the objects.

         This function is intended to be used with <b>objects belonging to
         the same container</b>, otherwise it will fail (and
         accomplish nothing).

         @see evas_vg_node_stack_below() */

         params {
            @in Evas_VG_Node *above @nonull; /*@ the object above which to stack */
         }
      }
      stack_below {
         /*@
         Stack @p obj immediately below @p below

         Objects, in a given container, are stacked in the order they get added
         to it.  This means that, if they overlap, the highest ones will
         cover the lowest ones, in that order. This function is a way to
         change the stacking order for the objects.

         This function is intended to be used with <b>objects belonging to
         the same container</b>, otherwise it will fail (and
         accomplish nothing).

         @see evas_vg_node_layer_get()
         @see evas_vg_node_layer_set()
         @see evas_vg_node_stack_below() */

         params {
            @in Evas_Object *below @nonull; /*@ the object below which to stack */
         }
      }
      lower {
         /*@
         Lower @p obj to the bottom of its layer.

         @p obj will, then, be the lowest one in the layer it belongs
         to. Objects on other layers won't get touched.

         @see evas_vg_node_stack_above()
         @see evas_vg_node_stack_below()
         @see evas_vg_node_raise() */
      }
   }
   implements {
      Eo.Base.parent.set;
      Eo.Base.constructor;
      @virtual .bound_get;
   }
}