aboutsummaryrefslogtreecommitdiffstats
path: root/src/lib/evas/canvas/evas_image.eo
blob: cb5da1a12be2d0af88de1131ba03dfab966c1317 (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
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Gfx.Fill, Efl.Gfx.View, Evas.Filter)
{
   legacy_prefix: evas_object_image;
   eo_prefix: evas_obj_image;
   methods {
      @property load_dpi {
         set {
            [[Set the DPI resolution of an image object's source image.

              This function sets the DPI resolution of a given loaded canvas
              image. Most useful for the SVG image loader.
            ]]
         }
         get {
            [[Get the DPI resolution of a loaded image object in the canvas.

              This function returns the DPI resolution of the given canvas
              image.
            ]]
         }
         values {
            dpi: double; [[The DPI resolution.]]
         }
      }

      @property source_clip {
         set {
            [[Clip the proxy object with the source object's clipper.

              @since 1.8
            ]]
         }
         get {
            [[Determine whether an object is clipped by source object's
              clipper.

              @since 1.8
            ]]
         }
         values {
            source_clip: bool; [[Whether $obj is clipped by the source
                                clipper ($true) or not ($false).]]
         }
      }
      @property source {
         set {
            [[Set the source object on an image object to used as a proxy.

              If an image object is set to behave as a proxy, it will mirror
              the rendering contents of a given source object in its drawing
              region, without affecting that source in any way. The source
              must be another valid Evas object. Other effects may be
              applied to the proxy, such as a map (see
              \@ref evas_object_map_set) to create a reflection of the
              original object (for example).

              Any existing source object on $obj will be removed after this
              call. Setting $src to $null clears the proxy object (not in
              "proxy state" anymore).

              Warning: You cannot set a proxy as another proxy's source.
            ]]
            return: bool;
         }
         get {
            [[Get the current source object of an image object.]]
         }
         values {
            src: Evas.Object *; [[Source object to use for the proxy.]]
         }
      }
      @property filled {
         set {
            [[Set whether the image object's fill property should track the
              object's size.

              If $setting is $true, then every \@ref evas_object_resize will
              automatically trigger a call to \@ref evas_object_image_fill_set
              with the that new size (and 0, 0 as source image's origin),
              so the bound image will fill the whole object's area.
            ]]
         }
         get {
            [[Retrieve whether the image object's fill property should track
              the object's size.

              Returns $true if it is tracking, $false if not (and
              \@ref evas_object_fill_set must be called manually).
            ]]
         }
         values {
            filled: bool; [[$true to make the fill property follow
                            object size or $false otherwise.]]
         }
      }
      @property content_hint {
         set {
            [[Set the content hint setting of a given image object of the
              canvas.

              This function sets the content hint value of the given image
              of the canvas. For example, if you're on the GL engine and
              your driver implementation supports it, setting this hint to
              #EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies
              at texture upload time, which is an "expensive" operation.
            ]]
         }
         get {
            [[Get the content hint setting of a given image object of the
              canvas.

              This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.
            ]]
         }
         values {
            hint: Evas_Image_Content_Hint; [[The content hint value, one of
                                             the #Evas_Image_Content_Hint ones.]]
         }
      }
      @property load_region {
         set {
            [[Inform a given image object to load a selective region of its
              source image.

              This function is useful when one is not showing all of an
              image's area on its image object.

              Note: The image loader for the image format in question has
              to support selective region loading in order to this function
              to take effect.
            ]]
         }
         get {
            [[Retrieve the coordinates of a given image object's selective
              (source image) load region.

              Note: Use $null pointers on the coordinates you're not
              interested in: they'll be ignored by the function.
            ]]
         }
         values {
            x: int; [[X-offset of the region to be loaded.]]
            y: int; [[Y-offset of the region to be loaded.]]
            w: int; [[Width of the region to be loaded.]]
            h: int; [[Height of the region to be loaded.]]
         }
      }
      @property alpha {
         set {
            [[Enable or disable alpha channel usage on the given image
              object.

              This function sets a flag on an image object indicating
              whether or not to use alpha channel data. A value of $true
              makes it use alpha channel data, and $false makes it ignore
              that data. Note that this has nothing to do with an object's
              color as  manipulated by \@ref evas_object_color_set.
            ]]
         }
         get {
            [[Retrieve whether alpha channel data is being used on the
              given image object.

              This function returns $true if the image object's alpha
              channel is being used, or $false otherwise.
            ]]
         }
         values {
            alpha: bool; [[Whether to use alpha channel ($true) data
                           or not ($false).]]
         }
      }
      @property border {
         set {
            [[Set the dimensions for an image object's border, a region
              which won't ever be scaled together with its center.

              When Evas is rendering, an image source may be scaled to fit
              the size of its image object. This function sets an area from
              the borders of the image inwards which is not to be scaled.
              This function is useful for making frames and for widget
              theming, where, for example, buttons may be of varying
              sizes, but their border size must remain constant.

              The units used for $l, $r, $t and $b are canvas units.

              Note: The border region itself may be scaled by the
              @.border_scale.set function.

              Note: By default, image objects have no borders set, i. e.
              $l, $r, $t and $b start as 0.
            ]]
            /* FIXME-doc
            See the following figures for visual explanation:\n
            @htmlonly
            <img src="image-borders.png" style="max-width: 100%;" />
            <a href="image-borders.png">Full-size</a>
            @endhtmlonly
            @image rtf image-borders.png
            @image latex image-borders.eps width=\textwidth
            @htmlonly
            <img src="border-effect.png" style="max-width: 100%;" />
            <a href="border-effect.png">Full-size</a>
            @endhtmlonly
            @image rtf border-effect.png
            @image latex border-effect.eps width=\textwidth
            */
         }
         get {
            [[Retrieve the dimensions for an image object's border, a
              region which won't ever be scaled together with its center.

              Note: Use $null pointers on the border components you're not
              interested in: they'll be ignored by the function.
            ]]
         }
         values {
            l: int; [[The border's left width.]]
            r: int; [[The border's right width.]]
            t: int; [[The border's top width.]]
            b: int; [[The border's bottom width.]]
         }
      }
      @property border_scale {
         set {
            [[Sets the scaling factor (multiplier) for the borders of an
              image object.
            ]]
         }
         get {
            [[Retrieves the scaling factor (multiplier) for the borders
              of an image object.
            ]]
         }
         values {
            scale: double; [[The scale factor (default is 1.0 - i.e. no scaling).]]
         }
      }
      @property pixels_dirty {
         set {
            [[Mark whether the given image object is dirty and needs to
              request its pixels.

              This function will only properly work if a pixels get
              callback has been set.

              Warning: Use this function if you really know what you are
              doing.
            ]]
         }
         get {
            [[Retrieves whether the given image object is dirty (needs to
              be redrawn).
            ]]
         }
         values {
            dirty: bool; [[Whether the image is dirty.]]
         }
      }
      @property video_surface {
         set {
            [[Set the video surface linked to a given image of the canvas.

              @since 1.1
            ]]
            values {
               surf: Evas_Video_Surface*; [[The new video surface.]]
            }
         }
         get {
            [[Get the video surface linekd to a given image of the canvas.

              @since 1.1
            ]]
            values {
               surf: const(Evas_Video_Surface)*; [[The new video surface.]]
            }
         }
      }
      @property video_surface_caps {
         set {
            [[Set the video surface capabilities to a given image of the canvas.]]
         }
         get {
            [[Get the video surface capabilities to a given image of the canvas.]]
         }
         values {
            caps: uint;
         }
      }
      @property load_orientation {
         set {
            [[Define if the orientation information in the image file
              should be honored.

              @since 1.1
            ]]
         }
         get {
            [[Get if the orientation information in the image file should
              be honored.

              @since 1.1
            ]]
         }
         values {
            enable: bool; [[$true means that it should honor the orientation
                            information.]]
         }
      }
      @property border_center_fill {
         set {
            [[Sets how the center part of the given image object (not the
              borders) should be drawn when Evas is rendering it.

              This function sets how the center part of the image object's
              source image is to be drawn, which must be one of the values
              in #Evas_Border_Fill_Mode. By center we mean the complementary
              part of that defined by @.border.set. This one is very useful
              for making frames and decorations. You would most probably
              also be using a filled image (as in @.filled.set) to use as
              a frame.
            ]]
         }
         get {
            [[Retrieves how the center part of the given image object (not
              the borders) is to be drawn when Evas is rendering it.
            ]]
         }
         values {
            fill: Evas_Border_Fill_Mode; [[Fill mode of the center region
                                           of $obj (a value in  #Evas_Border_Fill_Mode).]]
         }
      }
      @property source_visible {
         set {
            [[Set the source object to be visible or not.

              If $visible is set to $false, the source object of the
              proxy ($obj) will be invisible.

              This API works differently to \@ref evas_object_show and
              \@ref evas_object_hide. Once source object is hidden, the
              proxy object will be hidden as well. Actually in this case
              both objects are excluded from the Evas internal update circle.

              By this API, instead, one can toggle the visibility of a
              proxy's source  object remaining the proxy visibility untouched.

              Warning: If the all of proxies are deleted, then the source
              visibility of the source object will be cancelled.

              @since 1.8
            ]]
         }
         get {
            [[Get the state of the source object visibility.

              @since 1.8
            ]]
         }
         values {
            visible: bool; [[$true is source object to be shown, $false
                             otherwise.]]
         }
      }
      @property native_surface {
         set {
            [[Set the native surface of a given image of the canvas

              This function sets a native surface of a given canvas image.
            ]]
            legacy: null;
         }
         get {
            [[Get the native surface of a given image of the canvas

              This function returns the native surface of a given canvas
              image.
            ]]
         }
         values {
            surf: Evas_Native_Surface* @nonull; [[The native surface.]]
         }
      }
      @property load_scale_down {
         set {
            [[Set the scale down factor of a given image object's source
              image, when loading it.

              This function sets the scale down factor of a given canvas
              image. Most useful for the SVG image loader.
            ]]
         }
         get {
            [[Get the scale down factor of a given image object's source
              image, when loading it.
            ]]
         }
         values {
            scale_down: int; [[The scale down factor.]]
         }
      }
      @property scale_hint {
         set {
            [[Set the scale hint of a given image of the canvas.

              This function sets the scale hint value of the given image
              object in the canvas, which will affect how Evas is to cache
              scaled versions of its original source image.
            ]]
         }
         get {
            [[Get the scale hint of a given image of the canvas.

              This function returns the scale hint value of the given image
              object of the canvas.
            ]]
         }
         values {
            hint: Evas_Image_Scale_Hint; [[The scale hint, a value in
                                           #Evas_Image_Scale_Hint.]]
         }
      }
      @property source_events {
         set {
            [[Set whether an Evas object is to source events.

              Set whether an Evas object is to repeat events to source.

              If $source is $true, it will make events on $obj to also be
              repeated for the source object (see @.source.set). Even the
              $obj and source geometries are different, the event position
              will be transformed to the source object's space.

              If $source is $false, events occurring on $obj will be
              processed only on it.

              @since 1.8
            ]]
         }
         get {
            [[Determine whether an object is set to source events.

              @since 1.8
            ]]
         }
         values {
            source: bool; [[Whether $obj is to pass events ($true) or not
                            ($false).]]
         }
      }
      @property colorspace {
         set {
            [[Set the colorspace of a given image of the canvas.

              This function sets the colorspace of given canvas image.
            ]]
         }
         get {
            [[Get the colorspace of a given image of the canvas.

              This function returns the colorspace of given canvas image.
            ]]
         }
         values {
            cspace: Evas_Colorspace; [[The new color space.]]
         }
      }
      @property pixels_get_callback {
         set {
            [[Set the callback function to get pixels from a canvas' image.

              This functions sets a function to be the callback function
              that get pixels from a image of the canvas.
            ]]
         }
         values {
            func: Evas_Object_Image_Pixels_Get_Cb @nonull; [[The callback function.]]
            data: void *; [[The data pointer to be passed to $func.]]
         }
      }
      @property data_copy {
         set {
            [[Replaces the raw image data of the given image object.

              This function lets the application replace an image object's
              internal pixel buffer with an user-allocated one. For best
              results, you should generally first call
              \@ref evas_object_image_size_set with the width and height
              for the new buffer.

              This call is best suited for when you will be using image
              data with different dimensions than the existing image data,
              if any. If you only need to modify the existing image in some
              fashion, then using @.data_get is probably what you are after.

              Note that the caller is responsible for freeing the buffer
              when finished with it, as user-set image data will not be
              automatically freed when the image object is deleted.
            ]]
         }
         values {
            data: void *; [[The raw data to replace.]]
         }
      }
      @property animated_frame {
         set {
            [[Set the frame to current frame of an image object.

              This set image object's current frame to frame_num with 1
              being the first frame.

              See also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              @since 1.1
            ]]
         }
         values {
            frame_index: int; [[The index of current frame.]]
         }
      }
      @property region_support {
         get {
            [[Get the support state of a given image.

              @since 1.2
            ]]
            return: bool @warn_unused; [[The region support state.]]
         }
      }
      @property load_error {
         get {
            [[Retrieves a number representing any error that occurred during
              the last loading of the given image object's source image.
            ]]
            return: Evas_Load_Error @warn_unused; [[
               A value giving the last error that occurred. It should be
               one of the #Evas_Load_Error values. #EVAS_LOAD_ERROR_NONE
               is returned if there was no error.
            ]]
         }
      }
      @property animated_frame_count {
         get {
            [[Get the total number of frames of the image object.

              This returns total number of frames the image object
              supports (if animated).

              See also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              @since 1.1
            ]]
            return: int; [[The number of frames.]]
         }
      }
      @property stride {
         get {
            [[Retrieves the row stride of the given image object.

              The row stride is the number of bytes between the start of a
              row and the start of the next row for image data.
            ]]
            return: int @warn_unused; [[The stride of the image (in bytes).]]
         }
      }
      @property animated_loop_type {
         get {
            [[Get the kind of looping the image object does.

              This returns the kind of looping the image object wants to do.

              If it returns EVAS_IMAGE_ANIMATED_HINT_LOOP, you should display
              frames in a sequence like: 1->2->3->1->2->3->1...

              If it returns EVAS_IMAGE_ANIMATED_HINT_PINGPONG, it is better
              to display frames in a sequence like: 1->2->3->2->1->2->3->1...

              The default type is EVAS_IMAGE_ANIMATED_HINT_LOOP.

              See also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              @since 1.1
            ]]
            return: Evas_Image_Animated_Loop_Hint; [[Loop type of the image object.]]
         }
      }
      @property animated_loop_count {
         get {
            [[Get the number times the animation of the object loops.

              This returns loop count of image. The loop count is the number
              of times the animation will play fully from first to last frame
              until the animation should stop (at the final frame).

              If 0 is returned, then looping should happen indefinitely
              (no limit to the number of times it loops).

              See also \@ref evas_object_image_animated_get,
              @.animated_frame_count.get, @.animated_loop_type.get,
              @.animated_loop_count.get, @.animated_frame_duration_get.

              @since 1.1
            ]]
            return: int; [[The number of loop of an animated image object.]]
         }
      }

      @property scene {
         set {
            [[Set the 3D scene of a given image of the canvas.

              This function sets a 3d scene of a given canvas image.

              @since 1.10
            ]]
	    legacy: null;
         }
         get {
            [[Get the 3D scene of a given image of the canvas.

              This function returns the 3d scene of a given canvas image.

              @since 1.10
            ]]
            legacy: null;
         }
         values {
            scene: Evas.Canvas3D.Scene *; [[3D scene on an image object.]]
         }
      }
      @property orient {
         set {
            [[Set the image orientation.

              This function allows to rotate or flip the image.

              @since 1.14
            ]]
         }
         get {
            [[Get the image orientation.

              @since 1.14
            ]]
         }
         values {
            orient: Evas_Image_Orient; [[The image orientation \@ref Evas_Image_Orient.
                                         Default is #EVAS_IMAGE_ORIENT_NONE.]]
         }
      }
      @property snapshot {
         set {
            [[The content below the Evas_Object_Image will be rendered
              inside it and you can reuse it as a source for any kind
              of effect.

              @since 1.15
            ]]
         }
         get {
            [[Determine wether the Evas_Object_Image replicate the content
              of the canvas below.

              @since 1.15
            ]]
         }
         values {
            s: bool; [[Wether to put the content of the canvas below inside
                       the Evas_Object_Image.]]
         }
      }
      preload_begin {
         [[Begin preloading an image object's image data in the background.]]
         legacy: null;
      }
      data_update_add {
         [[Mark a sub-region of the given image object to be redrawn.

           This function schedules a particular rectangular region of an
           image object to be updated (redrawn) at the next rendering cycle.
         ]]
         params {
            @in x: int; [[X-offset of the region to be updated.]]
            @in y: int; [[Y-offset of the region to be updated.]]
            @in w: int; [[Width of the region to be updated.]]
            @in h: int; [[Height of the region to be updated.]]
         }
      }
      animated_frame_duration_get @const {
         [[Get the duration of a sequence of frames.

           This returns total duration that the specified sequence of
           frames should take in seconds.

           If you set start_frame to 1 and frame_num 0, you get frame 1's
           duration. If you set start_frame to 1 and frame_num 1, you get
           frame 1's duration + frame2's duration.

           See also \@ref evas_object_image_animated_get,
           @.animated_frame_count.get, @.animated_loop_type.get,
           @.animated_loop_count.get, @.animated_frame_duration_get.

           @since 1.1
         ]]
         return: double;
         params {
            @in start_frame: int; [[The first frame.]]
            @in frame_num: int; [[Number of frames in the sequence.]]
         }
      }
      data_set {
         [[Sets the raw image data of the given image object.

           Note that the raw data must be of the same size (see
           \@ref evas_object_image_size_set, which has to be called before
           this one) and colorspace (see @.colorspace.set) of the image.
           If data is $null, the current image data will be freed.
           Naturally, if one does not set an image object's data
           manually, it will still have one, allocated by Evas.
         ]]
         params {
            @in data: void *; [[The raw data, or $null.]]
         }
      }
      data_get @const {
         [[Get a pointer to the raw image data of the given image object.

           This function returns a pointer to an image object's internal
           pixel buffer, for reading only or read/write. If you request
           it for writing, the image will be marked dirty so that it gets
           redrawn at the next update.

           Each time you call this function on an image object, its data
           buffer will have an internal reference counter incremented.
           Decrement it back by using @.data_set.

           This is best suited for when you want to modify an existing
           image, without changing its dimensions.

           Note: The contents' format returned by it depend on the color
           space of the given image object.

           Note: You may want to use @.data_update_add to inform data
           changes, if you did any.
         ]]
         return: void * @warn_unused; [[ The raw image data.]]
         params {
            @in for_writing: bool; [[Whether the data being retrieved will
                                     be modified ($true) or not ($false).]]
         }
      }
      preload_cancel {
         [[Cancel preloading an image object's image data in the background.]]
         legacy: null;
      }
   }
   implements {
      Eo.Base.constructor;
      Eo.Base.destructor;
      Eo.Base.dbg_info_get;
      Efl.File.file.set;
      Efl.File.file.get;
      Efl.File.mmap.set;
      Efl.File.mmap.get;
      Efl.File.save;
      Efl.Image.animated.get;
      Efl.Image.load_size.set;
      Efl.Image.load_size.get;
      Efl.Image.smooth_scale.set;
      Efl.Image.smooth_scale.get;
      Efl.Gfx.Fill.fill_spread.set;
      Efl.Gfx.Fill.fill_spread.get;
      Efl.Gfx.Fill.fill.set;
      Efl.Gfx.Fill.fill.get;
      Efl.Gfx.View.size.set;
      Efl.Gfx.View.size.get;
      Efl.Gfx.Filter.program.set;
      Evas.Filter.input_alpha;
      Evas.Filter.input_render;
      Evas.Filter.dirty;
   }
}