summaryrefslogtreecommitdiff
path: root/src/lib/efl/interfaces/efl_ui_scrollable_interactive.eo
blob: 3e72ba4853b945befe0389cd63743b6c6d2d8c68 (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
import eina_types;

interface Efl.Ui.Scrollable_Interactive extends Efl.Ui.Scrollable
{
   eo_prefix: efl_ui_scrollable;
   methods {
      @property content_pos {
         [[The content position]]
         set {
         }
         get {
         }
         values {
            pos: Eina.Position2D; [[The position is virtual value, (0, 0) starting at the top-left.]]
         }
      }
      @property content_size {
         [[The content size]]
         get {
         }
         values {
            size: Eina.Size2D; [[The content size in pixels.]]
         }
      }
      @property viewport_geometry {
         [[The viewport geometry]]
         get {
         }
         values {
            rect: Eina.Rect; [[It is absolute geometry.]]
         }
      }
      @property bounce_enabled {
         [[Bouncing behavior

           When scrolling, the scroller may "bounce" when reaching the edge of the
           content object. This is a visual way to indicate the end has been reached.
           This is enabled by default for both axes. This API will determine if it's enabled
           for the given axis with the boolean parameters for each one.]]
         set {
         }
         get {
         }
         values {
            horiz: bool; [[Horizontal bounce policy.]]
            vert: bool; [[Vertical bounce policy.]]
         }
      }
      @property scroll_freeze {
         [[Freeze property
           This function will freeze scrolling movement (by input of a user).
           Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally.
           If you want to freeze in only one direction,
           See @.movement_block.set.
         ]]
         get {
         }
         set {
         }
         values {
            freeze: bool; [[$true if freeze, $false otherwise]]
         }
      }
      @property scroll_hold {
         [[Hold property
           When hold turns on, it only scrolls by holding action.
         ]]
         get {
         }
         set {
         }
         values {
            hold: bool; [[$true if hold, $false otherwise]]
         }
      }
      @property looping {
         [[Controls an infinite loop for a scroller.]]
         set {
         }
         get {
         }
         values {
            loop_h: bool; [[The scrolling horizontal loop]]
            loop_v: bool; [[The Scrolling vertical loop]]
         }
      }
      @property movement_block {
         [[Blocking of scrolling (per axis)

           This function will block scrolling movement (by input of a user) in
           a given direction. You can disable movements in the X axis, the Y
           axis or both. The default value is $none, where movements are
           allowed in both directions.
         ]]
         set {
         }
         get {
         }
         values {
            block: Efl.Ui.Scroll_Block(Efl.Ui.Scroll_Block.none); [[Which axis (or axes) to block]]
         }
      }
      @property gravity {
         [[Control scrolling gravity on the scrollable

           The gravity defines how the scroller will adjust its view
           when the size of the scroller contents increases.

           The scroller will adjust the view to glue itself as follows.

            x=0.0, for staying where it is relative to the left edge of the content
            x=1.0, for staying where it is relative to the right edge of the content
            y=0.0, for staying where it is relative to the top edge of the content
            y=1.0, for staying where it is relative to the bottom edge of the content

           Default values for x and y are 0.0]]
         set {
         }
         get {
         }
         values {
            x: double; [[Horizontal scrolling gravity]]
            y: double; [[Vertical scrolling gravity]]
         }
      }
      @property match_content {
         [[Prevent the scrollable from being smaller than the minimum size of the content.

           By default the scroller will be as small as its design allows,
           irrespective of its content. This will make the scroller minimum size the
           right size horizontally and/or vertically to perfectly fit its content in
           that direction.]]
         set {
         }
         values {
            w: bool; [[Whether to limit the minimum horizontal size]]
            h: bool; [[Whether to limit the minimum vertical size]]
         }
      }
      scroll {
         [[Show a specific virtual region within the scroller content object.

           This will ensure all (or part if it does not fit) of the designated
           region in the virtual content object (0, 0 starting at the top-left of the
           virtual content object) is shown within the scroller. This allows the scroller to "smoothly slide"
           to this location (if configuration in general calls for transitions). It
           may not jump immediately to the new location and make take a while and
           show other content along the way.
           ]]
         params {
            @in rect: Eina.Rect; [[The position where to scroll. and The size user want to see]]
            @in animation: bool; [[Whether to scroll with animation or not]]
         }
      }
   }
}