summaryrefslogtreecommitdiff
path: root/src/lib/elm_image.eo
blob: b0e89ffb213671fdf53e81642305fc80aa46d746 (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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
class Elm_Image (Elm_Widget, Evas.Clickable_Interface,
                 Elm_Interface_Atspi_Image, Elm_Interface_Atspi_Widget_Action)
{
   eo_prefix: elm_obj_image;
   properties {
      editable {
         set {
            /*@
            Make the image 'editable'.

            This means the image is a valid drag target for drag and drop, and can be
            cut or pasted too.

            @ingroup Image */
         }
         get {
            /*@
            Check if the image is 'editable'.

            @return Editability.

            A return value of EINA_TRUE means the image is a valid drag target
            for drag and drop, and can be cut or pasted too.

            @ingroup Image */
         }
         values {
            bool set; /*@ Turn on or off editability. Default is @c EINA_FALSE. */
         }
      }
      smooth_scale {
         set {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         get {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         values {
            bool smooth;
         }
      }
      resize_down {
         set {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         get {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         values {
            bool resize_down;
         }
      }
      load_size {
         set {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         get {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         values {
            int size;
         }
      }
      animated_play {
         set {
            /*@
            Start or stop an image object's animation.

            To actually start playing any image object's animation, if it
            supports it, one must do something like:

            @code
            if (elm_image_animated_available_get(img))
            {
            elm_image_animated_set(img, EINA_TRUE);
            elm_image_animated_play_set(img, EINA_TRUE);
            }
            @endcode

            elm_image_animated_set() will enable animation on the image, <b>but
            not start it yet</b>. This is the function one uses to start and
            stop animations on image objects.

            @see elm_image_animated_available_get()
            @see elm_image_animated_set()
            @see elm_image_animated_play_get()

            @ingroup Image
            @since 1.7 */
         }
         get {
            /*@
            Get whether an image object is under animation or not.

            @return @c EINA_TRUE, if the image is being animated, @c EINA_FALSE
            otherwise.

            @see elm_image_animated_play_get()

            @ingroup Image
            @since 1.7 */
         }
         values {
            bool play; /*@ @c EINA_TRUE to start the animation, @c EINA_FALSE
            otherwise. Default is @c EINA_FALSE. */
         }
      }
      resize_up {
         set {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         get {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         values {
            bool resize_up;
         }
      }
      smooth {
         set {
            /*@
            Set the smooth effect for an image.

            Set the scaling algorithm to be used when scaling the image. Smooth
            scaling provides a better resulting image, but is slower.

            The smooth scaling should be disabled when making animations that change
            the image size, since it will be faster. Animations that don't require
            resizing of the image can keep the smooth scaling enabled (even if the
            image is already scaled, since the scaled image will be cached).

            @see elm_image_smooth_get()

            @ingroup Image */
         }
         get {
            /*@
            Get the smooth effect for an image.

            @return @c EINA_TRUE if smooth scaling is enabled, @c EINA_FALSE otherwise.

            @see elm_image_smooth_set()

            @ingroup Image */
         }
         values {
            bool smooth; /*@ @c EINA_TRUE if smooth scaling should be used, @c EINA_FALSE
            otherwise. Default is @c EINA_TRUE. */
         }
      }
      no_scale {
         set {
            /*@
            Disable scaling of this object.

            This function disables scaling of the elm_image widget through the
            function elm_object_scale_set(). However, this does not affect the widget
            size/resize in any way. For that effect, take a look at
            elm_image_resizable_set().

            @see elm_image_no_scale_get()
            @see elm_image_resizable_set()
            @see elm_object_scale_set()

            @ingroup Image */
         }
         get {
            /*@
            Get whether scaling is disabled on the object.

            @return @c EINA_TRUE if scaling is disabled, @c EINA_FALSE otherwise

            @see elm_image_no_scale_set()

            @ingroup Image */
         }
         values {
            bool no_scale; /*@ @c EINA_TRUE if the object is not scalable, @c EINA_FALSE
            otherwise. Default is @c EINA_FALSE. */
         }
      }
      animated {
         set {
            /*@
            Set whether an image object (which supports animation) is to
            animate itself or not.

            An image object, even if it supports animation, will be displayed
            by default without animation. Call this function with @a animated
            set to @c EINA_TRUE to enable its animation. To start or stop the
            animation, actually, use elm_image_animated_play_set().

            @see elm_image_animated_get()
            @see elm_image_animated_available_get()
            @see elm_image_animated_play_set()

            @ingroup Image
            @since 1.7 */
         }
         get {
            /*@
            Get whether an image object has animation enabled or not.

            @return @c EINA_TRUE if the image has animation enabled,
            @c EINA_FALSE otherwise.

            @see elm_image_animated_set()

            @ingroup Image
            @since 1.7 */
         }
         values {
            bool anim; /*@ @c EINA_TRUE if the object is to animate itself,
            @c EINA_FALSE otherwise. Default is @c EINA_FALSE. */
         }
      }
      scale {
         set {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         get {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         values {
            double scale;
         }
      }
      file {
         set {
            /*@
            Set the file that will be used as the image's source.

            @return (@c EINA_TRUE = success, @c EINA_FALSE = error)

            @see elm_image_file_get()

            @note This function will trigger the Edje file case based on the
            extension of the @a file string (expects @c ".edj", for this
            case).

            @note If you use animated gif image and create multiple image objects with
            one gif image file, you should set the @p group differently for each object.
            Or image objects will share one evas image cache entry and you will get
            unwanted frames.

            @ingroup Image */
            return bool;
            legacy null;
         }
         get {
            /*@
            Get the file that will be used as image.

            @see elm_image_file_set()

            @ingroup Image */
         }
         values {
            const(char)* file; /*@ The path to file that will be used as image source */
            const(char)* group; /*@ The group that the image belongs to, in case it's an
            EET (including Edje case) file. This can be used as a key inside
            evas image cache if this is a normal image file not eet file. */
         }
      }
      fill_inside {
         set {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         get {
            /*@ No description supplied by the EAPI. */
            legacy null;
         }
         values {
            bool fill_inside;
         }
      }
      aspect_fixed {
         set {
            /*@
            Set whether the original aspect ratio of the image should be kept on resize.

            The original aspect ratio (width / height) of the image is usually
            distorted to match the object's size. Enabling this option will retain
            this original aspect, and the way that the image is fit into the object's
            area depends on the option set by elm_image_fill_outside_set().

            @see elm_image_aspect_fixed_get()
            @see elm_image_fill_outside_set()

            @ingroup Image */
         }
         get {
            /*@
            Get if the object retains the original aspect ratio.

            @return @c EINA_TRUE if the object keeps the original aspect, @c EINA_FALSE
            otherwise.

            @ingroup Image */
         }
         values {
            bool fixed; /*@ @c EINA_TRUE if the image should retain the aspect,
            @c EINA_FALSE otherwise. */
         }
      }
      orient {
         set {
            /*@
            Set the image orientation.

            This function allows to rotate or flip the given image.

            @see elm_image_orient_get()
            @see @ref Elm_Image_Orient

            @ingroup Image */
         }
         get {
            /*@
            Get the image orientation.

            @return The image orientation @ref Elm_Image_Orient

            @see elm_image_orient_set()
            @see @ref Elm_Image_Orient

            @ingroup Image */
         }
         values {
            Elm_Image_Orient orient; /*@ The image orientation @ref Elm_Image_Orient
            Default is #ELM_IMAGE_ORIENT_NONE. */
         }
      }
      fill_outside {
         set {
            /*@
            Set if the image fills the entire object area, when keeping the aspect ratio.

            When the image should keep its aspect ratio even if resized to another
            aspect ratio, there are two possibilities to resize it: keep the entire
            image inside the limits of height and width of the object (@p fill_outside
            is @c EINA_FALSE) or let the extra width or height go outside of the object,
            and the image will fill the entire object (@p fill_outside is @c EINA_TRUE).

            @note This option will have no effect if
            elm_image_aspect_fixed_set() is set to @c EINA_FALSE.

            @see elm_image_fill_outside_get()
            @see elm_image_aspect_fixed_set()

            @ingroup Image */
         }
         get {
            /*@
            Get if the object is filled outside

            @return @c EINA_TRUE if the object is filled outside, @c EINA_FALSE otherwise.

            @see elm_image_fill_outside_set()

            @ingroup Image */
         }
         values {
            bool fill_outside; /*@ @c EINA_TRUE if the object is filled outside,
            @c EINA_FALSE otherwise. Default is @c EINA_FALSE. */
         }
      }
      resizable {
         set {
            /*@
            Set if the object is (up/down) resizable.

            This function limits the image resize ability. If @p size_up is set to
            @c EINA_FALSE, the object can't have its height or width resized to a value
            higher than the original image size. Same is valid for @p size_down.

            @see elm_image_resizable_get()

            @ingroup Image */
         }
         get {
            /*@
            Get if the object is (up/down) resizable.

            @see elm_image_resizable_set()

            @ingroup Image */
         }
         values {
            bool up; /*@ A bool to set if the object is resizable up. Default is
            @c EINA_TRUE. */
            bool down; /*@ A bool to set if the object is resizable down. Default
            is @c EINA_TRUE. */
         }
      }
      preload_disabled {
         set {
            /*@
            Enable or disable preloading of the image

            @ingroup Image */
         }
         values {
            bool disabled; /*@ If EINA_TRUE, preloading will be disabled */
         }
      }
      mmap {
         set {
            /*@
            Set the file that will be used as the image's source.

            @return (@c EINA_TRUE = success, @c EINA_FALSE = error)

            @see elm_image_file_set()

            @note This function will trigger the Edje file case based on the
            extension of the @a file string use to create the Eina_File (expects
            @c ".edj", for this case).

            @note If you use animated gif image and create multiple image objects with
            one gif image file, you should set the @p group differently for each object.
            Or image objects will share one evas image cache entry and you will get
            unwanted frames.

            @ingroup Image */
            return bool;
            legacy null;
         }
         values {
            const(Eina_File)* file; /*@ The handler to an Eina_File that will be used as image source */
            const(char)* group; /*@ The group that the image belongs to, in case it's an
            EET (including Edje case) file. This can be used as a key inside
            evas image cache if this is a normal image file not eet file. */
         }
      }
      memfile {
         set {
            /*@
            Set a location in memory to be used as an image object's source
            bitmap.

            This function is handy when the contents of an image file are
            mapped in memory, for example.

            The @p format string should be something like @c "png", @c "jpg",
            @c "tga", @c "tiff", @c "bmp" etc, when provided (@c NULL, on the
            contrary). This improves the loader performance as it tries the
            "correct" loader first, before trying a range of other possible
            loaders until one succeeds.

            @return (@c EINA_TRUE = success, @c EINA_FALSE = error)

            @since 1.7

            @ingroup Image */
            return bool;
         }
         values {
            const(void)* img; /*@ The binary data that will be used as image source */
            size size; /*@ The size of binary data blob @p img */
            const(char)* format; /*@ (Optional) expected format of @p img bytes */
            const(char)* key; /*@ Optional indexing key of @p img to be passed to the
            image loader (eg. if @p img is a memory-mapped EET file) */
         }
      }
      animated_available {
         get {
            /*@
            Get whether an image object supports animation or not.

            @return @c EINA_TRUE if the image supports animation,
            @c EINA_FALSE otherwise.

            This function returns if this Elementary image object's internal
            image can be animated. Currently Evas only supports GIF
            animation. If the return value is @b EINA_FALSE, other
            @c elm_image_animated_xxx API calls won't work.

            @see elm_image_animated_set()

            @ingroup Image
            @since 1.7 */
            return bool;
         }
      }
      object {
         get {
            /*@
            Get the inlined image object of the image widget.

            @return The inlined image object, or NULL if none exists

            This function allows one to get the underlying @c Evas_Object of type
            Image from this elementary widget. It can be useful to do things like get
            the pixel data, save the image to a file, etc.

            @note Be careful to not manipulate it, as it is under control of
            elementary.

            @ingroup Image */
            return Evas_Object *;
         }
      }
      object_size {
         get {
            /*@
            Get the current size of the image.

            This is the real size of the image, not the size of the object.

            @ingroup Image */
         }
         values {
            int w; /*@ Pointer to store width, or NULL. */
            int h; /*@ Pointer to store height, or NULL. */
         }
      }
   }
   methods {
      sizing_eval {
         /*@ No description supplied by the EAPI. */
         legacy null;
      }
   }
   implements {
      class.constructor;
      Eo.Base.constructor;
      Evas.Object_Smart.hide;
      Evas.Object_Smart.clip.set;
      Evas.Object_Smart.clip_unset;
      Evas.Object_Smart.show;
      Evas.Object_Smart.color.set;
      Evas.Object_Smart.move;
      Evas.Object_Smart.add;
      Evas.Object_Smart.del;
      Evas.Object_Smart.member_add;
      Evas.Object_Smart.resize;
      Elm_Widget.theme_apply;
      Elm_Widget.event;
      Elm_Interface_Atspi_Image.extents.get;
      Elm_Interface_Atspi_Widget_Action.elm_actions.get;
   }
   events {
      drop;
      clicked;
      download,start;
      download,progress;
      download,done;
      download,error;
   }

}