Change to the linux kernel coding style
[wmaker-crm.git] / wrlib / tests / testdraw.c
1
2 #include <X11/Xlib.h>
3 #include "wraster.h"
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7
8 #include <sys/time.h>
9 #include <time.h>
10
11 Display *dpy;
12 RContext *ctx;
13 char *ProgName;
14
15 void testDraw()
16 {
17 RImage *img, *tile, *icon, *tmp;
18 RColor color, from, to;
19 RColor cdelta;
20 RSegment segs[20];
21 int i, x, y;
22 XSetWindowAttributes val;
23 Pixmap pix, back;
24 Window win;
25
26 val.background_pixel = ctx->black;
27 val.colormap = ctx->cmap;
28 win = XCreateWindow(dpy, DefaultRootWindow(dpy), 10, 10, 128, 256,
29 0, ctx->depth, InputOutput, ctx->visual, CWColormap | CWBackPixel, &val);
30 back = XCreatePixmap(ctx->dpy, ctx->drawable, 128, 256, ctx->depth);
31
32 /* Dark blue tile gradient */
33 from.red = 0x28;
34 from.green = 0x45;
35 from.blue = 0x69;
36 from.alpha = 0xff;
37 to.red = 0x08;
38 to.green = 0x24;
39 to.blue = 0x20;
40 to.alpha = 0xff;
41
42 /* Standard gray tile gradient */
43 /*from.red = 0xa6;
44 from.green = 0xa6;
45 from.blue = 0xb6;
46 from.alpha = 0xff;
47 to.red = 0x51;
48 to.green = 0x55;
49 to.blue = 0x61;
50 to.alpha = 0xff; */
51
52 /* Make the tile, and put it as a sample in the first place */
53 tile = RRenderGradient(64, 64, &from, &to, RGRD_DIAGONAL);
54 img = RCloneImage(tile);
55 RConvertImage(ctx, img, &pix);
56 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 0, 0);
57
58 /* Read the image, and combine it with the tile. Put it as a sample
59 * in the second slot, and also save a copy for later use. */
60 icon = RLoadImage(ctx, "ballot_box.xpm", 0);
61 if (!icon) {
62 puts(RMessageForError(RErrorCode));
63 exit(1);
64 }
65 RCombineArea(img, icon, 0, 0, icon->width, icon->height, 8, 8);
66 RReleaseImage(icon);
67 tmp = img;
68 RConvertImage(ctx, img, &pix);
69 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 64, 0);
70
71 img = RCloneImage(tile);
72
73 /* Draw random pixels on image */
74 for (i = 0; i < 200; i++) {
75 color.red = rand() % 256;
76 color.green = rand() % 256;
77 color.blue = rand() % 256;
78 color.alpha = 255;
79 x = rand() % 64;
80 y = rand() % 64;
81 RPutPixel(img, x, y, &color);
82 }
83
84 RConvertImage(ctx, img, &pix);
85 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 0, 64);
86
87 RReleaseImage(img);
88 img = RCloneImage(tile);
89
90 /* Alter random pixels in image with the same amount for r/g/b */
91 for (i = 0; i < 200; i++) {
92 cdelta.red = cdelta.green = cdelta.blue = rand() % 511 - 255;
93 cdelta.alpha = 0;
94 x = rand() % 64;
95 y = rand() % 64;
96 ROperatePixel(img, RAddOperation, x, y, &cdelta);
97 }
98
99 RConvertImage(ctx, img, &pix);
100 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 64, 64);
101
102 RReleaseImage(img);
103 img = RCloneImage(tile);
104
105 /* Draw lines in all directions to test different slopes */
106 color.red = 0xff;
107 color.green = 0x7d;
108 color.blue = 0x52;
109 color.alpha = 0xff;
110 for (i = 0; i < 16; i++)
111 segs[i].x1 = segs[i].y1 = 31;
112
113 segs[6].x2 = segs[7].x2 = segs[8].x2 = segs[9].x2 = segs[10].x2 = 0;
114 segs[2].y2 = segs[3].y2 = segs[4].y2 = segs[5].y2 = segs[6].y2 = 0;
115 segs[5].x2 = segs[11].x2 = 16;
116 segs[1].y2 = segs[7].y2 = 16;
117 segs[4].x2 = segs[12].x2 = 31;
118 segs[0].y2 = segs[8].y2 = 31;
119 segs[3].x2 = segs[13].x2 = 46;
120 segs[9].y2 = segs[15].y2 = 46;
121 segs[0].x2 = segs[1].x2 = segs[2].x2 = segs[14].x2 = segs[15].x2 = 62;
122 segs[10].y2 = segs[11].y2 = segs[12].y2 = segs[13].y2 = segs[14].y2 = 62;
123 RDrawSegments(img, segs, 9, &color);
124
125 /* Also test how alpha channel behaves when drawing lines */
126 color.alpha = 0x80;
127 RDrawSegments(img, &segs[9], 7, &color);
128
129 RConvertImage(ctx, img, &pix);
130 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 0, 128);
131
132 RReleaseImage(img);
133 img = RCloneImage(tile);
134
135 /* Alter lines in all directions (test different slopes) */
136 cdelta.red = cdelta.green = cdelta.blue = 80;
137 cdelta.alpha = 0;
138 ROperateSegments(img, RAddOperation, segs, 16, &cdelta);
139
140 RConvertImage(ctx, img, &pix);
141 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 64, 128);
142
143 RReleaseImage(img);
144
145 /* Create a bevel around the icon, and save it for a later use */
146 img = tmp;
147 cdelta.red = cdelta.green = cdelta.blue = 80;
148 cdelta.alpha = 0;
149 ROperateLine(img, RAddOperation, 8, 8, 56, 8, &cdelta);
150 ROperateLine(img, RAddOperation, 8, 9, 8, 56, &cdelta);
151 cdelta.red = cdelta.green = cdelta.blue = 40;
152 cdelta.alpha = 0;
153 ROperateLine(img, RSubtractOperation, 8, 56, 56, 56, &cdelta);
154 ROperateLine(img, RSubtractOperation, 56, 8, 56, 55, &cdelta);
155 RReleaseImage(tile);
156 tmp = RCloneImage(img);
157
158 /* Draw some solid lines over the icon */
159 color.red = 0xff;
160 color.green = 0x7d;
161 color.blue = 0x52;
162 color.alpha = 0xff;
163 for (i = 16; i < 24; i++) {
164 RDrawLine(img, 9, i, 55, i, &color);
165 }
166
167 /* Also try some lines with alpha over the icon */
168 color.alpha = 0x80;
169 for (i = 40; i < 48; i++) {
170 RDrawLine(img, 9, i, 55, i, &color);
171 }
172
173 RConvertImage(ctx, img, &pix);
174 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 0, 192);
175
176 RReleaseImage(img);
177
178 /* Restore the image with the icon, and alter some lines */
179 img = tmp;
180 cdelta.red = cdelta.green = cdelta.blue = 80;
181 cdelta.alpha = 0;
182 for (i = 16; i < 24; i++) {
183 ROperateLine(img, RSubtractOperation, 9, i, 55, i, &cdelta);
184 }
185 cdelta.red = cdelta.green = cdelta.blue = 80;
186 for (i = 40; i < 48; i++) {
187 ROperateLine(img, RAddOperation, 9, i, 55, i, &cdelta);
188 }
189
190 RConvertImage(ctx, img, &pix);
191 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 64, 192);
192
193 XSetWindowBackgroundPixmap(dpy, win, back);
194 XMapRaised(dpy, win);
195 XClearWindow(dpy, win);
196 XFlush(dpy);
197 }
198
199 void testBevel()
200 {
201 RImage *img, *tile;
202 RColor color, from, to;
203 XSetWindowAttributes val;
204 Pixmap pix, back;
205 Window win;
206
207 val.background_pixel = ctx->black;
208 val.colormap = ctx->cmap;
209 win = XCreateWindow(dpy, DefaultRootWindow(dpy), 10, 10, 140, 140,
210 0, ctx->depth, InputOutput, ctx->visual, CWColormap | CWBackPixel, &val);
211 back = XCreatePixmap(ctx->dpy, ctx->drawable, 140, 140, ctx->depth);
212
213 /* Standard gray tile gradient */
214 from.red = 0xa6;
215 from.green = 0xa6;
216 from.blue = 0xb6;
217 from.alpha = 0xff;
218 to.red = 0x51;
219 to.green = 0x55;
220 to.blue = 0x61;
221 to.alpha = 0xff;
222
223 /* Dark blue tile gradient */
224 /*from.red = 0x28;
225 from.green = 0x45;
226 from.blue = 0x69;
227 from.alpha = 0xff;
228 to.red = 0x08;
229 to.green = 0x24;
230 to.blue = 0x20;
231 to.alpha = 0xff; */
232
233 /* Create Background */
234 img = RCreateImage(140, 140, True);
235 color.red = 0x28;
236 color.green = 0x45;
237 color.blue = 0x69;
238 color.alpha = 0xff;
239 RClearImage(img, &color);
240 RConvertImage(ctx, img, &pix);
241 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 140, 140, 0, 0);
242 RReleaseImage(img);
243
244 tile = RRenderGradient(64, 64, &from, &to, RGRD_DIAGONAL);
245
246 img = RCloneImage(tile);
247 RBevelImage(img, RBEV_SUNKEN);
248 RConvertImage(ctx, img, &pix);
249 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 3, 3);
250 RReleaseImage(img);
251
252 img = RCloneImage(tile);
253 RBevelImage(img, RBEV_RAISED);
254 RConvertImage(ctx, img, &pix);
255 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 73, 3);
256 RReleaseImage(img);
257
258 img = RCloneImage(tile);
259 RBevelImage(img, RBEV_RAISED2);
260 RConvertImage(ctx, img, &pix);
261 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 3, 73);
262 RReleaseImage(img);
263
264 img = RCloneImage(tile);
265 RBevelImage(img, RBEV_RAISED3);
266 RConvertImage(ctx, img, &pix);
267 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 73, 73);
268 RReleaseImage(img);
269
270 XSetWindowBackgroundPixmap(dpy, win, back);
271 XMapRaised(dpy, win);
272 XClearWindow(dpy, win);
273 XFlush(dpy);
274 }
275
276 void testScale()
277 {
278 RImage *image;
279 RImage *scaled;
280 XSetWindowAttributes val;
281 Pixmap pix;
282 Window win;
283
284 val.background_pixel = ctx->black;
285 val.colormap = ctx->cmap;
286 win = XCreateWindow(dpy, DefaultRootWindow(dpy), 10, 10, 140, 140,
287 0, ctx->depth, InputOutput, ctx->visual, CWColormap | CWBackPixel, &val);
288 XStoreName(dpy, win, "Scale");
289 pix = XCreatePixmap(ctx->dpy, ctx->drawable, 140, 140, ctx->depth);
290
291 image = RLoadImage(ctx, "ballot_box.xpm", 0);
292 if (!image) {
293 puts("couldnt load ballot_box.xpm");
294 return;
295 }
296
297 scaled = RScaleImage(image, 140, 140);
298
299 RReleaseImage(image);
300 RConvertImage(ctx, scaled, &pix);
301 XSetWindowBackgroundPixmap(dpy, win, pix);
302 XMapRaised(dpy, win);
303 XClearWindow(dpy, win);
304 XFlush(dpy);
305 }
306
307 void testRotate()
308 {
309
310 RImage *image;
311 RImage *rotated;
312 XSetWindowAttributes val;
313 Pixmap pix;
314 Window win;
315
316 image = RLoadImage(ctx, "ballot_box.xpm", 0);
317 if (!image) {
318 puts("couldnt load ballot_box.xpm");
319 return;
320 }
321
322 image = RScaleImage(image, 90, 180);
323
324 val.background_pixel = ctx->black;
325 val.colormap = ctx->cmap;
326 win = XCreateWindow(dpy, DefaultRootWindow(dpy), 10, 10, image->height,
327 image->width, 0, ctx->depth, InputOutput, ctx->visual, CWColormap | CWBackPixel, &val);
328 XStoreName(dpy, win, "Rotate");
329 pix = XCreatePixmap(ctx->dpy, ctx->drawable, image->height, image->width, ctx->depth);
330
331 rotated = RRotateImage(image, 90.0);
332
333 RReleaseImage(image);
334 RConvertImage(ctx, rotated, &pix);
335 XSetWindowBackgroundPixmap(dpy, win, pix);
336 XMapRaised(dpy, win);
337 XClearWindow(dpy, win);
338 XFlush(dpy);
339 }
340
341 void drawClip()
342 {
343 RImage *img;
344 RColor color, from, to, tmp;
345 RColor cdelta, cdelta1;
346 RSegment segs[20];
347 XSetWindowAttributes val;
348 Pixmap pix, back;
349 Window win;
350
351 val.background_pixel = ctx->black;
352 val.colormap = ctx->cmap;
353 win = XCreateWindow(dpy, DefaultRootWindow(dpy), 10, 10, 64, 64,
354 0, ctx->depth, InputOutput, ctx->visual, CWColormap | CWBackPixel, &val);
355 back = XCreatePixmap(ctx->dpy, ctx->drawable, 64, 64, ctx->depth);
356
357 /* Standard gray tile gradient */
358 from.red = 0xa6;
359 from.green = 0xa6;
360 from.blue = 0xb6;
361 from.alpha = 0xff;
362 to.red = 0x51;
363 to.green = 0x55;
364 to.blue = 0x61;
365 to.alpha = 0xff;
366
367 /* Dark blue tile gradient */
368 from.red = 0x28;
369 from.green = 0x45;
370 from.blue = 0x69;
371 from.alpha = 0xff;
372 to.red = 0x08;
373 to.green = 0x24;
374 to.blue = 0x20;
375 to.alpha = 0xff;
376
377 img = RRenderGradient(64, 64, &from, &to, RGRD_DIAGONAL);
378
379 RBevelImage(img, RBEV_RAISED3);
380 #if 1
381 color.alpha = 255;
382 color.red = color.green = color.blue = 0;
383
384 cdelta.alpha = 0;
385 cdelta.red = cdelta.green = cdelta.blue = 80;
386
387 cdelta1.alpha = 0;
388 cdelta1.red = cdelta1.green = cdelta1.blue = 40;
389
390 segs[0].x1 = segs[2].y1 = segs[4].x1 = segs[4].x2 = 63 - 21;
391 segs[0].x2 = segs[2].y2 = segs[1].x2 = segs[3].y2 = 63 - 2;
392 segs[0].y1 = segs[2].x1 = segs[1].y1 = segs[3].x1 = 2;
393 segs[0].y2 = segs[2].x2 = segs[6].x1 = segs[6].x2 = 21;
394 segs[1].x1 = segs[3].y1 = segs[5].x1 = segs[5].x2 = 63 - 22;
395 segs[1].y2 = segs[3].x2 = segs[7].x1 = segs[7].x2 = 22;
396
397 segs[4].y1 = segs[5].y1 = segs[10].x1 = segs[11].x1 = 0;
398 segs[4].y2 = segs[5].y2 = segs[10].x2 = segs[11].x2 = 1;
399 segs[6].y1 = segs[7].y1 = segs[8].x1 = segs[9].x1 = 63 - 1;
400 segs[6].y2 = segs[7].y2 = segs[8].x2 = segs[9].x2 = 63;
401 segs[8].y1 = segs[8].y2 = 21;
402 segs[9].y1 = segs[9].y2 = 22;
403 segs[10].y1 = segs[10].y2 = 63 - 21;
404 segs[11].y1 = segs[11].y2 = 63 - 22;
405 /* Black segments */
406 RDrawSegments(img, segs, 12, &color);
407
408 segs[0].x1 = segs[3].y1 = 63 - 20;
409 segs[0].x2 = segs[1].y2 = segs[2].x2 = segs[3].y2 = 63 - 2;
410 segs[0].y1 = segs[1].x1 = segs[2].y1 = segs[3].x1 = 2;
411 segs[1].y1 = segs[2].x1 = 63 - 23;
412 segs[0].y2 = segs[3].x2 = 20;
413 segs[1].x2 = segs[2].y2 = 23;
414 /* Bevels arround black segments */
415 ROperateSegments(img, RAddOperation, segs, 2, &cdelta);
416 ROperateSegments(img, RSubtractOperation, &segs[2], 2, &cdelta1);
417
418 RGetPixel(img, 63 - 2, 20, &tmp);
419 /*RPutPixel(img, 63-1, 23, &tmp); */
420 RDrawLine(img, 63 - 1, 23, 63, 23, &tmp);
421 RGetPixel(img, 63 - 23, 2, &tmp);
422 RDrawLine(img, 63 - 23, 0, 63 - 23, 1, &tmp);
423
424 RGetPixel(img, 23, 63 - 2, &tmp);
425 /*RPutPixel(img, 23, 63-1, &tmp); */
426 RDrawLine(img, 23, 63 - 1, 23, 63, &tmp);
427 RGetPixel(img, 2, 63 - 20, &tmp);
428 RDrawLine(img, 0, 63 - 23, 1, 63 - 23, &tmp);
429 #else
430 color.alpha = 255;
431 color.red = color.green = color.blue = 0;
432
433 cdelta.alpha = 0;
434 cdelta.red = cdelta.green = cdelta.blue = 80;
435
436 cdelta1.alpha = 0;
437 cdelta1.red = cdelta1.green = cdelta1.blue = 40;
438
439 RDrawLine(img, 63 - 21, 2, 63 - 2, 21, &color); /* upper 2 black lines */
440 ROperateLine(img, RAddOperation, 63 - 20, 2, 63 - 2, 20, &cdelta); /* the bevel arround them */
441 ROperateLine(img, RSubtractOperation, 63 - 22, 2, 63 - 2, 22, &cdelta1);
442 RDrawLine(img, 63 - 21, 0, 63 - 21, 1, &color); /* upper small black lines */
443 RDrawLine(img, 63 - 1, 21, 63, 21, &color);
444
445 RGetPixel(img, 63 - 2, 20, &tmp);
446 RPutPixel(img, 63 - 1, 22, &tmp);
447 RGetPixel(img, 2, 63 - 22, &tmp);
448 RDrawLine(img, 63 - 22, 0, 63 - 22, 1, &tmp);
449
450 RDrawLine(img, 2, 63 - 21, 21, 63 - 2, &color); /* lower 2 black lines */
451 ROperateLine(img, RSubtractOperation, 2, 63 - 20, 20, 63 - 2, &cdelta1); /* the bevel arround them */
452 ROperateLine(img, RAddOperation, 2, 63 - 22, 22, 63 - 2, &cdelta);
453 RDrawLine(img, 21, 63 - 1, 21, 63, &color); /* lower small black lines */
454 RDrawLine(img, 0, 63 - 21, 1, 63 - 21, &color);
455 ROperateLine(img, RAddOperation, 22, 63 - 1, 22, 63, &cdelta);
456 /*ROperateLine(img, RAddOperation, 22, 63-1, 22, 63, &cdelta); *//* the bevel arround them */
457 ROperateLine(img, RSubtractOperation, 0, 63 - 22, 1, 63 - 22, &cdelta1);
458 #endif
459
460 RConvertImage(ctx, img, &pix);
461 XCopyArea(dpy, pix, back, ctx->copy_gc, 0, 0, 64, 64, 0, 0);
462 RReleaseImage(img);
463
464 XSetWindowBackgroundPixmap(dpy, win, back);
465 XMapRaised(dpy, win);
466 XClearWindow(dpy, win);
467 XFlush(dpy);
468 }
469
470 void benchmark()
471 {
472 RImage *img;
473 RColor color;
474 RColor cdelta;
475 double t1, t2, total, d1 = 0, d2 = 0, d3 = 0;
476 struct timeval timev;
477 int i, j;
478
479 puts("Starting benchmark");
480
481 gettimeofday(&timev, NULL);
482 t1 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
483
484 img = RCreateImage(1024, 768, True);
485
486 gettimeofday(&timev, NULL);
487 t2 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
488 total = t2 - t1;
489 printf("Image created in %f sec\n", total);
490
491 gettimeofday(&timev, NULL);
492 t1 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
493
494 color.red = 0x28;
495 color.green = 0x45;
496 color.blue = 0x69;
497 color.alpha = 0xff;
498 RClearImage(img, &color);
499
500 color.red = 0xff;
501 color.green = 0x7d;
502 color.blue = 0x52;
503 color.alpha = 0xff;
504 cdelta.red = cdelta.green = cdelta.blue = 80;
505 cdelta.alpha = 0;
506
507 gettimeofday(&timev, NULL);
508 t2 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
509 total = t2 - t1;
510 printf("Image filled in %f sec\n", total);
511
512 for (j = 1; j < 6; j++) {
513 printf("Pass %d...\n", j);
514 gettimeofday(&timev, NULL);
515 t1 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
516
517 color.alpha = 0xff;
518 for (i = 0; i < 10000; i++) {
519 RDrawLine(img, 0, i % 64, i % 64, 63, &color);
520 }
521
522 gettimeofday(&timev, NULL);
523 t2 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
524 total = t2 - t1;
525 printf("Drawing 10000 lines in %f sec\n", total);
526 d1 += total;
527
528 gettimeofday(&timev, NULL);
529 t1 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
530
531 color.alpha = 80;
532 for (i = 0; i < 10000; i++) {
533 RDrawLine(img, 0, i % 64, i % 64, 63, &color);
534 }
535
536 gettimeofday(&timev, NULL);
537 t2 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
538 total = t2 - t1;
539 printf("Drawing 10000 lines with alpha in %f sec\n", total);
540 d2 += total;
541
542 gettimeofday(&timev, NULL);
543 t1 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
544
545 for (i = 0; i < 10000; i++) {
546 ROperateLine(img, RAddOperation, 0, i % 64, i % 64, 63, &cdelta);
547 }
548
549 gettimeofday(&timev, NULL);
550 t2 = (double)timev.tv_sec + (((double)timev.tv_usec) / 1000000);
551 total = t2 - t1;
552 printf("Altering 10000 lines in %f sec\n", total);
553 d3 += total;
554 }
555 printf("Average: %f, %f, %f\n", d1 / 5, d2 / 5, d3 / 5);
556
557 RReleaseImage(img);
558 }
559
560 int main(int argc, char **argv)
561 {
562 RContextAttributes attr;
563 int visualID = -1;
564
565 ProgName = strrchr(argv[0], '/');
566 if (!ProgName)
567 ProgName = argv[0];
568 else
569 ProgName++;
570
571 dpy = XOpenDisplay("");
572 if (!dpy) {
573 puts("cant open display");
574 exit(1);
575 }
576
577 attr.flags = RC_RenderMode | RC_ColorsPerChannel;
578
579 attr.render_mode = RDitheredRendering;
580 attr.colors_per_channel = 4;
581
582 if (visualID >= 0) {
583 attr.flags |= RC_VisualID;
584 attr.visualid = visualID;
585 }
586
587 ctx = RCreateContext(dpy, DefaultScreen(dpy), &attr);
588
589 if (!ctx) {
590 printf("could not initialize graphics library context: %s\n", RMessageForError(RErrorCode));
591 exit(1);
592 }
593
594 /* Here are the things we want to test */
595 testDraw();
596
597 testBevel();
598
599 drawClip();
600
601 testScale();
602
603 testRotate();
604
605 /* benchmark(); */
606
607 getchar();
608 return 0;
609 }