remove non-planar surfaces
[mikachu/openbox.git] / render / gradient.c
1 #ifdef USE_GL
2 #include <GL/gl.h>
3 #endif /* USE_GL */
4 #include <glib.h>
5 #include "render.h"
6 #include "gradient.h"
7 #include "../kernel/openbox.h"
8 #include "color.h"
9
10 void gradient_render(Surface *sf, int w, int h)
11 {
12     pixel32 *data = sf->pixel_data;
13     pixel32 current;
14     unsigned int r,g,b;
15     int off, x;
16
17     switch (sf->grad) {
18     case Background_Solid: /* already handled */
19         return;
20     case Background_Vertical:
21         gradient_vertical(sf, w, h);
22         break;
23     case Background_Horizontal:
24         gradient_horizontal(sf, w, h);
25         break;
26     case Background_Diagonal:
27         gradient_diagonal(sf, w, h);
28         break;
29     case Background_CrossDiagonal:
30         gradient_crossdiagonal(sf, w, h);
31         break;
32     case Background_Pyramid:
33         gradient_pyramid(sf, w, h);
34         break;
35     case Background_PipeCross:
36         gradient_pipecross(sf, w, h);
37         break;
38     case Background_Rectangle:
39         gradient_rectangle(sf, w, h);
40         break;
41     default:
42         g_message("unhandled gradient");
43         return;
44     }
45   
46     if (sf->relief == Flat && sf->border) {
47         r = sf->border_color->r;
48         g = sf->border_color->g;
49         b = sf->border_color->b;
50         current = (r << default_red_offset)
51             + (g << default_green_offset)
52             + (b << default_blue_offset);
53         for (off = 0, x = 0; x < w; ++x, off++) {
54             *(data + off) = current;
55             *(data + off + ((h-1) * w)) = current;
56         }
57         for (off = 0, x = 0; x < h; ++x, off++) {
58             *(data + (off * w)) = current;
59             *(data + (off * w) + w - 1) = current;
60         }
61     }
62
63     if (sf->relief != Flat) {
64         if (sf->bevel == Bevel1) {
65             for (off = 1, x = 1; x < w - 1; ++x, off++)
66                 highlight(data + off,
67                           data + off + (h-1) * w,
68                           sf->relief==Raised);
69             for (off = 0, x = 0; x < h; ++x, off++)
70                 highlight(data + off * w,
71                           data + off * w + w - 1,
72                           sf->relief==Raised);
73         }
74
75         if (sf->bevel == Bevel2) {
76             for (off = 2, x = 2; x < w - 2; ++x, off++)
77                 highlight(data + off + w,
78                           data + off + (h-2) * w,
79                           sf->relief==Raised);
80             for (off = 1, x = 1; x < h-1; ++x, off++)
81                 highlight(data + off * w + 1,
82                           data + off * w + w - 2,
83                           sf->relief==Raised);
84         }
85     }
86 }
87
88
89
90 void gradient_vertical(Surface *sf, int w, int h)
91 {
92     pixel32 *data = sf->pixel_data;
93     pixel32 current;
94     float dr, dg, db;
95     unsigned int r,g,b;
96     int x, y;
97
98     dr = (float)(sf->secondary->r - sf->primary->r);
99     dr/= (float)h;
100
101     dg = (float)(sf->secondary->g - sf->primary->g);
102     dg/= (float)h;
103
104     db = (float)(sf->secondary->b - sf->primary->b);
105     db/= (float)h;
106
107     for (y = 0; y < h; ++y) {
108         r = sf->primary->r + (int)(dr * y);
109         g = sf->primary->g + (int)(dg * y);
110         b = sf->primary->b + (int)(db * y);
111         current = (r << default_red_offset)
112             + (g << default_green_offset)
113             + (b << default_blue_offset);
114         for (x = 0; x < w; ++x, ++data)
115             *data = current;
116     }
117 }
118
119 void gradient_horizontal(Surface *sf, int w, int h)
120 {
121     pixel32 *data = sf->pixel_data;
122     pixel32 current;
123     float dr, dg, db;
124     unsigned int r,g,b;
125     int x, y;
126
127     dr = (float)(sf->secondary->r - sf->primary->r);
128     dr/= (float)w;
129
130     dg = (float)(sf->secondary->g - sf->primary->g);
131     dg/= (float)w;
132
133     db = (float)(sf->secondary->b - sf->primary->b);
134     db/= (float)w;
135
136     for (x = 0; x < w; ++x, ++data) {
137         r = sf->primary->r + (int)(dr * x);
138         g = sf->primary->g + (int)(dg * x);
139         b = sf->primary->b + (int)(db * x);
140         current = (r << default_red_offset)
141             + (g << default_green_offset)
142             + (b << default_blue_offset);
143         for (y = 0; y < h; ++y)
144             *(data + y*w) = current;
145     }
146 }
147
148 void gradient_diagonal(Surface *sf, int w, int h)
149 {
150     pixel32 *data = sf->pixel_data;
151     pixel32 current;
152     float drx, dgx, dbx, dry, dgy, dby;
153     unsigned int r,g,b;
154     int x, y;
155
156     for (y = 0; y < h; ++y) {
157         drx = (float)(sf->secondary->r -
158                       sf->primary->r);
159         dry = drx/(float)h;
160         drx/= (float)w;
161
162         dgx = (float)(sf->secondary->g -
163                       sf->primary->g);
164         dgy = dgx/(float)h;
165         dgx/= (float)w;
166
167         dbx = (float)(sf->secondary->b -
168                       sf->primary->b);
169         dby = dbx/(float)h;
170         dbx/= (float)w;
171         for (x = 0; x < w; ++x, ++data) {
172             r = sf->primary->r +
173                 ((int)(drx * x) + (int)(dry * y))/2;
174             g = sf->primary->g +
175                 ((int)(dgx * x) + (int)(dgy * y))/2;
176             b = sf->primary->b +
177                 ((int)(dbx * x) + (int)(dby * y))/2;
178             current = (r << default_red_offset)
179                 + (g << default_green_offset)
180                 + (b << default_blue_offset);
181             *data = current;
182         }
183     }
184 }
185
186 void gradient_crossdiagonal(Surface *sf, int w, int h)
187 {
188     pixel32 *data = sf->pixel_data;
189     pixel32 current;
190     float drx, dgx, dbx, dry, dgy, dby;
191     unsigned int r,g,b;
192     int x, y;
193
194     for (y = 0; y < h; ++y) {
195         drx = (float)(sf->secondary->r -
196                       sf->primary->r);
197         dry = drx/(float)h;
198         drx/= (float)w;
199
200         dgx = (float)(sf->secondary->g -
201                       sf->primary->g);
202         dgy = dgx/(float)h;
203         dgx/= (float)w;
204
205         dbx = (float)(sf->secondary->b -
206                       sf->primary->b);
207         dby = dbx/(float)h;
208         dbx/= (float)w;
209         for (x = w; x > 0; --x, ++data) {
210             r = sf->primary->r +
211                 ((int)(drx * (x-1)) + (int)(dry * y))/2;
212             g = sf->primary->g +
213                 ((int)(dgx * (x-1)) + (int)(dgy * y))/2;
214             b = sf->primary->b +
215                 ((int)(dbx * (x-1)) + (int)(dby * y))/2;
216             current = (r << default_red_offset)
217                 + (g << default_green_offset)
218                 + (b << default_blue_offset);
219             *data = current;
220         }
221     }
222 }
223
224 void highlight(pixel32 *x, pixel32 *y, gboolean raised)
225 {
226     int r, g, b;
227
228     pixel32 *up, *down;
229     if (raised) {
230         up = x;
231         down = y;
232     } else {
233         up = y;
234         down = x;
235     }
236     r = (*up >> default_red_offset) & 0xFF;
237     r += r >> 1;
238     g = (*up >> default_green_offset) & 0xFF;
239     g += g >> 1;
240     b = (*up >> default_blue_offset) & 0xFF;
241     b += b >> 1;
242     if (r > 0xFF) r = 0xFF;
243     if (g > 0xFF) g = 0xFF;
244     if (b > 0xFF) b = 0xFF;
245     *up = (r << default_red_offset) + (g << default_green_offset)
246         + (b << default_blue_offset);
247   
248     r = (*down >> default_red_offset) & 0xFF;
249     r = (r >> 1) + (r >> 2);
250     g = (*down >> default_green_offset) & 0xFF;
251     g = (g >> 1) + (g >> 2);
252     b = (*down >> default_blue_offset) & 0xFF;
253     b = (b >> 1) + (b >> 2);
254     *down = (r << default_red_offset) + (g << default_green_offset)
255         + (b << default_blue_offset);
256 }
257
258 static void create_bevel_colors(Appearance *l)
259 {
260     int r, g, b;
261
262     /* light color */
263     r = l->surface.primary->r;
264     r += r >> 1;
265     g = l->surface.primary->g;
266     g += g >> 1;
267     b = l->surface.primary->b;
268     b += b >> 1;
269     if (r > 0xFF) r = 0xFF;
270     if (g > 0xFF) g = 0xFF;
271     if (b > 0xFF) b = 0xFF;
272     g_assert(!l->surface.bevel_light);
273     l->surface.bevel_light = color_new(r, g, b);
274     color_allocate_gc(l->surface.bevel_light);
275
276     /* dark color */
277     r = l->surface.primary->r;
278     r = (r >> 1) + (r >> 2);
279     g = l->surface.primary->g;
280     g = (g >> 1) + (g >> 2);
281     b = l->surface.primary->b;
282     b = (b >> 1) + (b >> 2);
283     g_assert(!l->surface.bevel_dark);
284     l->surface.bevel_dark = color_new(r, g, b);
285     color_allocate_gc(l->surface.bevel_dark);
286 }
287
288 void gradient_solid(Appearance *l, int x, int y, int w, int h) 
289 {
290     pixel32 pix;
291     int i, a, b;
292     Surface *sp = &l->surface;
293     int left = x, top = y, right = x + w - 1, bottom = y + h - 1;
294
295     if (sp->primary->gc == None)
296         color_allocate_gc(sp->primary);
297     pix = (sp->primary->r << default_red_offset)
298         + (sp->primary->g << default_green_offset)
299         + (sp->primary->b << default_blue_offset);
300
301     for (a = 0; a < l->area.width; a++)
302         for (b = 0; b < l->area.height; b++)
303             sp->pixel_data[a + b*l->area.width] = pix;
304
305     XFillRectangle(ob_display, l->pixmap, sp->primary->gc,
306                    x, y, w, h);
307
308     if (sp->interlaced) {
309         if (sp->secondary->gc == None)
310             color_allocate_gc(sp->secondary);
311         for (i = y; i < h; i += 2)
312             XDrawLine(ob_display, l->pixmap, sp->secondary->gc,
313                       x, i, w, i);
314     }
315
316     switch (sp->relief) {
317     case Raised:
318         if (!sp->bevel_dark)
319             create_bevel_colors(l);
320
321         switch (sp->bevel) {
322         case Bevel1:
323             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
324                       left, bottom, right, bottom);
325             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
326                       right, bottom, right, top);
327                 
328             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
329                       left, top, right, top);
330             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
331                       left, bottom, left, top);
332             break;
333         case Bevel2:
334             XDrawLine(ob_display, l->pixmap,
335                       sp->bevel_dark->gc,
336                       left + 1, bottom - 2, right - 2, bottom - 2);
337             XDrawLine(ob_display, l->pixmap,
338                       sp->bevel_dark->gc,
339                       right - 2, bottom - 2, right - 2, top + 1);
340
341             XDrawLine(ob_display, l->pixmap,
342                       sp->bevel_light->gc,
343                       left + 1, top + 1, right - 2, top + 1);
344             XDrawLine(ob_display, l->pixmap,
345                       sp->bevel_light->gc,
346                       left + 1, bottom - 2, left + 1, top + 1);
347             break;
348         default:
349             g_assert_not_reached(); /* unhandled BevelType */
350         }
351         break;
352     case Sunken:
353         if (!sp->bevel_dark)
354             create_bevel_colors(l);
355
356         switch (sp->bevel) {
357         case Bevel1:
358             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
359                       left, bottom, right, bottom);
360             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
361                       right, bottom, right, top);
362       
363             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
364                       left, top, right, top);
365             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
366                       left, bottom, left, top);
367             break;
368         case Bevel2:
369             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
370                       left + 1, bottom - 2, right - 2, bottom - 2);
371             XDrawLine(ob_display, l->pixmap, sp->bevel_light->gc,
372                       right - 2, bottom - 2, right - 2, top + 1);
373       
374             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
375                       left + 1, top + 1, right - 2, top + 1);
376             XDrawLine(ob_display, l->pixmap, sp->bevel_dark->gc,
377                       left + 1, bottom - 2, left + 1, top + 1);
378
379             break;
380         default:
381             g_assert_not_reached(); /* unhandled BevelType */
382         }
383         break;
384     case Flat:
385         if (sp->border) {
386             if (sp->border_color->gc == None)
387                 color_allocate_gc(sp->border_color);
388             XDrawRectangle(ob_display, l->pixmap, sp->border_color->gc,
389                            left, top, right, bottom);
390         }
391         break;
392     default:  
393         g_assert_not_reached(); /* unhandled ReliefType */
394     }
395 }
396
397 void gradient_pyramid(Surface *sf, int inw, int inh)
398 {
399     pixel32 *data = sf->pixel_data;
400     pixel32 *end = data + inw*inh - 1;
401     pixel32 current;
402     float drx, dgx, dbx, dry, dgy, dby;
403     unsigned int r,g,b;
404     int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
405     for (y = 0; y < h; ++y) {
406         drx = (float)(sf->secondary->r -
407                       sf->primary->r);
408         dry = drx/(float)h;
409         drx/= (float)w;
410
411         dgx = (float)(sf->secondary->g -
412                       sf->primary->g);
413         dgy = dgx/(float)h;
414         dgx/= (float)w;
415
416         dbx = (float)(sf->secondary->b -
417                       sf->primary->b);
418         dby = dbx/(float)h;
419         dbx/= (float)w;
420         for (x = 0; x < w; ++x, data) {
421             r = sf->primary->r +
422                 ((int)(drx * x) + (int)(dry * y))/2;
423             g = sf->primary->g +
424                 ((int)(dgx * x) + (int)(dgy * y))/2;
425             b = sf->primary->b +
426                 ((int)(dbx * x) + (int)(dby * y))/2;
427             current = (r << default_red_offset)
428                 + (g << default_green_offset)
429                 + (b << default_blue_offset);
430             *(data+x) = current;
431             *(data+inw-x) = current;
432             *(end-x) = current;
433             *(end-(inw-x)) = current;
434         }
435         data+=inw;
436         end-=inw;
437     }
438 }
439
440 void gradient_rectangle(Surface *sf, int inw, int inh)
441 {
442     pixel32 *data = sf->pixel_data;
443     pixel32 *end = data + inw*inh - 1;
444     pixel32 current;
445     float drx, dgx, dbx, dry, dgy, dby;
446     unsigned int r,g,b;
447     int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
448     int val;
449
450     for (y = 0; y < h; ++y) {
451         drx = (float)(sf->primary->r -
452                       sf->secondary->r);
453         dry = drx/(float)h;
454         drx/= (float)w;
455
456         dgx = (float)(sf->primary->g -
457                       sf->secondary->g);
458         dgy = dgx/(float)h;
459         dgx/= (float)w;
460
461         dbx = (float)(sf->primary->b -
462                       sf->secondary->b);
463         dby = dbx/(float)h;
464         dbx/= (float)w;
465         for (x = 0; x < w; ++x, data) {
466             if ((float)x/(float)w < (float)y/(float)h) val = (int)(drx * x);
467             else val = (int)(dry * y);
468
469             r = sf->secondary->r + val;
470             g = sf->secondary->g + val;
471             b = sf->secondary->b + val;
472             current = (r << default_red_offset)
473                 + (g << default_green_offset)
474                 + (b << default_blue_offset);
475             *(data+x) = current;
476             *(data+inw-x) = current;
477             *(end-x) = current;
478             *(end-(inw-x)) = current;
479         }
480         data+=inw;
481         end-=inw;
482     }
483 }
484
485 void gradient_pipecross(Surface *sf, int inw, int inh)
486 {
487     pixel32 *data = sf->pixel_data;
488     pixel32 *end = data + inw*inh - 1;
489     pixel32 current;
490     float drx, dgx, dbx, dry, dgy, dby;
491     unsigned int r,g,b;
492     int x, y, h=(inh/2) + 1, w=(inw/2) + 1;
493     int val;
494
495     for (y = 0; y < h; ++y) {
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         for (x = 0; x < w; ++x, data) {
511             if ((float)x/(float)w > (float)y/(float)h) val = (int)(drx * x);
512             else val = (int)(dry * y);
513
514             r = sf->primary->r + val;
515             g = sf->primary->g + val;
516             b = sf->primary->b + val;
517             current = (r << default_red_offset)
518                 + (g << default_green_offset)
519                 + (b << default_blue_offset);
520             *(data+x) = current;
521             *(data+inw-x) = current;
522             *(end-x) = current;
523             *(end-(inw-x)) = current;
524         }
525         data+=inw;
526         end-=inw;
527     }
528 }
529 #ifdef USE_GL
530 void render_gl_gradient(Surface *sf, int x, int y, int w, int h)
531 {
532     float pr,pg,pb;
533     float sr, sg, sb;
534     float ar, ag, ab;
535
536     pr = (float)sf->primary->r/255.0;
537     pg = (float)sf->primary->g/255.0;
538     pb = (float)sf->primary->b/255.0;
539     if (sf->secondary) {
540         sr = (float)sf->secondary->r/255.0;
541         sg = (float)sf->secondary->g/255.0;
542         sb = (float)sf->secondary->b/255.0;
543     }
544     switch (sf->grad) {
545     case Background_Solid: /* already handled */
546         glBegin(GL_TRIANGLES);
547         glColor3f(pr, pg, pb);
548         glVertex2i(x, y);
549         glVertex2i(x+w, y);
550         glVertex2i(x+w, y+h);
551
552         glVertex2i(x+w, y+h);
553         glVertex2i(x, y+h);
554         glVertex2i(x, y);
555         glEnd();
556         return;
557     case Background_Horizontal:
558         glBegin(GL_TRIANGLES);
559         glColor3f(pr, pg, pb);
560         glVertex2i(x, y);
561         glColor3f(sr, sg, sb);
562         glVertex2i(x+w, y);
563         glVertex2i(x+w, y+h);
564
565         glVertex2i(x+w, y+h);
566         glColor3f(pr, pg, pb);
567         glVertex2i(x, y+h);
568         glVertex2i(x, y);
569         glEnd();
570         break;
571     case Background_Vertical:
572         glBegin(GL_TRIANGLES);
573         glColor3f(pr, pg, pb);
574         glVertex2i(x, y);
575         glVertex2i(x+w, y);
576         glColor3f(sr, sg, sb);
577         glVertex2i(x+w, y+h);
578
579         glVertex2i(x+w, y+h);
580         glVertex2i(x, y+h);
581         glColor3f(pr, pg, pb);
582         glVertex2i(x, y);
583         glEnd();
584         break;
585     case Background_Diagonal:
586         ar = (pr + sr) / 2.0;
587         ag = (pg + sg) / 2.0;
588         ab = (pb + sb) / 2.0;
589         glBegin(GL_TRIANGLES);
590         glColor3f(ar, ag, ab);
591         glVertex2i(x, y);
592         glColor3f(pr, pg, pb);
593         glVertex2i(x+w, y);
594         glColor3f(ar, ag, ab);
595         glVertex2i(x+w, y+h);
596
597         glColor3f(ar, ag, ab);
598         glVertex2i(x+w, y+h);
599         glColor3f(sr, sg, sb);
600         glVertex2i(x, y+h);
601         glColor3f(ar, ag, ab);
602         glVertex2i(x, y);
603         glEnd();
604         break;
605     case Background_CrossDiagonal:
606         ar = (pr + sr) / 2.0;
607         ag = (pg + sg) / 2.0;
608         ab = (pb + sb) / 2.0;
609         glBegin(GL_TRIANGLES);
610         glColor3f(pr, pg, pb);
611         glVertex2i(x, y);
612         glColor3f(ar, ag, ab);
613         glVertex2i(x+w, y);
614         glColor3f(sr, sg, sb);
615         glVertex2i(x+w, y+h);
616
617         glColor3f(sr, sg, sb);
618         glVertex2i(x+w, y+h);
619         glColor3f(ar, ag, ab);
620         glVertex2i(x, y+h);
621         glColor3f(pr, pg, pb);
622         glVertex2i(x, y);
623         glEnd();
624         break;
625     case Background_Pyramid:
626         ar = (pr + sr) / 2.0;
627         ag = (pg + sg) / 2.0;
628         ab = (pb + sb) / 2.0;
629         glBegin(GL_TRIANGLES);
630         glColor3f(pr, pg, pb);
631         glVertex2i(x, y);
632         glColor3f(sr, sg, sb);
633         glVertex2i(x+w/2, y+h/2);
634         glColor3f(ar, ag, ab);
635         glVertex2i(x, y+h/2);
636
637         glVertex2i(x, y+h/2);
638         glColor3f(sr, sg, sb);
639         glVertex2i(x+w/2, y+h/2);
640         glColor3f(pr, pg, pb);
641         glVertex2i(x, y+h);
642
643         glVertex2i(x, y+h);
644         glColor3f(sr, sg, sb);
645         glVertex2i(x+w/2, y+h/2);
646         glColor3f(ar, ag, ab);
647         glVertex2i(x+w/2, y+h);
648
649         glVertex2i(x+w/2, y+h);
650         glColor3f(sr, sg, sb);
651         glVertex2i(x+w/2, y+h/2);
652         glColor3f(pr, pg, pb);
653         glVertex2i(x+w, y+h);
654
655         glVertex2i(x+w, y+h);
656         glColor3f(sr, sg, sb);
657         glVertex2i(x+w/2, y+h/2);
658         glColor3f(ar, ag, ab);
659         glVertex2i(x+w, y+h/2);
660
661         glVertex2i(x+w, y+h/2);
662         glColor3f(sr, sg, sb);
663         glVertex2i(x+w/2, y+h/2);
664         glColor3f(pr, pg, pb);
665         glVertex2i(x+w, y);
666
667         glVertex2i(x+w, y);
668         glColor3f(sr, sg, sb);
669         glVertex2i(x+w/2, y+h/2);
670         glColor3f(ar, ag, ab);
671         glVertex2i(x+w/2, y);
672
673         glVertex2i(x+w/2, y);
674         glColor3f(sr, sg, sb);
675         glVertex2i(x+w/2, y+h/2);
676         glColor3f(pr, pg, pb);
677         glVertex2i(x, y);
678         glEnd();
679         break;
680     case Background_PipeCross:
681         glBegin(GL_TRIANGLES);
682         glColor3f(pr, pg, pb);
683         glVertex2i(x, y);
684         glColor3f(sr, sg, sb);
685         glVertex2i(x+w/2, y+h/2);
686         glVertex2i(x, y+h/2);
687
688         glVertex2i(x, y+h/2);
689         glVertex2i(x+w/2, y+h/2);
690         glColor3f(pr, pg, pb);
691         glVertex2i(x, y+h);
692
693         glVertex2i(x, y+h);
694         glColor3f(sr, sg, sb);
695         glVertex2i(x+w/2, y+h/2);
696         glVertex2i(x+w/2, y+h);
697
698         glVertex2i(x+w/2, y+h);
699         glVertex2i(x+w/2, y+h/2);
700         glColor3f(pr, pg, pb);
701         glVertex2i(x+w, y+h);
702
703         glVertex2i(x+w, y+h);
704         glColor3f(sr, sg, sb);
705         glVertex2i(x+w/2, y+h/2);
706         glVertex2i(x+w, y+h/2);
707
708         glVertex2i(x+w, y+h/2);
709         glVertex2i(x+w/2, y+h/2);
710         glColor3f(pr, pg, pb);
711         glVertex2i(x+w, y);
712
713         glVertex2i(x+w, y);
714         glColor3f(sr, sg, sb);
715         glVertex2i(x+w/2, y+h/2);
716         glVertex2i(x+w/2, y);
717
718         glVertex2i(x+w/2, y);
719         glVertex2i(x+w/2, y+h/2);
720         glColor3f(pr, pg, pb);
721         glVertex2i(x, y);
722         glEnd();
723         break;
724     case Background_Rectangle:
725         glBegin(GL_TRIANGLES);
726         glColor3f(pr, pg, pb);
727         glVertex2i(x, y);
728         glColor3f(sr, sg, sb);
729         glVertex2i(x+w/2, y+h/2);
730         glColor3f(pr, pg, pb);
731         glVertex2i(x, y+h);
732
733         glVertex2i(x, y+h);
734         glColor3f(sr, sg, sb);
735         glVertex2i(x+w/2, y+h/2);
736         glColor3f(pr, pg, pb);
737         glVertex2i(x+w, y+h);
738
739         glVertex2i(x+w, y+h);
740         glColor3f(sr, sg, sb);
741         glVertex2i(x+w/2, y+h/2);
742         glColor3f(pr, pg, pb);
743         glVertex2i(x+w, y);
744
745         glVertex2i(x+w, y);
746         glColor3f(sr, sg, sb);
747         glVertex2i(x+w/2, y+h/2);
748         glColor3f(pr, pg, pb);
749         glVertex2i(x, y);
750
751         glEnd();
752         break;
753     default:
754         g_message("unhandled gradient");
755         return;
756     }
757 }
758 #endif /* USE_GL */