diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/evas/src/lib/canvas/evas_object_rectangle.c | 387 |
1 files changed, 0 insertions, 387 deletions
diff --git a/libraries/evas/src/lib/canvas/evas_object_rectangle.c b/libraries/evas/src/lib/canvas/evas_object_rectangle.c deleted file mode 100644 index 36678e7..0000000 --- a/libraries/evas/src/lib/canvas/evas_object_rectangle.c +++ /dev/null | |||
@@ -1,387 +0,0 @@ | |||
1 | #include "evas_common.h" | ||
2 | #include "evas_private.h" | ||
3 | |||
4 | /* private magic number for rectangle objects */ | ||
5 | static const char o_type[] = "rectangle"; | ||
6 | |||
7 | const char *o_rect_type = o_type; | ||
8 | |||
9 | /* private struct for rectangle object internal data */ | ||
10 | typedef struct _Evas_Object_Rectangle Evas_Object_Rectangle; | ||
11 | |||
12 | struct _Evas_Object_Rectangle | ||
13 | { | ||
14 | DATA32 magic; | ||
15 | void *engine_data; | ||
16 | }; | ||
17 | |||
18 | /* private methods for rectangle objects */ | ||
19 | static void evas_object_rectangle_init(Evas_Object *obj); | ||
20 | static void *evas_object_rectangle_new(void); | ||
21 | static void evas_object_rectangle_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y); | ||
22 | static void evas_object_rectangle_free(Evas_Object *obj); | ||
23 | static void evas_object_rectangle_render_pre(Evas_Object *obj); | ||
24 | static void evas_object_rectangle_render_post(Evas_Object *obj); | ||
25 | |||
26 | static unsigned int evas_object_rectangle_id_get(Evas_Object *obj); | ||
27 | static unsigned int evas_object_rectangle_visual_id_get(Evas_Object *obj); | ||
28 | static void *evas_object_rectangle_engine_data_get(Evas_Object *obj); | ||
29 | |||
30 | static int evas_object_rectangle_is_opaque(Evas_Object *obj); | ||
31 | static int evas_object_rectangle_was_opaque(Evas_Object *obj); | ||
32 | |||
33 | #if 0 /* usless calls for a rect object. much more useful for images etc. */ | ||
34 | static void evas_object_rectangle_store(Evas_Object *obj); | ||
35 | static void evas_object_rectangle_unstore(Evas_Object *obj); | ||
36 | static int evas_object_rectangle_is_visible(Evas_Object *obj); | ||
37 | static int evas_object_rectangle_was_visible(Evas_Object *obj); | ||
38 | static int evas_object_rectangle_is_inside(Evas_Object *obj, double x, double y); | ||
39 | static int evas_object_rectangle_was_inside(Evas_Object *obj, double x, double y); | ||
40 | #endif | ||
41 | |||
42 | static const Evas_Object_Func object_func = | ||
43 | { | ||
44 | /* methods (compulsory) */ | ||
45 | evas_object_rectangle_free, | ||
46 | evas_object_rectangle_render, | ||
47 | evas_object_rectangle_render_pre, | ||
48 | evas_object_rectangle_render_post, | ||
49 | evas_object_rectangle_id_get, | ||
50 | evas_object_rectangle_visual_id_get, | ||
51 | evas_object_rectangle_engine_data_get, | ||
52 | /* these are optional. NULL = nothing */ | ||
53 | NULL, | ||
54 | NULL, | ||
55 | NULL, | ||
56 | NULL, | ||
57 | evas_object_rectangle_is_opaque, | ||
58 | evas_object_rectangle_was_opaque, | ||
59 | NULL, | ||
60 | NULL, | ||
61 | NULL, | ||
62 | NULL, | ||
63 | NULL, | ||
64 | NULL, | ||
65 | NULL | ||
66 | }; | ||
67 | |||
68 | /* the actual api call to add a rect */ | ||
69 | /* it has no other api calls as all properties are standard */ | ||
70 | |||
71 | EVAS_MEMPOOL(_mp_obj); | ||
72 | |||
73 | EAPI Evas_Object * | ||
74 | evas_object_rectangle_add(Evas *e) | ||
75 | { | ||
76 | Evas_Object *obj; | ||
77 | |||
78 | MAGIC_CHECK(e, Evas, MAGIC_EVAS); | ||
79 | return NULL; | ||
80 | MAGIC_CHECK_END(); | ||
81 | obj = evas_object_new(e); | ||
82 | evas_object_rectangle_init(obj); | ||
83 | evas_object_inject(obj, e); | ||
84 | return obj; | ||
85 | } | ||
86 | |||
87 | /* all nice and private */ | ||
88 | static void | ||
89 | evas_object_rectangle_init(Evas_Object *obj) | ||
90 | { | ||
91 | /* alloc image ob, setup methods and default values */ | ||
92 | obj->object_data = evas_object_rectangle_new(); | ||
93 | /* set up default settings for this kind of object */ | ||
94 | obj->cur.color.r = 255; | ||
95 | obj->cur.color.g = 255; | ||
96 | obj->cur.color.b = 255; | ||
97 | obj->cur.color.a = 255; | ||
98 | obj->cur.geometry.x = 0; | ||
99 | obj->cur.geometry.y = 0; | ||
100 | obj->cur.geometry.w = 0; | ||
101 | obj->cur.geometry.h = 0; | ||
102 | obj->cur.layer = 0; | ||
103 | obj->cur.render_op = EVAS_RENDER_BLEND; | ||
104 | /* set up object-specific settings */ | ||
105 | obj->prev = obj->cur; | ||
106 | /* set up methods (compulsory) */ | ||
107 | obj->func = &object_func; | ||
108 | obj->type = o_type; | ||
109 | } | ||
110 | |||
111 | static void * | ||
112 | evas_object_rectangle_new(void) | ||
113 | { | ||
114 | Evas_Object_Rectangle *o; | ||
115 | |||
116 | /* alloc obj private data */ | ||
117 | EVAS_MEMPOOL_INIT(_mp_obj, "evas_object_rectangle", Evas_Object_Rectangle, 256, NULL); | ||
118 | o = EVAS_MEMPOOL_ALLOC(_mp_obj, Evas_Object_Rectangle); | ||
119 | if (!o) return NULL; | ||
120 | EVAS_MEMPOOL_PREP(_mp_obj, o, Evas_Object_Rectangle); | ||
121 | o->magic = MAGIC_OBJ_RECTANGLE; | ||
122 | return o; | ||
123 | } | ||
124 | |||
125 | static void | ||
126 | evas_object_rectangle_free(Evas_Object *obj) | ||
127 | { | ||
128 | Evas_Object_Rectangle *o; | ||
129 | |||
130 | /* frees private object data. very simple here */ | ||
131 | o = (Evas_Object_Rectangle *)(obj->object_data); | ||
132 | MAGIC_CHECK(o, Evas_Object_Rectangle, MAGIC_OBJ_RECTANGLE); | ||
133 | return; | ||
134 | MAGIC_CHECK_END(); | ||
135 | /* free obj */ | ||
136 | o->magic = 0; | ||
137 | EVAS_MEMPOOL_FREE(_mp_obj, o); | ||
138 | } | ||
139 | |||
140 | static void | ||
141 | evas_object_rectangle_render(Evas_Object *obj, void *output, void *context, void *surface, int x, int y) | ||
142 | { | ||
143 | /* render object to surface with context, and offxet by x,y */ | ||
144 | obj->layer->evas->engine.func->context_color_set(output, | ||
145 | context, | ||
146 | obj->cur.cache.clip.r, | ||
147 | obj->cur.cache.clip.g, | ||
148 | obj->cur.cache.clip.b, | ||
149 | obj->cur.cache.clip.a); | ||
150 | obj->layer->evas->engine.func->context_multiplier_unset(output, | ||
151 | context); | ||
152 | obj->layer->evas->engine.func->context_render_op_set(output, context, | ||
153 | obj->cur.render_op); | ||
154 | obj->layer->evas->engine.func->rectangle_draw(output, | ||
155 | context, | ||
156 | surface, | ||
157 | obj->cur.geometry.x + x, | ||
158 | obj->cur.geometry.y + y, | ||
159 | obj->cur.geometry.w, | ||
160 | obj->cur.geometry.h); | ||
161 | //// obj->cur.cache.geometry.x + x, | ||
162 | //// obj->cur.cache.geometry.y + y, | ||
163 | //// obj->cur.cache.geometry.w, | ||
164 | //// obj->cur.cache.geometry.h); | ||
165 | } | ||
166 | |||
167 | static void | ||
168 | evas_object_rectangle_render_pre(Evas_Object *obj) | ||
169 | { | ||
170 | int is_v, was_v; | ||
171 | |||
172 | /* dont pre-render the obj twice! */ | ||
173 | if (obj->pre_render_done) return; | ||
174 | obj->pre_render_done = 1; | ||
175 | /* pre-render phase. this does anything an object needs to do just before */ | ||
176 | /* rendering. this could mean loading the image data, retrieving it from */ | ||
177 | /* elsewhere, decoding video etc. */ | ||
178 | /* then when this is done the object needs to figure if it changed and */ | ||
179 | /* if so what and where and add the appropriate redraw rectangles */ | ||
180 | /* if someone is clipping this obj - go calculate the clipper */ | ||
181 | if (obj->cur.clipper) | ||
182 | { | ||
183 | if (obj->cur.cache.clip.dirty) | ||
184 | evas_object_clip_recalc(obj->cur.clipper); | ||
185 | obj->cur.clipper->func->render_pre(obj->cur.clipper); | ||
186 | } | ||
187 | /* now figure what changed and add draw rects */ | ||
188 | /* if it just became visible or invisible */ | ||
189 | is_v = evas_object_is_visible(obj); | ||
190 | was_v = evas_object_was_visible(obj); | ||
191 | if (!(is_v | was_v)) goto done; | ||
192 | if (is_v != was_v) | ||
193 | { | ||
194 | evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, obj, is_v, was_v); | ||
195 | goto done; | ||
196 | } | ||
197 | if ((obj->cur.map != obj->prev.map) || | ||
198 | (obj->cur.usemap != obj->prev.usemap)) | ||
199 | { | ||
200 | evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); | ||
201 | goto done; | ||
202 | } | ||
203 | /* it's not visible - we accounted for it appearing or not so just abort */ | ||
204 | if (!is_v) goto done; | ||
205 | /* clipper changed this is in addition to anything else for obj */ | ||
206 | evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, obj); | ||
207 | /* if we restacked (layer or just within a layer) and don't clip anyone */ | ||
208 | if ((obj->restack) && (!obj->clip.clipees)) | ||
209 | { | ||
210 | evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); | ||
211 | goto done; | ||
212 | } | ||
213 | /* if it changed render op */ | ||
214 | if (obj->cur.render_op != obj->prev.render_op) | ||
215 | { | ||
216 | evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); | ||
217 | goto done; | ||
218 | } | ||
219 | /* if it changed color */ | ||
220 | if ((obj->cur.color.r != obj->prev.color.r) || | ||
221 | (obj->cur.color.g != obj->prev.color.g) || | ||
222 | (obj->cur.color.b != obj->prev.color.b) || | ||
223 | (obj->cur.color.a != obj->prev.color.a)) | ||
224 | { | ||
225 | evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, obj); | ||
226 | goto done; | ||
227 | } | ||
228 | /* if it changed geometry - and obviously not visibility or color */ | ||
229 | /* calculate differences since we have a constant color fill */ | ||
230 | /* we really only need to update the differences */ | ||
231 | if ((obj->cur.geometry.x != obj->prev.geometry.x) || | ||
232 | (obj->cur.geometry.y != obj->prev.geometry.y) || | ||
233 | (obj->cur.geometry.w != obj->prev.geometry.w) || | ||
234 | (obj->cur.geometry.h != obj->prev.geometry.h)) | ||
235 | { | ||
236 | evas_rects_return_difference_rects(&obj->layer->evas->clip_changes, | ||
237 | obj->cur.geometry.x, | ||
238 | obj->cur.geometry.y, | ||
239 | obj->cur.geometry.w, | ||
240 | obj->cur.geometry.h, | ||
241 | obj->prev.geometry.x, | ||
242 | obj->prev.geometry.y, | ||
243 | obj->prev.geometry.w, | ||
244 | obj->prev.geometry.h); | ||
245 | //// rl = evas_rects_return_difference_rects(obj->cur.cache.geometry.x, | ||
246 | //// obj->cur.cache.geometry.y, | ||
247 | //// obj->cur.cache.geometry.w, | ||
248 | //// obj->cur.cache.geometry.h, | ||
249 | //// obj->prev.cache.geometry.x, | ||
250 | //// obj->prev.cache.geometry.y, | ||
251 | //// obj->prev.cache.geometry.w, | ||
252 | //// obj->prev.cache.geometry.h); | ||
253 | goto done; | ||
254 | } | ||
255 | /* it obviously didn't change - add a NO obscure - this "unupdates" this */ | ||
256 | /* area so if there were updates for it they get wiped. don't do it if we */ | ||
257 | /* arent fully opaque and we are visible */ | ||
258 | /* | ||
259 | if (evas_object_is_visible(obj) && | ||
260 | evas_object_is_opaque(obj) && | ||
261 | (!obj->clip.clipees)) | ||
262 | obj->layer->evas->engine.func->output_redraws_rect_del(obj->layer->evas->engine.data.output, | ||
263 | obj->cur.cache.clip.x, | ||
264 | obj->cur.cache.clip.y, | ||
265 | obj->cur.cache.clip.w, | ||
266 | obj->cur.cache.clip.h); | ||
267 | */ | ||
268 | done: | ||
269 | evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, obj, is_v, was_v); | ||
270 | } | ||
271 | |||
272 | static void | ||
273 | evas_object_rectangle_render_post(Evas_Object *obj) | ||
274 | { | ||
275 | |||
276 | /* this moves the current data to the previous state parts of the object */ | ||
277 | /* in whatever way is safest for the object. also if we don't need object */ | ||
278 | /* data anymore we can free it if the object deems this is a good idea */ | ||
279 | /* remove those pesky changes */ | ||
280 | evas_object_clip_changes_clean(obj); | ||
281 | /* move cur to prev safely for object data */ | ||
282 | obj->prev = obj->cur; | ||
283 | } | ||
284 | |||
285 | static int | ||
286 | evas_object_rectangle_is_opaque(Evas_Object *obj) | ||
287 | { | ||
288 | /* this returns 1 if the internal object data implies that the object is */ | ||
289 | /* currently fully opaque over the entire rectangle it occupies */ | ||
290 | if ((obj->cur.map) && (obj->cur.usemap)) return 0; | ||
291 | if (obj->cur.render_op == EVAS_RENDER_COPY) | ||
292 | return 1; | ||
293 | if (obj->cur.render_op != EVAS_RENDER_BLEND) | ||
294 | return 0; | ||
295 | return 1; | ||
296 | } | ||
297 | |||
298 | static int | ||
299 | evas_object_rectangle_was_opaque(Evas_Object *obj) | ||
300 | { | ||
301 | /* this returns 1 if the internal object data implies that the object was */ | ||
302 | /* previously fully opaque over the entire rectangle it occupies */ | ||
303 | if (obj->prev.render_op == EVAS_RENDER_COPY) | ||
304 | return 1; | ||
305 | if (obj->prev.render_op != EVAS_RENDER_BLEND) | ||
306 | return 0; | ||
307 | return 1; | ||
308 | } | ||
309 | |||
310 | static unsigned int evas_object_rectangle_id_get(Evas_Object *obj) | ||
311 | { | ||
312 | Evas_Object_Rectangle *o; | ||
313 | |||
314 | o = (Evas_Object_Rectangle *)(obj->object_data); | ||
315 | if (!o) return 0; | ||
316 | return MAGIC_OBJ_RECTANGLE; | ||
317 | } | ||
318 | |||
319 | static unsigned int evas_object_rectangle_visual_id_get(Evas_Object *obj) | ||
320 | { | ||
321 | Evas_Object_Rectangle *o; | ||
322 | |||
323 | o = (Evas_Object_Rectangle *)(obj->object_data); | ||
324 | if (!o) return 0; | ||
325 | return MAGIC_OBJ_SHAPE; | ||
326 | } | ||
327 | |||
328 | static void *evas_object_rectangle_engine_data_get(Evas_Object *obj) | ||
329 | { | ||
330 | Evas_Object_Rectangle *o; | ||
331 | |||
332 | o = (Evas_Object_Rectangle *)(obj->object_data); | ||
333 | if (!o) return NULL; | ||
334 | return o->engine_data; | ||
335 | } | ||
336 | |||
337 | |||
338 | #if 0 /* usless calls for a rect object. much more useful for images etc. */ | ||
339 | static void | ||
340 | evas_object_rectangle_store(Evas_Object *obj) | ||
341 | { | ||
342 | /* store... nothing for rectangle objects... it's a bit silly */ | ||
343 | /* but for others that may have expensive caluclations to do to */ | ||
344 | /* generate the object data, hint that they might want to be pre-calced */ | ||
345 | /* once and stored */ | ||
346 | } | ||
347 | |||
348 | static void | ||
349 | evas_object_rectangle_unstore(Evas_Object *obj) | ||
350 | { | ||
351 | /* store... nothing for rectangle objects... it's a bit silly */ | ||
352 | } | ||
353 | |||
354 | static int | ||
355 | evas_object_rectangle_is_visible(Evas_Object *obj) | ||
356 | { | ||
357 | /* this returns 1 if the internal object data would imply that it is */ | ||
358 | /* visible (ie drawing it draws something. this is not to do with events */ | ||
359 | return 1; | ||
360 | } | ||
361 | |||
362 | static int | ||
363 | evas_object_rectangle_was_visible(Evas_Object *obj) | ||
364 | { | ||
365 | /* this returns 1 if the internal object data would imply that it was */ | ||
366 | /* visible (ie drawing it draws something. this is not to do with events */ | ||
367 | return 1; | ||
368 | } | ||
369 | |||
370 | static int | ||
371 | evas_object_rectangle_is_inside(Evas_Object *obj, double x, double y) | ||
372 | { | ||
373 | /* this returns 1 if the canvas co-ordinates are inside the object based */ | ||
374 | /* on object private data. not much use for rects, but for polys, images */ | ||
375 | /* and other complex objects it might be */ | ||
376 | return 1; | ||
377 | } | ||
378 | |||
379 | static int | ||
380 | evas_object_rectangle_was_inside(Evas_Object *obj, double x, double y) | ||
381 | { | ||
382 | /* this returns 1 if the canvas co-ordinates were inside the object based */ | ||
383 | /* on object private data. not much use for rects, but for polys, images */ | ||
384 | /* and other complex objects it might be */ | ||
385 | return 1; | ||
386 | } | ||
387 | #endif | ||