summaryrefslogtreecommitdiff
path: root/src/lib/elementary/elm_mapbuf.eo
blob: b116ed7ce678171a3d63320c48f25a0763f3c172 (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
class Elm.Mapbuf (Efl.Ui.Widget, Efl.Content, Efl.Part, Efl.Ui.Legacy)
{
   [[Elementary mapbuf class]]
   legacy_prefix: elm_mapbuf;
   eo_prefix: elm_private_mapbuf;
   methods {
      @property auto {
         set {
            [[Set or unset auto flag for map rendering.

              When a ampbuf object has "auto mode" enabled, then it will
              enable and disable map mode based on current visibility.
              Mapbuf will track if you show or hide it AND if the object
              is inside the canvas viewport or not when it is moved or
              resized. Note that if you turn automode off, then map mode
              will be in a disabled state at this point. When you turn it
              on for the first time, the current state will be evaluated
              base on current properties of the mapbuf object.

              Auto mode is disabled by default.
            ]]
         }
         get {
            [[Get a value whether auto mode is enabled or not.]]
         }
         values {
            on: bool; [[The auto mode state.]]
         }
      }
      @property smooth {
         set {
            [[Enable or disable smooth map rendering.

              This sets smoothing for map rendering. If the object is a
              type that has its own smoothing settings, then both the
              smooth settings for this object and the map must be turned off.

              By default smooth maps are enabled.
            ]]
         }
         get {
            [[Get a value whether smooth map rendering is enabled or not.]]
         }
         values {
            smooth: bool; [[The smooth mode state.]]
         }
      }
      @property alpha {
         set {
            [[Set or unset alpha flag for map rendering.

              This sets alpha flag for map rendering. If the object is a
              type that has its own alpha settings, then this will take
              precedence. Only image objects have this currently. It stops
              alpha blending of the map area, and is useful if you know the
              object and/or all sub-objects is 100% solid.

              Alpha is enabled by default.
            ]]
         }
         get {
            [[Get a value whether alpha blending is enabled or not.]]
         }
         values {
            alpha: bool; [[The alpha state.]]
         }
      }
      @property enabled {
         set {
            [[Enable or disable the map.

              This enables the map that is set or disables it. On enable,
              the object geometry will be saved, and the new geometry will
              change (position and size) to reflect the map geometry set.

              Also, when enabled, alpha and smooth states will be used, so
              if the content isn't solid, alpha should be enabled, for
              example, otherwise a black rectangle will fill the content.

              When disabled, the stored map will be freed and geometry prior
              to enabling the map will be restored.

              It's disabled by default.
            ]]
         }
         get {
            [[Get a value whether map is enabled or not.]]
         }
         values {
            enabled: bool; [[The enabled state.]]
         }
      }
      @property point_color {
         [[The color of a point (vertex) in the mapbuf.

           This represents the color of the vertex in the mapbuf. Colors will
           be linearly interpolated between vertex points through the mapbuf.
           Color will multiply the "texture" pixels (like GL_MODULATE in
           OpenGL). The default color of a vertex in a mapbuf is white
           solid (255, 255, 255, 255) which means it will have no effect on
           modifying the texture pixels.

           @since 1.9
         ]]
         keys {
            idx: int; [[Index of point to change, from 0 to 3.]]
         }
         values {
            r: int; [[Red (0 - 255)]]
            g: int; [[Green (0 - 255)]]
            b: int; [[Blue (0 - 255)]]
            a: int; [[Alpha (0 - 255)]]
         }
      }
   }
   implements {
      class.constructor;
      Efl.Object.constructor;
      Efl.Gfx.visible { set; }
      Efl.Gfx.position { set; }
      Efl.Gfx.size { set; }
      Efl.Ui.Widget.theme_apply;
      Efl.Ui.Widget.widget_sub_object_del;
      Efl.Content.content { get; set; }
      Efl.Content.content_unset;
      Efl.Part.part;
   }
}