summaryrefslogtreecommitdiff
path: root/src/lib/elm_progressbar.eo
blob: 827581c4c3cd814003ae33b7d1c9e2d0cbe00c0f (plain) (blame)
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
class Elm.Progressbar (Elm.Layout)
{
   eo_prefix: elm_obj_progressbar;
   methods {
      @property span_size {
         [[Control the (exact) length of the bar region of a given progress bar widget

           This sets the minimum width (when in horizontal mode) or height
           (when in vertical mode) of the actual bar area of the progress
           bar $obj. This in turn affects the object's minimum size. Use
           this when you're not setting other size hints expanding on the
           given direction (like weight and alignment hints) and you would
           like it to have a specific size.

           Note: Icon, label and unit text around $obj will require their
           own space, which will make $obj to require more the $size,
           actually.]]
         set {
         }
         get {
         }
         values {
            size: Evas.Coord; [[The length of the progress bar's bar region]]
         }
      }
      @property pulse {
         [[Control whether a given progress bar widget is at "pulsing mode" or not.

           By default, progress bars will display values from the low to
           high value boundaries. There are, though, contexts in which the
           progress of a given task is unknown. For such cases,
           one can set a progress bar widget to a "pulsing state", to give
           the user an idea that some computation is being held, but
           without exact progress values. In the default theme, it will
           animate its bar with the contents filling in constantly and back
           to non-filled, in a loop. To start and stop this pulsing
           animation, one has to explicitly call elm_progressbar_pulse().]]
         set {
         }
         get {
         }
         values {
            pulse: bool; [[$true to put $obj in pulsing mode, $false to put it back to its default one]]
         }
      }
      @property value {
         [[Control the progress value (in percentage) on a given progress bar widget

           Use this call to set progress bar levels.

           Note: If you passes a value out of the specified range for
           $val, it will be interpreted as the closest of the boundary
           values in the range.]]
         set {
         }
         get {
         }
         values {
            val: double; [[The progress value (must be between $0.0 and 1.0)]]
         }
      }
      @property inverted {
         [[Invert a given progress bar widget's displaying values order

           A progress bar may be inverted, in which state it gets its
           values inverted, with high values being on the left or top and
           low values on the right or bottom, as opposed to normally have
           the low values on the former and high values on the latter,
           respectively, for horizontal and vertical modes.]]
         set {
         }
         get {
         }
         values {
            inverted: bool; [[Use $true to make $obj inverted, $false to bring it back to default, non-inverted values.]]
         }
      }
      @property horizontal {
         [[Control the orientation of a given progress bar widget

           Use this function to change how your progress bar is to be
           disposed: vertically or horizontally.]]
         set {
         }
         get {
         }
         values {
            horizontal: bool; [[Use $true to make $obj to be horizontal, $false to make it vertical]]
         }
      }
      @property unit_format {
         [[Control the format string for a given progress bar widget's units label

           If $NULL is passed on $format, it will make $obj's units
           area to be hidden completely. If not, it'll set the <b>format
           string</b> for the units label's text. The units label is
           provided a floating point value, so the units text is up display
           at most one floating point value. Note that the units label is
           optional. Use a format string such as "%1.2f meters" for
           example.

           Note: The default format string for a progress bar is an integer
           percentage, as in $"%.0f %%".]]
         set {
         }
         get {
         }
         values {
            units: const(char)* @nullable; [[The format string for $obj's units label]]
         }
      }
      @property unit_format_function {
         set {
            [[Set the format function pointer for the units label

              Set the callback function to format the unit string.

              See: @.unit_format.set for more info on how this works.

              @since 1.7]]
         }
         values {
            func: progressbar_func_type @nullable; [[The unit format function]]
            free_func: progressbar_freefunc_type @optional; [[The freeing function for the format string.]]
         }
      }
      part_value_set {
         [[Set the progress value (in percentage) on a given progress bar widget for the given part name

           Use this call to set progress bar status for more than one progress status .

           @since 1.8]]
         params {
            @in part: const(char)*; [[The partname to which val have to set]]
            @in val: double; [[The progress value (must be between $0.0 and 1.0)]]
         }
      }
      part_value_get @const {
         [[Get the progress value (in percentage) on a given progress bar widget for a particular part

           @since 1.8]]
         return: double; [[The value of the progressbar]]
         params {
            @in part: const(char)*; [[The part name of the progress bar]]
         }
      }
      pulse {
         [[Start/stop a given progress bar "pulsing" animation, if its under that mode

           Note: This call won't do anything if $obj is not under "pulsing mode".]]
         params {
            @in state: bool; [[$true, to start the pulsing animation, $false to stop it]]
         }
      }
   }
   implements {
      class.constructor;
      Eo.Base.constructor;
      Evas.Object_Smart.add;
      Evas.Object_Smart.del;
      Elm.Widget.theme_apply;
      Elm.Widget.focus_next_manager_is;
      Elm.Widget.focus_direction_manager_is;
      Elm.Widget.sub_object_del;
      Elm.Container.content_set;
      Elm.Layout.text_aliases.get;
      Elm.Layout.content_aliases.get;
      Elm.Layout.sizing_eval;
   }
   events {
      changed;
      language,changed;
      access,changed;
   }

}