datpath: Avoid reporting half updated statistics.
[openvswitch] / extras / ezio / ezio.c
1 /* Copyright (c) 2008, 2009 Nicira Networks, Inc.
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 #include <config.h>
17 #include "ezio.h"
18 #include <assert.h>
19 #include <stddef.h>
20 #include <string.h>
21 #include "util.h"
22
23 static void remove_elements(uint8_t *p, size_t n_elems, size_t elem_size,
24                             int pos, int n_del);
25 static void insert_elements(uint8_t *p, size_t n_elems, size_t elem_size,
26                             int pos, int n_insert);
27 static int range(int value, int min, int max);
28
29 void
30 ezio_init(struct ezio *e)
31 {
32     memset(e->icons, 0, sizeof e->icons);
33     ezio_clear(e);
34     e->x_ofs = 0;
35     e->show_cursor = true;
36     e->blink_cursor = false;
37 }
38
39 void
40 ezio_set_icon(struct ezio *e, int idx,
41               int row0, int row1, int row2, int row3,
42               int row4, int row5, int row6, int row7)
43 {
44     e->icons[idx][0] = row0;
45     e->icons[idx][1] = row1;
46     e->icons[idx][2] = row2;
47     e->icons[idx][3] = row3;
48     e->icons[idx][4] = row4;
49     e->icons[idx][5] = row5;
50     e->icons[idx][6] = row6;
51     e->icons[idx][7] = row7;
52 }
53
54 void
55 ezio_set_default_icon(struct ezio *e, int idx)
56 {
57     uint8_t *icon;
58
59     assert(idx >= 0 && idx < 8);
60     icon = e->icons[idx];
61     if (idx == 6) {
62         ezio_set_icon(e, idx,
63                       e_____,
64                       eX____,
65                       e_X___,
66                       e__X__,
67                       e___X_,
68                       e____X,
69                       e_____,
70                       e_____);
71     } else if (idx == 7) {
72         ezio_set_icon(e, idx,
73                       e_____,
74                       e_____,
75                       e_X___,
76                       eX_X_X,
77                       eX_X_X,
78                       e___X_,
79                       e_____,
80                       e_____);
81     } else {
82         ezio_set_icon(e, idx,
83                       e_____,
84                       e_____,
85                       e_____,
86                       e_____,
87                       e_____,
88                       e_____,
89                       e_____,
90                       e_____);
91     }
92 }
93
94 void
95 ezio_clear(struct ezio *e)
96 {
97     memset(e->chars, ' ', sizeof e->chars);
98     e->x = e->y = 0;
99 }
100
101 void
102 ezio_put_char(struct ezio *e, int x, int y, uint8_t c)
103 {
104     assert(x >= 0 && x <= 39);
105     assert(y >= 0 && y <= 1);
106     e->chars[y][x] = c != 0xfe ? c : 0xff;
107 }
108
109 void
110 ezio_line_feed(struct ezio *e)
111 {
112     if (++e->y >= 2) {
113         e->y = 1;
114         ezio_scroll_up(e, 1);
115     }
116 }
117
118 void
119 ezio_newline(struct ezio *e)
120 {
121     e->x = 0;
122     ezio_line_feed(e);
123 }
124
125 void
126 ezio_delete_char(struct ezio *e, int x, int y, int n)
127 {
128     remove_elements(&e->chars[y][0], 40, 1, x, n);
129 }
130
131 void
132 ezio_delete_line(struct ezio *e, int y, int n)
133 {
134     remove_elements(e->chars[0], 2, 40, y, n);
135 }
136
137 void
138 ezio_insert_char(struct ezio *e, int x, int y, int n)
139 {
140     insert_elements(&e->chars[y][0], 40, 1, x, n);
141 }
142
143 void
144 ezio_insert_line(struct ezio *e, int y, int n)
145 {
146     insert_elements(&e->chars[0][0], 2, 40, y, n);
147 }
148
149 void
150 ezio_scroll_left(struct ezio *e, int n)
151 {
152     int y;
153     for (y = 0; y < 2; y++) {
154         ezio_delete_char(e, 0, y, n);
155     }
156 }
157
158 void
159 ezio_scroll_right(struct ezio *e, int n)
160 {
161     int y;
162
163     for (y = 0; y < 2; y++) {
164         ezio_insert_char(e, 0, y, n);
165     }
166 }
167
168 void
169 ezio_scroll_up(struct ezio *e, int n)
170 {
171     ezio_delete_line(e, 0, n);
172 }
173
174 void
175 ezio_scroll_down(struct ezio *e, int n)
176 {
177     ezio_insert_line(e, 0, n);
178 }
179
180 bool
181 ezio_chars_differ(const struct ezio *a, const struct ezio *b, int x0, int x1,
182                   int *xp, int *yp)
183 {
184     int x, y;
185
186     x0 = range(x0, 0, 39);
187     x1 = range(x1, 1, 40);
188     for (y = 0; y < 2; y++) {
189         for (x = x0; x < x1; x++) {
190             if (a->chars[y][x] != b->chars[y][x]) {
191                 *xp = x;
192                 *yp = y;
193                 return true;
194             }
195         }
196     }
197     return false;
198 }
199
200 static void
201 remove_elements(uint8_t *p, size_t n_elems, size_t elem_size,
202                 int pos, int n_del)
203 {
204     if (pos >= 0 && pos < n_elems) {
205         n_del = MIN(n_del, n_elems - pos);
206         memmove(p + elem_size * pos,
207                 p + elem_size * (pos + n_del),
208                 elem_size * (n_elems - pos - n_del));
209         memset(p + elem_size * (n_elems - n_del), ' ', n_del * elem_size);
210     }
211 }
212
213 static void
214 insert_elements(uint8_t *p, size_t n_elems, size_t elem_size,
215                 int pos, int n_insert)
216 {
217     if (pos >= 0 && pos < n_elems) {
218         n_insert = MIN(n_insert, n_elems - pos);
219         memmove(p + elem_size * (pos + n_insert),
220                 p + elem_size * pos,
221                 elem_size * (n_elems - pos - n_insert));
222         memset(p + elem_size * pos, ' ', n_insert * elem_size);
223     }
224 }
225
226 static int
227 range(int value, int min, int max)
228 {
229     return value < min ? min : value > max ? max : value;
230 }
231