slight optimizations, and make the last 4 gradients work properly
[mikachu/openbox.git] / render / gradient.c
1 #include <glib.h>
2 #include "render.h"
3 #include "gradient.h"
4 #include "../kernel/openbox.h"
5 #include "color.h"
6
7 void gradient_render(Surface *sf, int w, int h)
8 {
9     pixel32 *data = sf->pixel_data;
10     pixel32 current;
11     unsigned int r,g,b;
12     int off, x;
13
14     switch (sf->grad) {
15     case Background_Solid: /* already handled */
16         return;
17     case Background_Vertical:
18         gradient_vertical(sf, w, h);
19         break;
20     case Background_Horizontal:
21         gradient_horizontal(sf, w, h);
22         break;
23     case Background_Diagonal:
24         gradient_diagonal(sf, w, h);
25         break;
26     case Background_CrossDiagonal:
27         gradient_crossdiagonal(sf, w, h);
28         break;
29     case Background_Pyramid:
30         gradient_pyramid(sf, w, h);
31         break;
32     case Background_PipeCross:
33         gradient_pipecross(sf, w, h);
34         break;
35     case Background_Rectangle:
36         gradient_rectangle(sf, w, h);
37         break;
38     default:
39         g_message("unhandled gradient");
40         return;
41     }
42   
43     if (sf->relief == Flat && sf->border) {
44         r = sf->border_color->r;
45         g = sf->border_color->g;
46         b = sf->border_color->b;
47         current = (r << default_red_offset)
48             + (g << default_green_offset)
49             + (b << default_blue_offset);
50         for (off = 0, x = 0; x < w; ++x, off++) {
51             *(data + off) = current;
52             *(data + off + ((h-1) * w)) = current;
53         }
54         for (off = 0, x = 0; x < h; ++x, off++) {
55             *(data + (off * w)) = current;
56             *(data + (off * w) + w - 1) = current;
57         }
58     }
59
60     if (sf->relief != Flat) {
61         if (sf->bevel == Bevel1) {
62             for (off = 1, x = 1; x < w - 1; ++x, off++)
63                 highlight(data + off,
64                           data + off + (h-1) * w,
65                           sf->relief==Raised);
66             for (off = 0, x = 0; x < h; ++x, off++)
67                 highlight(data + off * w,
68                           data + off * w + w - 1,
69                           sf->relief==Raised);
70         }
71
72         if (sf->bevel == Bevel2) {
73             for (off = 2, x = 2; x < w - 2; ++x, off++)
74                 highlight(data + off + w,
75                           data + off + (h-2) * w,
76                           sf->relief==Raised);
77             for (off = 1, x = 1; x < h-1; ++x, off++)
78                 highlight(data + off * w + 1,
79                           data + off * w + w - 2,
80                           sf->relief==Raised);
81         }
82     }
83 }
84
85
86
87 void gradient_vertical(Surface *sf, int w, int h)
88 {
89     pixel32 *data = sf->pixel_data;
90     pixel32 current;
91     float dr, dg, db;
92     unsigned int r,g,b;
93     int x, y;
94
95     dr = (float)(sf->secondary->r - sf->primary->r);
96     dr/= (float)h;
97
98     dg = (float)(sf->secondary->g - sf->primary->g);
99     dg/= (float)h;
100
101     db = (float)(sf->secondary->b - sf->primary->b);
102     db/= (float)h;
103
104     for (y = 0; y < h; ++y) {
105         r = sf->primary->r + (int)(dr * y);
106         g = sf->primary->g + (int)(dg * y);
107         b = sf->primary->b + (int)(db * y);
108         current = (r << default_red_offset)
109             + (g << default_green_offset)
110             + (b << default_blue_offset);
111         for (x = 0; x < w; ++x, ++data)
112             *data = current;
113     }
114 }
115
116 void gradient_horizontal(Surface *sf, int w, int h)
117 {
118     pixel32 *data = sf->pixel_data;
119     pixel32 current;
120     float dr, dg, db;
121     unsigned int r,g,b;
122     int x, y;
123
124     dr = (float)(sf->secondary->r - sf->primary->r);
125     dr/= (float)w;
126
127     dg = (float)(sf->secondary->g - sf->primary->g);
128     dg/= (float)w;
129
130     db = (float)(sf->secondary->b - sf->primary->b);
131     db/= (float)w;
132
133     for (x = 0; x < w; ++x, ++data) {
134         r = sf->primary->r + (int)(dr * x);
135         g = sf->primary->g + (int)(dg * x);
136         b = sf->primary->b + (int)(db * x);
137         current = (r << default_red_offset)
138             + (g << default_green_offset)
139             + (b << default_blue_offset);
140         for (y = 0; y < h; ++y)
141             *(data + y*w) = current;
142     }
143 }
144
145 void gradient_diagonal(Surface *sf, int w, int h)
146 {
147     pixel32 *data = sf->pixel_data;
148     pixel32 current;
149     float drx, dgx, dbx, dry, dgy, dby;
150     unsigned int r,g,b;
151     int x, y;
152
153     for (y = 0; y < h; ++y) {
154         drx = (float)(sf->secondary->r -
155                       sf->primary->r);
156         dry = drx/(float)h;
157         drx/= (float)w;
158
159         dgx = (float)(sf->secondary->g -
160                       sf->primary->g);
161         dgy = dgx/(float)h;
162         dgx/= (float)w;
163
164         dbx = (float)(sf->secondary->b -
165                       sf->primary->b);
166         dby = dbx/(float)h;
167         dbx/= (float)w;
168         for (x = 0; x < w; ++x, ++data) {
169             r = sf->primary->r +
170                 ((int)(drx * x) + (int)(dry * y))/2;
171             g = sf->primary->g +
172                 ((int)(dgx * x) + (int)(dgy * y))/2;
173             b = sf->primary->b +
174                 ((int)(dbx * x) + (int)(dby * y))/2;
175             current = (r << default_red_offset)
176                 + (g << default_green_offset)
177                 + (b << default_blue_offset);
178             *data = current;
179         }
180     }
181 }
182
183 void gradient_crossdiagonal(Surface *sf, int w, int h)
184 {
185     pixel32 *data = sf->pixel_data;
186     pixel32 current;
187     float drx, dgx, dbx, dry, dgy, dby;
188     unsigned int r,g,b;
189     int x, y;
190
191     for (y = 0; y < h; ++y) {
192         drx = (float)(sf->secondary->r -
193                       sf->primary->r);
194         dry = drx/(float)h;
195         drx/= (float)w;
196
197         dgx = (float)(sf->secondary->g -
198                       sf->primary->g);
199         dgy = dgx/(float)h;
200         dgx/= (float)w;
201
202         dbx = (float)(sf->secondary->b -
203                       sf->primary->b);
204         dby = dbx/(float)h;
205         dbx/= (float)w;
206         for (x = w; x > 0; --x, ++data) {
207             r = sf->primary->r +
208                 ((int)(drx * (x-1)) + (int)(dry * y))/2;
209             g = sf->primary->g +
210                 ((int)(dgx * (x-1)) + (int)(dgy * y))/2;
211             b = sf->primary->b +
212                 ((int)(dbx * (x-1)) + (int)(dby * y))/2;
213             current = (r << default_red_offset)
214                 + (g << default_green_offset)
215                 + (b << default_blue_offset);
216             *data = current;
217         }
218     }
219 }
220
221 void highlight(pixel32 *x, pixel32 *y, gboolean raised)
222 {
223     int r, g, b;
224
225     pixel32 *up, *down;
226     if (raised) {
227         up = x;
228         down = y;
229     } else {
230         up = y;
231         down = x;
232     }
233     r = (*up >> default_red_offset) & 0xFF;
234     r += r >> 1;
235     g = (*up >> default_green_offset) & 0xFF;
236     g += g >> 1;
237     b = (*up >> default_blue_offset) & 0xFF;
238     b += b >> 1;
239     if (r > 0xFF) r = 0xFF;
240     if (g > 0xFF) g = 0xFF;
241     if (b > 0xFF) b = 0xFF;
242     *up = (r << default_red_offset) + (g << default_green_offset)
243         + (b << default_blue_offset);
244   
245     r = (*down >> default_red_offset) & 0xFF;
246     r = (r >> 1) + (r >> 2);
247     g = (*down >> default_green_offset) & 0xFF;
248     g = (g >> 1) + (g >> 2);
249     b = (*down >> default_blue_offset) & 0xFF;
250     b = (b >> 1) + (b >> 2);
251     *down = (r << default_red_offset) + (g << default_green_offset)
252         + (b << default_blue_offset);
253 }
254
255 static void create_bevel_colors(Appearance *l)
256 {
257     int r, g, b;
258
259     /* light color */
260     r = l->surface.primary->r;
261     r += r >> 1;
262     g = l->surface.primary->g;
263     g += g >> 1;
264     b = l->surface.primary->b;
265     b += b >> 1;
266     if (r > 0xFF) r = 0xFF;
267     if (g > 0xFF) g = 0xFF;
268     if (b > 0xFF) b = 0xFF;
269     g_assert(!l->surface.bevel_light);
270     l->surface.bevel_light = color_new(r, g, b);
271     color_allocate_gc(l->surface.bevel_light);
272
273     /* dark color */
274     r = l->surface.primary->r;
275     r = (r >> 1) + (r >> 2);
276     g = l->surface.primary->g;
277     g = (g >> 1) + (g >> 2);
278     b = l->surface.primary->b;
279     b = (b >> 1) + (b >> 2);
280     g_assert(!l->surface.bevel_dark);
281     l->surface.bevel_dark = color_new(r, g, b);
282     color_allocate_gc(l->surface.bevel_dark);
283 }
284
285 void gradient_solid(Appearance *l, int x, int y, int w, int h) 
286 {
287     pixel32 pix;
288     int i, a, b;
289     Surface *sp = &l->surface;
290     int left = x, top = y, right = x + w - 1, bottom = y + h - 1;
291
292     if (sp->primary->gc == None)
293         color_allocate_gc(sp->primary);
294     pix = (sp->primary->r << default_red_offset)
295         + (sp->primary->g << default_green_offset)
296         + (sp->primary->b << default_blue_offset);
297
298     for (a = 0; a < l->area.width; a++)
299         for (b = 0; b < l->area.height; b++)
300             sp->pixel_data[a + b*l->area.width] = pix;
301
302     XFillRectangle(ob_display, l->pixmap, sp->primary->gc,
303                    x, y, w, h);
304
305     if (sp->interlaced) {
306         if (sp->secondary->gc == None)
307             color_allocate_gc(sp->secondary);
308         for (i = y; i < h; i += 2)
309             XDrawLine(ob_display, l->pixmap, sp->secondary->gc,
310                       x, i, w, i);
311     }
312
313     switch (sp->relief) {
314     case Raised:
315         if (!sp->bevel_dark)
316             create_bevel_colors(l);
317
318         switch (sp->bevel) {
319         case Bevel1:
320             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
321                       left, bottom, right, bottom);
322             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
323                       right, bottom, right, top);
324                 
325             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
326                       left, top, right, top);
327             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
328                       left, bottom, left, top);
329             break;
330         case Bevel2:
331             XDrawLine(ob_display, l->pixmap,
332                       sp->bevel_dark->gc,
333                       left + 1, bottom - 2, right - 2, bottom - 2);
334             XDrawLine(ob_display, l->pixmap,
335                       sp->bevel_dark->gc,
336                       right - 2, bottom - 2, right - 2, top + 1);
337
338             XDrawLine(ob_display, l->pixmap,
339                       sp->bevel_light->gc,
340                       left + 1, top + 1, right - 2, top + 1);
341             XDrawLine(ob_display, l->pixmap,
342                       sp->bevel_light->gc,
343                       left + 1, bottom - 2, left + 1, top + 1);
344             break;
345         default:
346             g_assert_not_reached(); /* unhandled BevelType */
347         }
348         break;
349     case Sunken:
350         if (!sp->bevel_dark)
351             create_bevel_colors(l);
352
353         switch (sp->bevel) {
354         case Bevel1:
355             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
356                       left, bottom, right, bottom);
357             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
358                       right, bottom, right, top);
359       
360             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
361                       left, top, right, top);
362             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
363                       left, bottom, left, top);
364             break;
365         case Bevel2:
366             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
367                       left + 1, bottom - 2, right - 2, bottom - 2);
368             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
369                       right - 2, bottom - 2, right - 2, top + 1);
370       
371             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
372                       left + 1, top + 1, right - 2, top + 1);
373             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
374                       left + 1, bottom - 2, left + 1, top + 1);
375
376             break;
377         default:
378             g_assert_not_reached(); /* unhandled BevelType */
379         }
380         break;
381     case Flat:
382         if (sp->border) {
383             if (sp->border_color->gc == None)
384                 color_allocate_gc(sp->border_color);
385             XDrawRectangle(ob_display, l->pixmap, sp->border_color->gc,
386                            left, top, right, bottom);
387         }
388         break;
389     default:  
390         g_assert_not_reached(); /* unhandled ReliefType */
391     }
392 }
393
394 void gradient_pyramid(Surface *sf, int inw, int inh)
395 {
396     pixel32 *data = sf->pixel_data;
397     pixel32 *end = data + inw*inh - 1;
398     pixel32 current;
399     float drx, dgx, dbx, dry, dgy, dby;
400     unsigned int r,g,b;
401     int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
402
403     drx = (float)(sf->secondary->r -
404                   sf->primary->r);
405     dry = drx/(float)h;
406     drx/= (float)w;
407
408     dgx = (float)(sf->secondary->g -
409                   sf->primary->g);
410     dgy = dgx/(float)h;
411     dgx/= (float)w;
412
413     dbx = (float)(sf->secondary->b -
414                   sf->primary->b);
415     dby = dbx/(float)h;
416     dbx/= (float)w;
417
418     for (y = 0; y < h; ++y) {
419         for (x = 0; x < w; ++x, data) {
420             r = sf->primary->r +
421                 ((int)(drx * x) + (int)(dry * y))/2;
422             g = sf->primary->g +
423                 ((int)(dgx * x) + (int)(dgy * y))/2;
424             b = sf->primary->b +
425                 ((int)(dbx * x) + (int)(dby * y))/2;
426             current = (r << default_red_offset)
427                 + (g << default_green_offset)
428                 + (b << default_blue_offset);
429             *(data+x) = current;
430             *(data+inw-x) = current;
431             *(end-x) = current;
432             *(end-(inw-x)) = current;
433         }
434         data+=inw;
435         end-=inw;
436     }
437 }
438
439 void gradient_rectangle(Surface *sf, int inw, int inh)
440 {
441     pixel32 *data = sf->pixel_data;
442     pixel32 *end = data + inw*inh - 1;
443     pixel32 current;
444     float drx, dgx, dbx, dry, dgy, dby;
445     unsigned int r,g,b;
446     int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
447
448     drx = (float)(sf->primary->r -
449                   sf->secondary->r);
450     dry = drx/(float)h;
451     drx/= (float)w;
452
453     dgx = (float)(sf->primary->g -
454                   sf->secondary->g);
455     dgy = dgx/(float)h;
456     dgx/= (float)w;
457
458     dbx = (float)(sf->primary->b -
459                   sf->secondary->b);
460     dby = dbx/(float)h;
461     dbx/= (float)w;
462
463     for (y = 0; y < h; ++y) {
464         for (x = 0; x < w; ++x, data) {
465             if ((float)x/(float)w < (float)y/(float)h) {
466                 r = sf->primary->r + (drx * x);
467                 g = sf->primary->g + (dgx * x);
468                 b = sf->primary->b + (dbx * x);
469             } else {
470                 r = sf->primary->r + (dry * x);
471                 g = sf->primary->g + (dgy * x);
472                 b = sf->primary->b + (dby * x);
473             }
474             current = (r << default_red_offset)
475                 + (g << default_green_offset)
476                 + (b << default_blue_offset);
477             *(data+x) = current;
478             *(data+inw-x) = current;
479             *(end-x) = current;
480             *(end-(inw-x)) = current;
481         }
482         data+=inw;
483         end-=inw;
484     }
485 }
486
487 void gradient_pipecross(Surface *sf, int inw, int inh)
488 {
489     pixel32 *data = sf->pixel_data;
490     pixel32 *end = data + inw*inh - 1;
491     pixel32 current;
492     float drx, dgx, dbx, dry, dgy, dby;
493     unsigned int r,g,b;
494     int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
495
496     drx = (float)(sf->secondary->r -
497                   sf->primary->r);
498     dry = drx/(float)h;
499     drx/= (float)w;
500
501     dgx = (float)(sf->secondary->g -
502                   sf->primary->g);
503     dgy = dgx/(float)h;
504     dgx/= (float)w;
505
506     dbx = (float)(sf->secondary->b -
507                   sf->primary->b);
508     dby = dbx/(float)h;
509     dbx/= (float)w;
510
511     for (y = 0; y < h; ++y) {
512         for (x = 0; x < w; ++x, data) {
513             if ((float)x/(float)w > (float)y/(float)h) {
514                 r = sf->primary->r + (drx * x);
515                 g = sf->primary->g + (dgx * x);
516                 b = sf->primary->b + (dbx * x);
517             } else {
518                 r = sf->primary->r + (dry * x);
519                 g = sf->primary->g + (dgy * x);
520                 b = sf->primary->b + (dby * x);
521             }
522             current = (r << default_red_offset)
523                 + (g << default_green_offset)
524                 + (b << default_blue_offset);
525             *(data+x) = current;
526             *(data+inw-x) = current;
527             *(end-x) = current;
528             *(end-(inw-x)) = current;
529         }
530         data+=inw;
531         end-=inw;
532     }
533 }