summaryrefslogtreecommitdiff
path: root/src/lib/efl/interfaces/efl_image_load.eo
blob: b373551a395c5bf1fe64ebd9e5dc04e38faa072c (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
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
import efl_gfx_types;

/*
enum Efl.Image.Load.State
{
   none = 0,      [[Not loading any image.]]
   loaded = 1,    [[Image data is loaded, nothing is pending.]]
   pending = 2,   [[The image has been queued for load, but actual loading may not have started yet.]]
   loading = 3,   [[The image is currently loading.]]
   error = 4,     [[Image load has failed. Call @Efl.Image.Load.load_error.get to know why.]]
   cancelled = 5  [[Image load has been cancelled.]]
}
*/

interface Efl.Image.Load ()
{
   [[Common APIs for all loadable 2D images.]]

   methods {
      load_async_start {
         [[Begin preloading an image object's image data in the background.

           Once the background task is done, the event $load,done will be
           emitted.
         ]]
      }
      load_async_cancel {
         [[Cancel preloading an image object's image data in the background.

           The event $load,cancelled should be triggered soon after
           cancellation happened, and the object should be left in a state
           where it has no image data. If cancel is called too late, the image
           will be kept in memory.
         ]]
      }
      /*
      @property load_state {
         get {
            [[Queries information on the current state of load of the image.

              While more relevant to asynchronous load, this will also return
              meaningful information about the last synchronous load.
            ]]
         }
         values {
            state: Efl.Image.Load.State;
         }
      }
      */
      @property load_size {
         [[The load size of an image.

           The image will be loaded into memory as if it was the specified
           size instead of its original size. This can save a lot of memory,
           and is important for scalable types like svg.

           By default, the load size is not specified, so it is 0x0.
         ]]
         set {
            [[Requests the canvas to load the image at the given size.

              EFL will try to load the image at the requested size, but does
              not garantee an exact match between the request and the loaded
              image dimensions.
            ]]
         }
         get {
            [[Returns the requested load size.]]
         }
         values {
            w: int; [[Width of the image's load size.]]
            h: int; [[Height of the image's load size.]]
         }
      }
      @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 load_region_support {
         [[Indicates whether the @.load_region property is supported for the
           current file.

           @since 1.2
         ]]
         get {}
         values {
            support: bool;
         }
      }
      @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 load_orientation {
         [[Defines whether the orientation information in the image file
           should be honored.

           The orientation can for instance be set in the EXIF tags of a
           JPEG image. If this flag is $false, then the orientation will be
           ignored at load time, otherwise the image will be loaded with the
           proper orientation.

           @since 1.1
         ]]
         set {}
         get {}
         values {
            enable: bool; [[$true means that it should honor the orientation
                            information.]]
         }
      }
      @property load_scale_down {
         [[The scale down factor is a divider on the original image size.

           Setting the scale down factor can reduce load time and memory usage,
           at the cost of having a scaled down image in memory.

           This function sets the scale down factor of a given canvas
           image. Most useful for the SVG image loader, but also applies
           to JPEG, PNG and BMP.

           Powers of two (2, 4, 8) are best supported (especially with JPEG)
         ]]
         set {
            [[Requests the image loader to scale down by $div times.
              Call this before starting the actual image load.
            ]]
         }
         get {}
         values {
            div: int; [[The scale down dividing factor.]]
         }
      }
      @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: Efl.Image.Load.Error @warn_unused; [[
               A value giving the last error that occurred, one of
               @Efl.Image.Load.Error values. @Efl.Image.Load.Error.none is
               returned if there was no error.
            ]]
         }
      }
   }
   events {
      load,done;
      load,error: Efl.Image.Load.Error;
      load,cancelled;
   }
}