Mercurial > MadButterfly
annotate src/redraw_man.c @ 28:604bc90d509d
Refactory
| author | Thinker K.F. Li <thinker@branda.to> |
|---|---|
| date | Mon, 04 Aug 2008 20:08:37 +0800 |
| parents | 19c603dd6ff9 |
| children | f56c96b035a8 |
| rev | line source |
|---|---|
| 12 | 1 #include <stdio.h> |
| 2 #include <stdlib.h> | |
| 3 #include <string.h> | |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
4 #include <cairo.h> |
| 12 | 5 #include "mb_types.h" |
| 6 #include "shapes.h" | |
| 7 #include "tools.h" | |
| 8 #include "redraw_man.h" | |
| 9 | |
|
26
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
10 /* NOTE: bounding box should also consider width of stroke. |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
11 */ |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
12 |
| 12 | 13 #define OK 0 |
| 14 #define ERR -1 | |
| 15 | |
| 13 | 16 #define OFFSET(type, field) ((void *)&((type *)NULL)->field - (void *)NULL) |
| 17 #define SWAP(a, b, t) do { t c; c = a; a = b; b = c; } while(0) | |
| 18 | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
19 #ifdef UNITTEST |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
20 typedef struct _sh_dummy sh_dummy_t; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
21 |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
22 extern void sh_dummy_transform(shape_t *shape); |
|
20
74d3d5dc9aaa
rename XXX_draw() to XXX_fill()
Thinker K.F. Li <thinker@branda.to>
parents:
19
diff
changeset
|
23 extern void sh_dummy_fill(shape_t *, cairo_t *); |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
24 #endif /* UNITTEST */ |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
25 |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
26 /*! \brief Sort a list of element by a unsigned integer. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
27 * |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
28 * The result is in ascend order. The unsigned integers is |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
29 * at offset specified by 'off' from start address of elemnts. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
30 */ |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
31 static void _insert_sort(void **elms, int num, int off) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
32 int i, j; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
33 unsigned int val; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
34 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
35 for(i = 1; i < num; i++) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
36 val = *(unsigned int *)(elms[i] + off); |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
37 for(j = i; j > 0; j--) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
38 if(*(unsigned int *)(elms[j - 1] + off) <= val) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
39 break; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
40 elms[j] = elms[j - 1]; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
41 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
42 elms[j] = elms[i]; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
43 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
44 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
45 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
46 static int extend_memblk(void **buf, int o_size, int n_size) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
47 void *new_buf; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
48 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
49 new_buf = realloc(*buf, n_size); |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
50 if(new_buf == NULL) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
51 return ERR; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
52 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
53 if(new_buf != *buf) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
54 *buf = new_buf; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
55 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
56 return OK; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
57 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
58 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
59 static int add_dirty_geo(redraw_man_t *rdman, geo_t *geo) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
60 int max_dirty_geos; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
61 int r; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
62 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
63 if(rdman->n_dirty_geos >= rdman->max_dirty_geos) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
64 max_dirty_geos = rdman->n_geos; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
65 r = extend_memblk((void **)&rdman->dirty_geos, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
66 sizeof(geo_t *) * rdman->n_dirty_geos, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
67 sizeof(geo_t *) * max_dirty_geos); |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
68 if(r != OK) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
69 return ERR; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
70 rdman->max_dirty_geos = max_dirty_geos; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
71 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
72 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
73 rdman->dirty_geos[rdman->n_dirty_geos++] = geo; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
74 return OK; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
75 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
76 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
77 static int add_dirty_area(redraw_man_t *rdman, area_t *area) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
78 int max_dirty_areas; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
79 int r; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
80 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
81 if(rdman->n_dirty_areas >= rdman->max_dirty_areas) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
82 /* every geo object and coord object can contribute 2 areas. */ |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
83 max_dirty_areas = (rdman->n_geos + rdman->n_coords) * 2; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
84 r = extend_memblk((void **)&rdman->dirty_areas, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
85 sizeof(area_t *) * rdman->n_dirty_areas, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
86 sizeof(area_t *) * max_dirty_areas); |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
87 if(r != OK) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
88 return ERR; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
89 rdman->max_dirty_areas = max_dirty_areas; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
90 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
91 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
92 rdman->dirty_areas[rdman->n_dirty_areas++] = area; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
93 return OK; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
94 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
95 |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
96 static void area_to_positions(area_t *area, co_aix (*poses)[2]) { |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
97 poses[0][0] = area->x; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
98 poses[0][1] = area->y; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
99 poses[1][0] = area->x + area->w; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
100 poses[1][1] = area->y + area->h;; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
101 } |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
102 |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
103 int redraw_man_init(redraw_man_t *rdman, cairo_t *cr, cairo_t *backend) { |
| 12 | 104 extern void redraw_man_destroy(redraw_man_t *rdman); |
| 105 | |
| 106 memset(rdman, 0, sizeof(redraw_man_t)); | |
| 107 | |
| 108 rdman->geo_pool = elmpool_new(sizeof(geo_t), 128); | |
| 109 if(rdman->geo_pool == NULL) | |
| 110 return ERR; | |
| 111 | |
| 112 rdman->coord_pool = elmpool_new(sizeof(coord_t), 16); | |
| 113 if(rdman->coord_pool == NULL) { | |
| 114 elmpool_free(rdman->geo_pool); | |
| 115 return ERR; | |
| 116 } | |
| 117 | |
|
18
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
118 rdman->shnode_pool = elmpool_new(sizeof(shnode_t), 16); |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
119 if(rdman->shnode_pool == NULL) { |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
120 elmpool_free(rdman->geo_pool); |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
121 elmpool_free(rdman->coord_pool); |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
122 return ERR; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
123 } |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
124 |
| 12 | 125 rdman->root_coord = elmpool_elm_alloc(rdman->coord_pool); |
| 126 if(rdman->root_coord == NULL) | |
| 127 redraw_man_destroy(rdman); | |
| 13 | 128 rdman->n_coords = 1; |
| 12 | 129 coord_init(rdman->root_coord, NULL); |
| 130 | |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
131 rdman->cr = cr; |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
132 rdman->backend = backend; |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
133 |
| 12 | 134 return OK; |
| 135 } | |
| 136 | |
| 137 void redraw_man_destroy(redraw_man_t *rdman) { | |
| 138 elmpool_free(rdman->coord_pool); | |
| 139 elmpool_free(rdman->geo_pool); | |
|
18
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
140 elmpool_free(rdman->shnode_pool); |
| 13 | 141 if(rdman->dirty_coords) |
| 142 free(rdman->dirty_coords); | |
| 14 | 143 if(rdman->dirty_geos) |
| 144 free(rdman->dirty_geos); | |
| 12 | 145 } |
| 146 | |
| 147 | |
| 148 #define ASSERT(x) | |
| 149 /* | |
| 150 * Change transformation matrix | |
| 151 * - update aggregated transformation matrix | |
| 152 * - of coord_t object been changed. | |
| 153 * - of children coord_t objects. | |
| 154 * - redraw members of coord_t objects. | |
| 155 * - redraw shape objects they are overlaid with members. | |
| 156 * - find out overlaid shape objects. | |
| 157 * - geo_t of a coord_t object | |
| 158 * - can make finding more efficiency. | |
| 159 * - fill overlay geo_t objects of members. | |
| 160 * | |
| 161 * Change a shape object | |
| 162 * - redraw changed object. | |
| 163 * - redraw shape objects they are overlaid with changed object. | |
| 164 * - find out overlaid shape objects. | |
| 165 * | |
| 166 * That coord and geo of shape objects are setted by user code | |
| 167 * give user code a chance to collect coord and geo objects together | |
| 168 * and gain interest of higher cache hit rate. | |
| 169 */ | |
| 170 | |
| 171 /*! \brief Find out all affected shape objects. | |
| 172 * | |
| 173 * Find out all shape objects that are overalid with geo_t of | |
| 174 * a geometry changed object. | |
| 175 * | |
| 176 * Linear scan geo_t objects of all shape objects in all_shapes | |
| 177 * list of a redraw_man_t object. | |
| 178 */ | |
| 179 int rdman_find_overlaid_shapes(redraw_man_t *rdman, geo_t *geo, | |
| 180 geo_t ***overlays) { | |
| 181 int n_geos; | |
| 182 geo_t **geos; | |
| 183 geo_t *geo_cur; | |
| 184 int n_overlays; | |
| 185 geo_t **_overlays; | |
| 186 int i; | |
| 187 | |
| 188 n_geos = rdman->n_geos; | |
| 189 | |
| 190 geos = (geo_t **)malloc(sizeof(geo_t *) * n_geos); | |
| 191 if(geos == NULL) | |
| 192 return -1; | |
| 193 | |
| 194 _overlays = (geo_t **)malloc(sizeof(geo_t *) * n_geos); | |
| 195 if(geos == NULL) { | |
| 196 free(geos); | |
| 197 return -1; | |
| 198 } | |
| 199 | |
| 200 geo_cur = STAILQ_HEAD(rdman->all_geos); | |
| 201 for(i = 0; i < n_geos; i++) { | |
| 202 geos[i] = geo_cur; | |
| 203 geo_cur = STAILQ_NEXT(geo_t, next, geo_cur); | |
| 204 } | |
| 205 geo_mark_overlay(geo, n_geos, geos, &n_overlays, _overlays); | |
| 206 | |
| 207 free(geos); | |
| 208 *overlays = _overlays; | |
| 209 | |
| 210 return n_overlays; | |
| 211 } | |
| 212 | |
| 213 int rdman_add_shape(redraw_man_t *rdman, shape_t *shape, coord_t *coord) { | |
| 214 geo_t *geo; | |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
215 #ifdef GEO_ORDER |
| 13 | 216 geo_t *visit; |
| 217 unsigned int next_order; | |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
218 #endif |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
219 int r; |
| 12 | 220 |
| 221 geo = elmpool_elm_alloc(rdman->geo_pool); | |
| 222 if(geo == NULL) | |
| 223 return ERR; | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
224 |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
225 geo_init(geo); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
226 |
| 12 | 227 sh_attach_geo(shape, geo); |
| 228 STAILQ_INS_TAIL(rdman->all_geos, geo_t, next, geo); | |
| 229 rdman->n_geos++; | |
| 13 | 230 |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
231 #ifdef GEO_ORDER |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
232 /* TODO: remove order number. */ |
| 13 | 233 geo->order = ++rdman->next_geo_order; |
| 234 if(geo->order == 0) { | |
| 235 next_order = 0; | |
| 236 for(visit = STAILQ_HEAD(rdman->all_geos); | |
| 237 visit != NULL; | |
| 238 visit = STAILQ_NEXT(geo_t, next, visit)) | |
| 239 visit->order = ++next_order; | |
| 240 rdman->next_geo_order = next_order; | |
| 241 } | |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
242 #endif |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
243 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
244 /* New one should be dirty to recompute it when drawing. */ |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
245 geo->flags |= GEF_DIRTY; |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
246 r = add_dirty_geo(rdman, geo); |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
247 if(r != OK) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
248 return ERR; |
| 13 | 249 |
| 12 | 250 sh_attach_coord(shape, coord); |
| 251 | |
| 252 return OK; | |
| 253 } | |
| 254 | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
255 /*! \brief Remove a shape object from redraw manager. |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
256 * |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
257 * TODO: redraw shape objects that overlaid with removed one. |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
258 */ |
| 12 | 259 int rdman_remove_shape(redraw_man_t *rdman, shape_t *shape) { |
| 260 STAILQ_REMOVE(rdman->all_geos, geo_t, next, shape->geo); | |
| 261 elmpool_elm_free(rdman->geo_pool, shape->geo); | |
| 262 sh_detach_geo(shape); | |
| 263 rdman->n_geos--; | |
| 264 sh_detach_coord(shape); | |
| 265 return OK; | |
| 266 } | |
| 267 | |
| 268 coord_t *rdman_coord_new(redraw_man_t *rdman, coord_t *parent) { | |
| 13 | 269 coord_t *coord, *root_coord; |
| 270 coord_t *visit; | |
| 12 | 271 |
| 272 coord = elmpool_elm_alloc(rdman->coord_pool); | |
| 273 if(coord == NULL) | |
| 274 return NULL; | |
| 275 | |
| 276 coord_init(coord, parent); | |
| 13 | 277 rdman->n_coords++; |
| 278 | |
| 279 coord->order = ++rdman->next_coord_order; | |
| 280 if(coord->order == 0) { | |
| 281 rdman->next_coord_order = 0; | |
| 282 root_coord = visit = rdman->root_coord; | |
| 283 /* skip root coord. */ | |
| 284 visit = preorder_coord_subtree(root_coord, visit); | |
| 285 while(visit) { | |
| 286 visit->order = ++rdman->next_coord_order; | |
| 287 visit = preorder_coord_subtree(root_coord, visit); | |
| 288 } | |
| 289 } | |
| 12 | 290 |
| 291 return coord; | |
| 292 } | |
| 293 | |
| 294 /*! \brief Free a coord of a redraw_man_t object. | |
| 295 * | |
| 296 * \param coord is a coord_t without children and members. | |
| 297 * \return 0 for successful, -1 for error. | |
| 298 */ | |
| 299 int rdman_coord_free(redraw_man_t *rdman, coord_t *coord) { | |
| 300 coord_t *parent; | |
| 301 | |
| 302 parent = coord->parent; | |
| 303 if(parent == NULL) | |
| 304 return ERR; | |
| 305 | |
| 306 if(STAILQ_HEAD(coord->members) != NULL) | |
| 307 return ERR; | |
| 308 | |
| 309 if(STAILQ_HEAD(coord->children) != NULL) | |
| 310 return ERR; | |
| 311 | |
| 312 STAILQ_REMOVE(parent->children, coord_t, sibling, coord); | |
| 313 elmpool_elm_free(rdman->coord_pool, coord); | |
| 13 | 314 rdman->n_coords--; |
| 315 | |
| 316 return OK; | |
| 317 } | |
| 318 | |
| 319 /*! \brief Mark a coord is changed. | |
| 320 * | |
| 321 * A changed coord_t object is marked as dirty and put | |
| 322 * into dirty_coords list. | |
| 323 */ | |
| 324 int rdman_coord_changed(redraw_man_t *rdman, coord_t *coord) { | |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
325 coord_t *child; |
| 13 | 326 int max_dirty_coords; |
| 327 int r; | |
| 328 | |
| 329 if(coord->flags & COF_DIRTY) | |
| 330 return OK; | |
| 331 | |
| 332 if(rdman->n_dirty_coords >= rdman->max_dirty_coords) { | |
| 333 /* Max of dirty_coords is not big enough. */ | |
| 334 max_dirty_coords = rdman->max_dirty_coords + 16; | |
| 335 | |
| 336 r = extend_memblk((void **)&rdman->dirty_coords, | |
| 337 sizeof(coord_t *) * rdman->n_dirty_coords, | |
| 338 sizeof(coord_t *) * max_dirty_coords); | |
| 339 rdman->max_dirty_coords = max_dirty_coords; | |
| 340 } | |
| 341 | |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
342 /* Make the coord and child coords dirty. */ |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
343 for(child = coord; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
344 child != NULL; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
345 child = preorder_coord_subtree(coord, child)) { |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
346 rdman->dirty_coords[rdman->n_dirty_coords++] = coord; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
347 coord->flags |= COF_DIRTY; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
348 } |
| 13 | 349 |
| 350 return OK; | |
| 351 } | |
| 352 | |
|
18
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
353 static int _rdman_shape_changed(redraw_man_t *rdman, shape_t *shape) { |
| 13 | 354 geo_t *geo; |
| 355 int r; | |
| 356 | |
| 357 geo = shape->geo; | |
| 358 | |
| 359 if(geo->flags & GEF_DIRTY) | |
| 360 return OK; | |
| 361 | |
| 362 r = add_dirty_geo(rdman, geo); | |
| 363 if(r == ERR) | |
| 364 return ERR; | |
| 365 geo->flags |= GEF_DIRTY; | |
| 12 | 366 |
| 367 return OK; | |
| 368 } | |
| 369 | |
|
18
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
370 /*! \brief Mark a shape is changed. |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
371 * |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
372 * The geo_t object of a changed shape is mark as dirty and |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
373 * put into dirty_geos list. |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
374 */ |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
375 int rdman_shape_changed(redraw_man_t *rdman, shape_t *shape) { |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
376 return _rdman_shape_changed(rdman, shape); |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
377 } |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
378 |
| 28 | 379 /* Clean dirties */ |
| 380 | |
| 381 static void clean_shape(shape_t *shape) { | |
| 382 switch(shape->sh_type) { | |
| 383 case SHT_PATH: | |
| 384 sh_path_transform(shape); | |
| 385 break; | |
| 386 case SHT_TEXT: | |
| 387 sh_text_transform(shape); | |
| 388 break; | |
| 389 #ifdef UNITTEST | |
| 390 default: | |
| 391 sh_dummy_transform(shape); | |
| 392 break; | |
| 393 #endif /* UNITTEST */ | |
| 394 } | |
| 395 shape->geo->flags &= ~GEF_DIRTY; | |
| 396 } | |
| 397 | |
| 398 static int clean_coord(coord_t *coord) { | |
| 399 shape_t *shape; | |
| 400 geo_t *geo; | |
| 401 co_aix (*poses)[2]; | |
| 402 int cnt, pos_cnt; | |
| 403 | |
| 404 compute_aggr_of_coord(coord); | |
| 405 | |
| 406 /* Clean member shapes. */ | |
| 407 cnt = 0; | |
| 408 for(shape = STAILQ_HEAD(coord->members); | |
| 409 shape != NULL; | |
| 410 shape = STAILQ_NEXT(shape_t, coord_mem_next, shape)) { | |
| 411 geo = shape->geo; | |
| 412 SWAP(geo->cur_area, geo->last_area, area_t *); | |
| 413 clean_shape(shape); | |
| 414 cnt++; | |
| 415 } | |
| 416 | |
| 417 /* Compute area of the coord. */ | |
| 418 poses = (co_aix (*)[2])malloc(sizeof(co_aix [2]) * 2 * cnt); | |
| 419 if(poses == NULL) | |
| 420 return ERR; | |
| 421 | |
| 422 pos_cnt = 0; | |
| 423 for(shape = STAILQ_HEAD(coord->members); | |
| 424 shape != NULL; | |
| 425 shape = STAILQ_NEXT(shape_t, coord_mem_next, shape)) { | |
| 426 geo = shape->geo; | |
| 427 | |
| 428 area_to_positions(geo->cur_area, poses + pos_cnt); | |
| 429 pos_cnt += 2; | |
| 430 } | |
| 431 | |
| 432 SWAP(coord->cur_area, coord->last_area, area_t *); | |
| 433 area_init(coord->cur_area, pos_cnt, poses); | |
| 434 free(poses); | |
| 435 | |
| 436 coord->flags &= ~COF_DIRTY; | |
| 437 | |
| 438 return OK; | |
| 439 } | |
| 440 | |
| 441 static int clean_rdman_coords(redraw_man_t *rdman) { | |
| 442 coord_t *coord; | |
| 443 coord_t **dirty_coords; | |
| 444 int n_dirty_coords; | |
| 445 int i, r; | |
| 446 | |
| 447 n_dirty_coords = rdman->n_dirty_coords; | |
| 448 if(n_dirty_coords > 0) { | |
| 449 dirty_coords = rdman->dirty_coords; | |
| 450 _insert_sort((void **)dirty_coords, n_dirty_coords, | |
| 451 OFFSET(coord_t, order)); | |
| 452 for(i = 0; i < n_dirty_coords; i++) { | |
| 453 coord = dirty_coords[i]; | |
| 454 if(!(coord->flags & COF_DIRTY)) | |
| 455 continue; | |
| 456 r = clean_coord(coord); | |
| 457 if(r != OK) | |
| 458 return ERR; | |
| 459 /* These two steps can be avoided for drawing all. */ | |
| 460 add_dirty_area(rdman, &coord->areas[0]); | |
| 461 add_dirty_area(rdman, &coord->areas[1]); | |
| 462 } | |
| 463 rdman->n_dirty_coords = 0; | |
| 464 } | |
| 465 return OK; | |
| 466 } | |
| 467 | |
| 468 static int clean_rdman_geos(redraw_man_t *rdman) { | |
| 469 int i; | |
| 470 int n_dirty_geos; | |
| 471 geo_t **dirty_geos; | |
| 472 geo_t *visit_geo; | |
| 473 | |
| 474 n_dirty_geos = rdman->n_dirty_geos; | |
| 475 if(n_dirty_geos > 0) { | |
| 476 dirty_geos = rdman->dirty_geos; | |
| 477 for(i = 0; i < n_dirty_geos; i++) { | |
| 478 visit_geo = dirty_geos[i]; | |
| 479 if(!(visit_geo->flags & GEF_DIRTY)) | |
| 480 continue; | |
| 481 | |
| 482 SWAP(visit_geo->cur_area, visit_geo->last_area, area_t *); | |
| 483 clean_shape(visit_geo->shape); | |
| 484 add_dirty_area(rdman, visit_geo->cur_area); | |
| 485 add_dirty_area(rdman, visit_geo->last_area); | |
| 486 } | |
| 487 rdman->n_dirty_geos = 0; | |
| 488 } | |
| 489 | |
| 490 return OK; | |
| 491 } | |
| 492 | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
493 /* Drawing and Redrawing |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
494 * ============================================================ |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
495 */ |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
496 |
|
26
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
497 #ifndef UNITTEST |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
498 static void set_shape_stroke_param(shape_t *shape, cairo_t *cr) { |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
499 cairo_set_line_width(cr, shape->stroke_width); |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
500 } |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
501 #else |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
502 static void set_shape_stroke_param(shape_t *shape, cairo_t *cr) { |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
503 } |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
504 #endif |
|
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
505 |
| 22 | 506 static void draw_shape(redraw_man_t *rdman, shape_t *shape) { |
| 507 paint_t *fill, *stroke; | |
|
18
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
508 |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
509 fill = shape->fill; |
| 19 | 510 if(fill) { |
|
18
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
511 fill->prepare(fill, rdman->cr); |
| 19 | 512 switch(shape->sh_type) { |
| 513 case SHT_PATH: | |
|
20
74d3d5dc9aaa
rename XXX_draw() to XXX_fill()
Thinker K.F. Li <thinker@branda.to>
parents:
19
diff
changeset
|
514 sh_path_fill(shape, rdman->cr); |
| 19 | 515 break; |
| 27 | 516 case SHT_TEXT: |
| 517 sh_text_fill(shape, rdman->cr); | |
| 518 break; | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
519 #ifdef UNITTEST |
| 19 | 520 default: |
|
20
74d3d5dc9aaa
rename XXX_draw() to XXX_fill()
Thinker K.F. Li <thinker@branda.to>
parents:
19
diff
changeset
|
521 sh_dummy_fill(shape, rdman->cr); |
| 19 | 522 break; |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
523 #endif /* UNITTEST */ |
| 19 | 524 } |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
525 } |
| 22 | 526 stroke = shape->stroke; |
| 527 if(stroke) { | |
| 528 stroke->prepare(stroke, rdman->cr); | |
|
26
d50f33040de6
Set line width for path.
Thinker K.F. Li <thinker@branda.to>
parents:
25
diff
changeset
|
529 set_shape_stroke_param(shape, rdman->cr); |
| 22 | 530 switch(shape->sh_type) { |
| 531 case SHT_PATH: | |
| 532 sh_path_stroke(shape, rdman->cr); | |
| 533 break; | |
| 27 | 534 case SHT_TEXT: |
| 535 sh_text_stroke(shape, rdman->cr); | |
| 536 break; | |
| 22 | 537 #ifdef UNITTEST |
| 538 default: | |
| 539 /* sh_dummy_fill(shape, rdman->cr); */ | |
| 540 break; | |
| 541 #endif /* UNITTEST */ | |
| 542 } | |
| 543 } | |
| 13 | 544 } |
| 545 | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
546 #ifndef UNITTEST |
|
25
29937c26bb01
Fix bug of a dark line appear when animating.
Thinker K.F. Li <thinker@branda.to>
parents:
24
diff
changeset
|
547 static void clean_canvas(cairo_t *cr) { |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
548 /* TODO: clean to background color. */ |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
549 cairo_set_source_rgb(cr, 0, 0, 0); |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
550 cairo_paint(cr); |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
551 } |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
552 |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
553 static void make_clip(cairo_t *cr, int n_dirty_areas, |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
554 area_t **dirty_areas) { |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
555 int i; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
556 area_t *area; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
557 |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
558 for(i = 0; i < n_dirty_areas; i++) { |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
559 area = dirty_areas[i]; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
560 cairo_rectangle(cr, area->x, area->y, area->w, area->h); |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
561 } |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
562 cairo_clip(cr); |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
563 } |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
564 |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
565 static void reset_clip(redraw_man_t *rdman) { |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
566 cairo_reset_clip(rdman->cr); |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
567 cairo_reset_clip(rdman->backend); |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
568 } |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
569 |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
570 static void copy_cr_2_backend(redraw_man_t *rdman, int n_dirty_areas, |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
571 area_t **dirty_areas) { |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
572 if(n_dirty_areas) |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
573 make_clip(rdman->backend, n_dirty_areas, dirty_areas); |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
574 |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
575 cairo_paint(rdman->backend); |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
576 } |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
577 #else /* UNITTEST */ |
|
25
29937c26bb01
Fix bug of a dark line appear when animating.
Thinker K.F. Li <thinker@branda.to>
parents:
24
diff
changeset
|
578 static void clean_canvas(cairo_t *cr) { |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
579 } |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
580 |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
581 static void reset_clip(redraw_man_t *rdman) { |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
582 } |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
583 |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
584 static void copy_cr_2_backend(redraw_man_t *rdman, int n_dirty_areas, |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
585 area_t **dirty_areas) { |
|
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
586 } |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
587 #endif /* UNITTEST */ |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
588 |
| 22 | 589 static void draw_shapes_in_areas(redraw_man_t *rdman, |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
590 int n_areas, |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
591 area_t **areas) { |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
592 geo_t *visit_geo; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
593 int i; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
594 |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
595 for(visit_geo = STAILQ_HEAD(rdman->all_geos); |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
596 visit_geo != NULL; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
597 visit_geo = STAILQ_NEXT(geo_t, next, visit_geo)) { |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
598 if(visit_geo->flags & GEF_DIRTY) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
599 clean_shape(visit_geo->shape); |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
600 for(i = 0; i < n_areas; i++) { |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
601 if(is_overlay(visit_geo->cur_area, areas[i])) { |
| 22 | 602 draw_shape(rdman, visit_geo->shape); |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
603 break; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
604 } |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
605 } |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
606 } |
| 13 | 607 } |
| 608 | |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
609 |
| 13 | 610 /*! \brief Re-draw all changed shapes or shapes affected by changed coords. |
| 611 * | |
| 612 * A coord object has a geo to keep track the range that it's members will | |
| 613 * draw on. Geo of a coord should be recomputed when the coord is changed. | |
| 614 * Geo of a coord used to accelerate finding overlay shape objects of | |
| 615 * a specified geo. A coord object also must be recomputed when one of | |
| 616 * it's members is changed. | |
| 617 * | |
| 618 * New and old geo values of a coord object that is recomputed for | |
| 619 * changing of it-self must be used to find overlay shape objects. | |
| 620 * New and old geo values of a shape should also be used to find | |
| 621 * overlay shape objects, too. If a shape's coord is changed, shape's | |
| 622 * geo object is not used to find overlay shape objects any more. | |
| 623 * | |
| 624 * steps: | |
| 625 * - update chagned coord objects | |
| 14 | 626 * - recompute area for changed coord objects |
| 13 | 627 * - recompute geo for members shape objects |
| 14 | 628 * - clear dirty of geo for members to prevent from |
| 629 * recomputing for change of shape objects. | |
| 630 * - add old and new area value to list of dirty areas. | |
| 13 | 631 * - recompute geo for changed shape objects |
| 14 | 632 * - only if a shape object is dirty. |
| 633 * - put new and old value of area of geo to list of dirty areas. | |
| 634 * - Scan all shapes and redraw shapes overlaid with dirty areas. | |
| 13 | 635 * |
| 14 | 636 * dirty flag of coord objects is cleared after update. |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
637 * dirty flag of geo objects is also cleared after recomputing. |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
638 * Clean dirty flag can prevent redundant computing for geo and |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
639 * corod objects. |
| 14 | 640 * |
| 13 | 641 */ |
| 642 int rdman_redraw_changed(redraw_man_t *rdman) { | |
| 28 | 643 int r; |
| 13 | 644 int n_dirty_areas; |
| 14 | 645 area_t **dirty_areas; |
| 13 | 646 |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
647 r = clean_rdman_coords(rdman); |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
648 if(r != OK) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
649 return ERR; |
| 13 | 650 |
| 28 | 651 r = clean_rdman_geos(rdman); |
| 652 if(r != OK) | |
| 653 return ERR; | |
| 654 | |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
655 n_dirty_areas = rdman->n_dirty_areas; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
656 dirty_areas = rdman->dirty_areas; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
657 if(n_dirty_areas > 0) { |
|
25
29937c26bb01
Fix bug of a dark line appear when animating.
Thinker K.F. Li <thinker@branda.to>
parents:
24
diff
changeset
|
658 clean_canvas(rdman->cr); |
| 22 | 659 draw_shapes_in_areas(rdman, n_dirty_areas, dirty_areas); |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
660 copy_cr_2_backend(rdman, rdman->n_dirty_areas, rdman->dirty_areas); |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
661 rdman->n_dirty_areas = 0; |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
662 reset_clip(rdman); |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
663 } |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
664 rdman->n_dirty_areas = 0; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
665 |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
666 return OK; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
667 } |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
668 |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
669 int rdman_redraw_all(redraw_man_t *rdman) { |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
670 geo_t *geo; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
671 |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
672 clean_rdman_coords(rdman); |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
673 rdman->n_dirty_areas = 0; |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
674 |
|
15
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
675 for(geo = STAILQ_HEAD(rdman->all_geos); |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
676 geo != NULL; |
|
c2ce186a5c37
X_main uses rdman_redraw_all()
Thinker K.F. Li <thinker@branda.to>
parents:
14
diff
changeset
|
677 geo = STAILQ_NEXT(geo_t, next, geo)) { |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
678 if(geo->flags & GEF_DIRTY) |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
679 clean_shape(geo->shape); |
| 22 | 680 draw_shape(rdman, geo->shape); |
| 13 | 681 } |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
682 copy_cr_2_backend(rdman, 0, NULL); |
|
23
56f592f56ff7
Fix bug and add linear gradient paint.
Thinker K.F. Li <thinker@branda.to>
parents:
22
diff
changeset
|
683 rdman->n_dirty_geos = 0; |
| 13 | 684 |
| 685 return OK; | |
| 12 | 686 } |
| 687 | |
|
18
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
688 shnode_t *shnode_new(redraw_man_t *rdman, shape_t *shape) { |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
689 shnode_t *node; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
690 |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
691 node = (shnode_t *)elmpool_elm_alloc(rdman->shnode_pool); |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
692 if(node) { |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
693 node->shape = shape; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
694 node->next = NULL; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
695 } |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
696 return node; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
697 } |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
698 |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
699 int rdman_paint_changed(redraw_man_t *rdman, paint_t *paint) { |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
700 shnode_t *node; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
701 int r; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
702 |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
703 for(node = STAILQ_HEAD(paint->members); |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
704 node != NULL; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
705 node = STAILQ_NEXT(shnode_t, next, node)) { |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
706 r = _rdman_shape_changed(rdman, node->shape); |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
707 if(r != OK) |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
708 return ERR; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
709 } |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
710 return OK; |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
711 } |
|
0f3baa488a62
Support solid color paint for fill.
Thinker K.F. Li <thinker@branda.to>
parents:
17
diff
changeset
|
712 |
| 12 | 713 /* |
|
16
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
714 * Dirty of geo |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
715 * A geo is dirty when any of the shape, size or positions is changed. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
716 * It's geo and positions should be recomputed before drawing. So, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
717 * dirty geos are marked as dirty and put into dirty_geos list. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
718 * The list is inspected before drawing to make sure the right shape, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
719 * size, and positions. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
720 * |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
721 * Dirty of coord |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
722 * A coord is dirty when it's transformation matrix being changed. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
723 * Dirty coords are marked as dirty and put into dirty_coords list. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
724 * Once a coord is dirty, every member geos of it are also dirty. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
725 * Because, their shape, size and positions will be changed. But, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
726 * they are not marked as dirty and put into dirty_geos list, since |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
727 * all these member geos will be recomputed for computing new current |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
728 * area of the coord. The changes of a coord also affect child |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
729 * coords. Once parent is dirty, all children are also dirty for |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
730 * their aggregate matrix out of date. Dirty coords should be |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
731 * clean in preorder of tree traversal. The dirty_coords list |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
732 * are sorted to keep the order before cleaning. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
733 * Whenever a coord is marked dirty and put into dirty_coords list, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
734 * all it's children should also be marked and put. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
735 * |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
736 * The procedure of clean coords comprises recomputing aggregate |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
737 * tranform matrix and area where members spreading in. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
738 * |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
739 * The list is inspected before drawing to recompute new shape, size, |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
740 * and positions of member geos of coords in the list. The drity |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
741 * flag of member geos will be clean. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
742 * |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
743 * Clean coords should be performed before clean geos, since clean |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
744 * coords will also clean member geos. |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
745 */ |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
746 |
|
e17e12b112c4
A simple animation using rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
15
diff
changeset
|
747 /* |
| 12 | 748 * When redraw an area, the affected elements may also extend to |
| 749 * outside of the area. Since the order of drawing will change | |
| 750 * the result, it will infect more and more elements to keep | |
| 751 * drawing order althrough they are overlaid directly with | |
| 752 * specified area. | |
| 753 * | |
| 754 * To fix the problem, we don't extend the set of redrawing to | |
| 755 * elements they are not overliad directly. The redrawing is | |
| 756 * performed on a temporary surface, clipped to fit the area, and | |
| 757 * update only specified area on the destinate surface. | |
| 758 */ | |
| 759 | |
| 760 /* | |
| 761 * To accelerate speed of transformation, when a matrix changed, | |
| 762 * transformation should be aggregated and computed in a loop. | |
| 763 * It can get intereset of higher hit rate of cache. | |
| 764 * - shapes prvoide list of positions needed to be transformed. | |
| 765 * - redraw_man transforms positions from shapes. | |
| 766 * - shapes drawing with result of transforms. | |
| 767 * - shapes should be called to give them a chance to update geometries. | |
| 768 */ | |
| 769 | |
| 13 | 770 /* |
| 771 * functions: | |
| 772 * - redraw all | |
| 773 * - redraw changed | |
| 774 */ | |
| 775 | |
| 12 | 776 #ifdef UNITTEST |
| 777 | |
| 778 #include <CUnit/Basic.h> | |
| 19 | 779 #include "paint.h" |
| 12 | 780 |
| 781 struct _sh_dummy { | |
| 782 shape_t shape; | |
| 783 co_aix x, y; | |
| 784 co_aix w, h; | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
785 int draw_cnt; |
| 12 | 786 }; |
| 787 | |
| 788 shape_t *sh_dummy_new(co_aix x, co_aix y, co_aix w, co_aix h) { | |
| 789 sh_dummy_t *dummy; | |
| 790 | |
| 791 dummy = (sh_dummy_t *)malloc(sizeof(sh_dummy_t)); | |
| 792 if(dummy == NULL) | |
| 793 return NULL; | |
| 794 | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
795 memset(dummy, 0, sizeof(sh_dummy_t)); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
796 |
| 12 | 797 dummy->x = x; |
| 798 dummy->y = y; | |
| 799 dummy->w = w; | |
| 800 dummy->h = h; | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
801 dummy->draw_cnt = 0; |
| 12 | 802 |
| 803 return (shape_t *)dummy; | |
| 804 } | |
| 805 | |
| 806 void sh_dummy_free(shape_t *sh) { | |
| 807 free(sh); | |
| 808 } | |
| 809 | |
| 810 void sh_dummy_transform(shape_t *shape) { | |
| 811 sh_dummy_t *dummy = (sh_dummy_t *)shape; | |
| 812 co_aix poses[2][2]; | |
| 813 co_aix x1, y1, x2, y2; | |
| 814 | |
| 815 if(shape->geo && shape->coord) { | |
| 816 x1 = dummy->x; | |
| 817 y1 = dummy->y; | |
| 818 x2 = x1 + dummy->w; | |
| 819 y2 = y1 + dummy->h; | |
| 820 | |
| 821 coord_trans_pos(shape->coord, &x1, &y1); | |
| 822 coord_trans_pos(shape->coord, &x2, &y2); | |
| 823 poses[0][0] = x1; | |
| 824 poses[0][1] = y1; | |
| 825 poses[1][0] = x2; | |
| 826 poses[1][1] = y2; | |
| 827 | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
828 if(shape->geo) |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
829 geo_from_positions(shape->geo, 2, poses); |
| 12 | 830 } |
| 831 } | |
| 832 | |
|
20
74d3d5dc9aaa
rename XXX_draw() to XXX_fill()
Thinker K.F. Li <thinker@branda.to>
parents:
19
diff
changeset
|
833 void sh_dummy_fill(shape_t *shape, cairo_t *cr) { |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
834 sh_dummy_t *dummy; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
835 |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
836 dummy = (sh_dummy_t *)shape; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
837 dummy->draw_cnt++; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
838 } |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
839 |
| 19 | 840 static void dummy_paint_prepare(paint_t *paint, cairo_t *cr) { |
| 841 } | |
| 842 | |
| 843 static void dummy_paint_free(paint_t *paint) { | |
| 844 if(paint) | |
| 845 free(paint); | |
| 846 } | |
| 847 | |
| 848 paint_t *dummy_paint_new(redraw_man_t *rdman) { | |
| 849 paint_t *paint; | |
| 850 | |
| 851 paint = (paint_t *)malloc(sizeof(paint_t)); | |
| 852 if(paint == NULL) | |
| 853 return NULL; | |
| 854 | |
| 855 paint_init(paint, dummy_paint_prepare, dummy_paint_free); | |
| 856 | |
| 857 return paint; | |
| 858 } | |
| 859 | |
| 12 | 860 void test_rdman_find_overlaid_shapes(void) { |
| 861 redraw_man_t rdman; | |
| 862 geo_t geo; | |
| 863 coord_t *coords[3]; | |
| 864 shape_t *shapes[5]; | |
| 865 geo_t **overlays; | |
| 13 | 866 co_aix pos[2][2]; |
| 12 | 867 int n; |
| 868 int i; | |
| 869 | |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
870 redraw_man_init(&rdman, NULL, NULL); |
| 12 | 871 coords[0] = rdman.root_coord; |
| 872 for(i = 1; i < 3; i++) { | |
| 873 coords[i] = rdman_coord_new(&rdman, rdman.root_coord); | |
| 874 } | |
| 875 for(i = 0; i < 5; i++) { | |
| 876 shapes[i] = sh_dummy_new(10 + i * 30, 10 + i * 20, 25, 15); | |
| 877 CU_ASSERT(shapes[i] != NULL); | |
| 878 } | |
| 879 for(i = 0; i < 3; i++) | |
| 880 rdman_add_shape(&rdman, shapes[i], coords[1]); | |
| 881 for(i = 3; i < 5; i++) | |
| 882 rdman_add_shape(&rdman, shapes[i], coords[2]); | |
| 883 | |
| 884 coords[1]->matrix[0] = 2; | |
| 885 coords[0]->matrix[4] = 2; | |
| 886 | |
| 887 update_aggr_matrix(coords[0]); | |
| 888 for(i = 0; i < 5; i++) | |
| 889 sh_dummy_transform(shapes[i]); | |
| 890 | |
| 13 | 891 pos[0][0] = 100; |
| 892 pos[0][1] = 120; | |
| 893 pos[1][0] = 100 + 140; | |
| 894 pos[1][1] = 120 + 40; | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
895 geo_init(&geo); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
896 geo_from_positions(&geo, 2, pos); |
| 12 | 897 |
| 898 n = rdman_find_overlaid_shapes(&rdman, &geo, &overlays); | |
| 899 CU_ASSERT(n == 2); | |
| 900 CU_ASSERT(overlays != NULL); | |
| 901 CU_ASSERT(overlays[0] == shapes[2]->geo); | |
| 902 CU_ASSERT(overlays[1] == shapes[3]->geo); | |
| 903 | |
| 904 free(overlays); | |
| 905 for(i = 0; i < 5; i++) | |
| 906 sh_dummy_free(shapes[i]); | |
| 907 | |
| 908 redraw_man_destroy(&rdman); | |
| 909 } | |
| 910 | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
911 void test_rdman_redraw_changed(void) { |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
912 coord_t *coords[3]; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
913 shape_t *shapes[3]; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
914 sh_dummy_t **dummys; |
| 19 | 915 paint_t *paint; |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
916 redraw_man_t *rdman; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
917 redraw_man_t _rdman; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
918 int i; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
919 |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
920 dummys = (sh_dummy_t **)shapes; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
921 |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
922 rdman = &_rdman; |
|
24
e598bc809c0f
No more flash when animation.
Thinker K.F. Li <thinker@branda.to>
parents:
23
diff
changeset
|
923 redraw_man_init(rdman, NULL, NULL); |
| 19 | 924 paint = dummy_paint_new(rdman); |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
925 for(i = 0; i < 3; i++) { |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
926 shapes[i] = sh_dummy_new(0, 0, 50, 50); |
| 19 | 927 rdman_paint_fill(rdman, paint, shapes[i]); |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
928 coords[i] = rdman_coord_new(rdman, rdman->root_coord); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
929 coords[i]->matrix[2] = 10 + i * 100; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
930 coords[i]->matrix[5] = 10 + i * 100; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
931 rdman_coord_changed(rdman, coords[i]); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
932 rdman_add_shape(rdman, shapes[i], coords[i]); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
933 } |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
934 rdman_redraw_all(rdman); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
935 CU_ASSERT(dummys[0]->draw_cnt == 1); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
936 CU_ASSERT(dummys[1]->draw_cnt == 1); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
937 CU_ASSERT(dummys[2]->draw_cnt == 1); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
938 |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
939 coords[2]->matrix[2] = 100; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
940 coords[2]->matrix[5] = 100; |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
941 rdman_coord_changed(rdman, coords[2]); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
942 rdman_redraw_changed(rdman); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
943 |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
944 CU_ASSERT(dummys[0]->draw_cnt == 1); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
945 CU_ASSERT(dummys[1]->draw_cnt == 2); |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
946 CU_ASSERT(dummys[2]->draw_cnt == 2); |
| 19 | 947 |
| 948 paint->free(paint); | |
| 949 redraw_man_destroy(rdman); | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
950 } |
|
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
951 |
| 12 | 952 CU_pSuite get_redraw_man_suite(void) { |
| 953 CU_pSuite suite; | |
| 954 | |
| 955 suite = CU_add_suite("Suite_redraw_man", NULL, NULL); | |
| 956 CU_ADD_TEST(suite, test_rdman_find_overlaid_shapes); | |
|
17
41f0907b27ac
Unittest for rdman_redraw_changed().
Thinker K.F. Li <thinker@branda.to>
parents:
16
diff
changeset
|
957 CU_ADD_TEST(suite, test_rdman_redraw_changed); |
| 12 | 958 |
| 959 return suite; | |
| 960 } | |
| 961 | |
| 962 #endif /* UNITTEST */ |