← Back to branch summary

~profzoom/ubuntu/quantal/wmaker/bug-1079925

« back to all changes in this revision

Viewing changes to wrlib/testdraw.c

  • Committer: Bazaar Package Importer
  • Author(s): Marcelo E. Magallon
  • Date: 2004-11-10 14:05:30 UTC
  • Revision ID: james.westby@ubuntu.com-20041110140530-qpd66b5lm38x7apk
Tags: upstream-0.91.0
Import upstream version 0.91.0

Show diffs side-by-side

added added

removed removed

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