src/texture.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19  *  USA.
  20  */
  21
  22 #include "wconfig.h"
  23
  24 #include <X11/Xlib.h>
  25 #include <X11/Xutil.h>
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include <wraster.h>
  32
  33 #include "WindowMaker.h"
  34 #include "wcore.h"
  35 #include "texture.h"
  36 #include "funcs.h"
  37
  38 extern WPreferences wPreferences;
  39
  40
  41 static Pixmap renderTexture(WScreen *scr, int width, int height,
  42                              WTexture *texture, int rel);
  43
  44
  45 static void bevelImage(RImage *image, int relief);
  46
  47
  48
  49 WTexSolid*
  50 wTextureMakeSolid(WScreen *scr, XColor *color)
  51 {
  52     WTexSolid *texture;
  53     int gcm;
  54     XGCValues gcv;
  55
  56     texture = wmalloc(sizeof(WTexture));
  57
  58     texture->type = WTEX_SOLID;
  59     texture->subtype = 0;
  60
  61     XAllocColor(dpy, scr->w_colormap, color);
  62     texture->normal = *color;
  63     if (color->red==0 && color->blue==0 && color->green == 0) {
  64         texture->light.red = 0xb6da;
  65         texture->light.green = 0xb6da;
  66         texture->light.blue = 0xb6da;
  67         texture->dim.red = 0x6185;
  68         texture->dim.green = 0x6185;
  69         texture->dim.blue = 0x6185;
  70     } else {
  71         RColor rgb;
  72         RHSVColor hsv, hsv2;
  73         int v;
  74
  75         rgb.red = color->red >> 8;
  76         rgb.green = color->green >> 8;
  77         rgb.blue = color->blue >> 8;
  78         RRGBtoHSV(&rgb, &hsv);
  79         RHSVtoRGB(&hsv, &rgb);
  80         hsv2 = hsv;
  81
  82         v = hsv.value*16/10;
  83         hsv.value = (v > 255 ? 255 : v);
  84         RHSVtoRGB(&hsv, &rgb);
  85         texture->light.red = rgb.red << 8;
  86         texture->light.green = rgb.green << 8;
  87         texture->light.blue = rgb.blue << 8;
  88
  89         hsv2.value = hsv2.value/2;
  90         RHSVtoRGB(&hsv2, &rgb);
  91         texture->dim.red = rgb.red << 8;
  92         texture->dim.green = rgb.green << 8;
  93         texture->dim.blue = rgb.blue << 8;
  94     }
  95     texture->dark.red = 0;
  96     texture->dark.green = 0;
  97     texture->dark.blue = 0;
  98     XAllocColor(dpy, scr->w_colormap, &texture->light);
  99     XAllocColor(dpy, scr->w_colormap, &texture->dim);
 100     XAllocColor(dpy, scr->w_colormap, &texture->dark);
 101
 102     gcm = GCForeground|GCBackground|GCGraphicsExposures;
 103     gcv.graphics_exposures = False;
 104
 105     gcv.background = gcv.foreground = texture->light.pixel;
 106     texture->light_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 107
 108     gcv.background = gcv.foreground = texture->dim.pixel;
 109     texture->dim_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 110
 111     gcv.background = gcv.foreground = texture->dark.pixel;
 112     texture->dark_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 113
 114     gcv.background = gcv.foreground = color->pixel;
 115     texture->normal_gc = XCreateGC(dpy, scr->w_win, gcm, &gcv);
 116
 117     return texture;
 118 }
 119
 120
 121 static int
 122 dummyErrorHandler(Display *foo, XErrorEvent *bar)
 123 {
 124 #ifdef DEBUG
 125     wwarning("your server is buggy. Tell the author if some error related to color occurs");
 126 #endif
 127     return 0;
 128 }
 129
 130
 131 void
 132 wTextureDestroy(WScreen *scr, WTexture *texture)
 133 {
 134     int i;
 135     int count=0;
 136     unsigned long colors[8];
 137
 138 #ifdef DEBUG
 139     if (texture==NULL) {
 140         printf("BUG: trying to free NULL texture\n");
 141         return;
 142     }
 143 #endif
 144
 145     /*
 146      * some stupid servers don't like white or black being freed...
 147      */
 148 #define CANFREE(c) (c!=scr->black_pixel && c!=scr->white_pixel && c!=0)
 149     switch (texture->any.type) {
 150      case WTEX_SOLID:
 151         XFreeGC(dpy, texture->solid.light_gc);
 152         XFreeGC(dpy, texture->solid.dark_gc);
 153         XFreeGC(dpy, texture->solid.dim_gc);
 154         if (CANFREE(texture->solid.light.pixel))
 155           colors[count++] = texture->solid.light.pixel;
 156         if (CANFREE(texture->solid.dim.pixel))
 157           colors[count++] = texture->solid.dim.pixel;
 158         if (CANFREE(texture->solid.dark.pixel))
 159           colors[count++] = texture->solid.dark.pixel;
 160         break;
 161
 162      case WTEX_PIXMAP:
 163         RDestroyImage(texture->pixmap.pixmap);
 164         break;
 165
 166      case WTEX_MHGRADIENT:
 167      case WTEX_MVGRADIENT:
 168      case WTEX_MDGRADIENT:
 169         for (i=0; texture->mgradient.colors[i]!=NULL; i++) {
 170             free(texture->mgradient.colors[i]);
 171         }
 172         free(texture->mgradient.colors);
 173         break;
 174
 175      case WTEX_THGRADIENT:
 176      case WTEX_TVGRADIENT:
 177      case WTEX_TDGRADIENT:
 178         RDestroyImage(texture->tgradient.pixmap);
 179         break;
 180     }
 181     if (CANFREE(texture->any.color.pixel))
 182       colors[count++] = texture->any.color.pixel;
 183     if (count > 0) {
 184         XErrorHandler oldhandler;
 185
 186         /* ignore error from buggy servers that don't know how
 187          * to do reference counting for colors. */
 188         XSync(dpy,0);
 189         oldhandler = XSetErrorHandler(dummyErrorHandler);
 190         XFreeColors(dpy, scr->colormap, colors, count, 0);
 191         XSync(dpy,0);
 192         XSetErrorHandler(oldhandler);
 193     }
 194     XFreeGC(dpy, texture->any.gc);
 195     free(texture);
 196 #undef CANFREE
 197 }
 198
 199
 200
 201 WTexGradient*
 202 wTextureMakeGradient(WScreen *scr, int style, RColor *from, RColor *to)
 203 {
 204     WTexGradient *texture;
 205     XGCValues gcv;
 206
 207
 208     texture = wmalloc(sizeof(WTexture));
 209     memset(texture, 0, sizeof(WTexture));
 210     texture->type = style;
 211     texture->subtype = 0;
 212
 213     texture->color1 = *from;
 214     texture->color2 = *to;
 215
 216     texture->normal.red = (from->red + to->red)<<7;
 217     texture->normal.green = (from->green + to->green)<<7;
 218     texture->normal.blue = (from->blue + to->blue)<<7;
 219
 220     XAllocColor(dpy, scr->w_colormap, &texture->normal);
 221     gcv.background = gcv.foreground = texture->normal.pixel;
 222     gcv.graphics_exposures = False;
 223     texture->normal_gc = XCreateGC(dpy, scr->w_win, GCForeground|GCBackground
 224                                    |GCGraphicsExposures, &gcv);
 225
 226     return texture;
 227 }
 228
 229
 230
 231 WTexMGradient*
 232 wTextureMakeMGradient(WScreen *scr, int style, RColor **colors)
 233 {
 234     WTexMGradient *texture;
 235     XGCValues gcv;
 236     int i;
 237
 238
 239     texture = wmalloc(sizeof(WTexture));
 240     memset(texture, 0, sizeof(WTexture));
 241     texture->type = style;
 242     texture->subtype = 0;
 243
 244     i=0;
 245     while (colors[i]!=NULL) i++;
 246     i--;
 247     texture->normal.red = (colors[0]->red<<8);
 248     texture->normal.green = (colors[0]->green<<8);
 249     texture->normal.blue =  (colors[0]->blue<<8);
 250
 251     texture->colors = colors;
 252
 253     XAllocColor(dpy, scr->w_colormap, &texture->normal);
 254     gcv.background = gcv.foreground = texture->normal.pixel;
 255     gcv.graphics_exposures = False;
 256     texture->normal_gc = XCreateGC(dpy, scr->w_win, GCForeground|GCBackground
 257                                    |GCGraphicsExposures, &gcv);
 258
 259     return texture;
 260 }
 261
 262
 263
 264 WTexPixmap*
 265 wTextureMakePixmap(WScreen *scr, int style, char *pixmap_file, XColor *color)
 266 {
 267     WTexPixmap *texture;
 268     XGCValues gcv;
 269     RImage *image;
 270     char *file;
 271
 272     file = FindImage(wPreferences.pixmap_path, pixmap_file);
 273     if (!file) {
 274         wwarning(_("image file \"%s\" used as texture could not be found."),
 275                  pixmap_file);
 276         return NULL;
 277     }
 278     image = RLoadImage(scr->rcontext, file, 0);
 279     if (!image) {
 280         wwarning(_("could not load texture pixmap \"%s\":%s"), file,
 281                         RMessageForError(RErrorCode));
 282         free(file);
 283         return NULL;
 284     }
 285     free(file);
 286
 287     texture = wmalloc(sizeof(WTexture));
 288     memset(texture, 0, sizeof(WTexture));
 289     texture->type = WTEX_PIXMAP;
 290     texture->subtype = style;
 291
 292     texture->normal = *color;
 293
 294     XAllocColor(dpy, scr->w_colormap, &texture->normal);
 295     gcv.background = gcv.foreground = texture->normal.pixel;
 296     gcv.graphics_exposures = False;
 297     texture->normal_gc = XCreateGC(dpy, scr->w_win, GCForeground|GCBackground
 298                                    |GCGraphicsExposures, &gcv);
 299
 300     texture->pixmap = image;
 301
 302     return texture;
 303 }
 304
 305
 306
 307 WTexTGradient*
 308 wTextureMakeTGradient(WScreen *scr, int style, RColor *from, RColor *to,
 309                       char *pixmap_file, int opacity)
 310 {
 311     WTexTGradient *texture;
 312     XGCValues gcv;
 313     RImage *image;
 314     char *file;
 315
 316     file = FindImage(wPreferences.pixmap_path, pixmap_file);
 317     if (!file) {
 318         wwarning(_("image file \"%s\" used as texture could not be found."),
 319                  pixmap_file);
 320         return NULL;
 321     }
 322     image = RLoadImage(scr->rcontext, file, 0);
 323     if (!image) {
 324         wwarning(_("could not load texture pixmap \"%s\":%s"), file,
 325                  RMessageForError(RErrorCode));
 326         free(file);
 327         return NULL;
 328     }
 329     free(file);
 330
 331     texture = wmalloc(sizeof(WTexture));
 332     memset(texture, 0, sizeof(WTexture));
 333     texture->type = style;
 334
 335     texture->opacity = opacity;
 336
 337     texture->color1 = *from;
 338     texture->color2 = *to;
 339
 340     texture->normal.red = (from->red + to->red)<<7;
 341     texture->normal.green = (from->green + to->green)<<7;
 342     texture->normal.blue = (from->blue + to->blue)<<7;
 343
 344     XAllocColor(dpy, scr->w_colormap, &texture->normal);
 345     gcv.background = gcv.foreground = texture->normal.pixel;
 346     gcv.graphics_exposures = False;
 347     texture->normal_gc = XCreateGC(dpy, scr->w_win, GCForeground|GCBackground
 348                                    |GCGraphicsExposures, &gcv);
 349
 350     texture->pixmap = image;
 351
 352     return texture;
 353 }
 354
 355
 356
 357 RImage*
 358 wTextureRenderImage(WTexture *texture, int width, int height, int relief)
 359 {
 360     RImage *image;
 361     RColor color1;
 362     int d;
 363     int subtype;
 364
 365     switch (texture->any.type) {
 366      case WTEX_SOLID:
 367         image = RCreateImage(width, height, False);
 368
 369         color1.red = texture->solid.normal.red >> 8;
 370         color1.green = texture->solid.normal.green >> 8;
 371         color1.blue = texture->solid.normal.blue >> 8;
 372         color1.alpha = 255;
 373
 374         RClearImage(image, &color1);
 375         break;
 376
 377      case WTEX_PIXMAP:
 378         if (texture->pixmap.subtype == WTP_TILE) {
 379             image = RMakeTiledImage(texture->pixmap.pixmap, width, height);
 380         } else if (texture->pixmap.subtype == WTP_CENTER) {
 381             color1.red = texture->pixmap.normal.red>>8;
 382             color1.green = texture->pixmap.normal.green>>8;
 383             color1.blue = texture->pixmap.normal.blue>>8;
 384             color1.alpha = 255;
 385             image = RMakeCenteredImage(texture->pixmap.pixmap, width, height,
 386                                        &color1);
 387         } else {
 388             image = RScaleImage(texture->pixmap.pixmap, width, height);
 389         }
 390         break;
 391
 392      case WTEX_HGRADIENT:
 393         subtype = RGRD_HORIZONTAL;
 394         goto render_gradient;
 395
 396      case WTEX_VGRADIENT:
 397         subtype = RGRD_VERTICAL;
 398         goto render_gradient;
 399
 400      case WTEX_DGRADIENT:
 401         subtype = RGRD_DIAGONAL;
 402      render_gradient:
 403
 404         image = RRenderGradient(width, height, &texture->gradient.color1,
 405                                 &texture->gradient.color2, subtype);
 406         break;
 407
 408      case WTEX_MHGRADIENT:
 409         subtype = RGRD_HORIZONTAL;
 410         goto render_mgradient;
 411
 412      case WTEX_MVGRADIENT:
 413         subtype = RGRD_VERTICAL;
 414         goto render_mgradient;
 415
 416      case WTEX_MDGRADIENT:
 417         subtype = RGRD_DIAGONAL;
 418      render_mgradient:
 419         image = RRenderMultiGradient(width, height,
 420                                      &(texture->mgradient.colors[1]),
 421                                      subtype);
 422         break;
 423
 424      case WTEX_THGRADIENT:
 425         subtype = RGRD_HORIZONTAL;
 426         goto render_tgradient;
 427
 428      case WTEX_TVGRADIENT:
 429         subtype = RGRD_VERTICAL;
 430         goto render_tgradient;
 431
 432      case WTEX_TDGRADIENT:
 433         subtype = RGRD_DIAGONAL;
 434      render_tgradient:
 435         {
 436             RImage *grad;
 437
 438             image = RMakeTiledImage(texture->tgradient.pixmap, width, height);
 439             if (!image)
 440                 break;
 441
 442             grad = RRenderGradient(width, height, &texture->tgradient.color1,
 443                                    &texture->tgradient.color2, subtype);
 444             if (!grad) {
 445                 RDestroyImage(image);
 446                 image = NULL;
 447                 break;
 448             }
 449
 450             RCombineImagesWithOpaqueness(image, grad,
 451                                          texture->tgradient.opacity);
 452             RDestroyImage(grad);
 453         }
 454         break;
 455
 456      default:
 457         puts("ERROR in wTextureRenderImage()");
 458         image = NULL;
 459         break;
 460     }
 461
 462     if (!image) {
 463         wwarning(_("could not render texture: %s"), RMessageForError(RErrorCode));
 464         return None;
 465     }
 466
 467
 468     /* render bevel */
 469
 470     switch (relief) {
 471     case WREL_ICON:
 472         d = RBEV_RAISED3;
 473         break;
 474
 475      case WREL_RAISED:
 476         d = RBEV_RAISED2;
 477         break;
 478
 479      case WREL_SUNKEN:
 480         d = RBEV_SUNKEN;
 481         break;
 482
 483      case WREL_FLAT:
 484         d = 0;
 485         break;
 486
 487      case WREL_MENUENTRY:
 488         d = -WREL_MENUENTRY;
 489         break;
 490
 491      default:
 492         d = 0;
 493     }
 494
 495     if (d > 0) {
 496         RBevelImage(image, d);
 497     } else if (d < 0) {
 498         bevelImage(image, -d);
 499     }
 500
 501     return image;
 502 }
 503
 504
 505 /* used only for menu entries */
 506 void
 507 wTextureRender(WScreen *scr, WTexture *texture, Pixmap *data,
 508                int width, int height, int relief)
 509 {
 510     if (!texture)
 511       return;
 512 /*
 513     switch (texture->any.type) {
 514      case WTEX_DGRADIENT:
 515      case WTEX_VGRADIENT:
 516      case WTEX_HGRADIENT:
 517      case WTEX_MHGRADIENT:
 518      case WTEX_MVGRADIENT:
 519      case WTEX_MDGRADIENT:
 520      case WTEX_PIXMAP:
 521         */
 522         if (!*data) {
 523             *data = renderTexture(scr, width, height, texture, relief);
 524         }/*
 525         break;
 526     }*/
 527 }
 528
 529
 530
 531 static void
 532 bevelImage(RImage *image, int relief)
 533 {
 534     int width = image->width;
 535     int height = image->height;
 536     RColor color;
 537
 538     switch (relief) {
 539      case WREL_MENUENTRY:
 540         color.red = color.green = color.blue = 80;
 541         color.alpha = 0;
 542         ROperateLine(image, RAddOperation, 1, 0, width-2, 0, &color);
 543
 544         ROperateLine(image, RAddOperation, 0, 0, 0, height-1, &color);
 545
 546         color.red = color.green = color.blue = 40;
 547         color.alpha = 0;
 548         ROperateLine(image, RSubtractOperation, width-1, 0, width-1,
 549                      height-1, &color);
 550
 551         ROperateLine(image, RSubtractOperation, 1, height-2, width-2,
 552                      height-2, &color);
 553
 554         color.red = color.green = color.blue = 0;
 555         color.alpha = 255;
 556         RDrawLine(image, 0, height-1, width-1, height-1, &color);
 557         break;
 558
 559     }
 560 }
 561
 562
 563
 564 static Pixmap
 565 renderTexture(WScreen *scr, int width, int height, WTexture *texture,
 566                int rel)
 567 {
 568     RImage *img;
 569     Pixmap pix;
 570
 571     img = wTextureRenderImage(texture, width, height, rel);
 572
 573     if (!img) {
 574         wwarning(_("could not render texture: %s"), RMessageForError(RErrorCode));
 575         return None;
 576     }
 577     if (!RConvertImage(scr->rcontext, img, &pix)) {
 578         wwarning(_("error rendering image:%s"), RMessageForError(RErrorCode));
 579     }
 580     RDestroyImage(img);
 581     return pix;
 582 }
 583
 584
 585 void
 586 wDrawBevel(Drawable d, unsigned width, unsigned height,
 587            WTexSolid *texture, int relief)
 588 {
 589     GC light, dim, dark;
 590     XSegment segs[4];
 591
 592     if (relief==WREL_FLAT) return;
 593
 594     light = texture->light_gc;
 595     dim = texture->dim_gc;
 596     dark = texture->dark_gc;
 597     switch (relief) {
 598      case WREL_FLAT:
 599         return;
 600      case WREL_MENUENTRY:
 601      case WREL_RAISED:
 602      case WREL_ICON:
 603         segs[0].x1 = 1;
 604         segs[0].x2 = width - 2;
 605         segs[0].y2 = segs[0].y1 = height - 2;
 606         segs[1].x1 = width - 2;
 607         segs[1].y1 = 1;
 608         segs[1].x2 = width - 2;
 609         segs[1].y2 = height - 2;
 610         XDrawSegments(dpy, d, dim, segs, 2);
 611         segs[0].x1 = 0;
 612         segs[0].x2 = width - 1;
 613         segs[0].y2 = segs[0].y1 = height - 1;
 614         segs[1].x1 = segs[1].x2 = width - 1;
 615         segs[1].y1 = 0;
 616         segs[1].y2 = height - 1;
 617         XDrawSegments(dpy, d, dark, segs, 2);
 618         segs[0].x1 = segs[0].y1 = segs[0].y2 = 0;
 619         segs[0].x2 = width - 2;
 620         segs[1].x1 = segs[1].y1 = 0;
 621         segs[1].x2 = 0;
 622         segs[1].y2 = height - 2;
 623         XDrawSegments(dpy, d, light, segs, 2);
 624         if (relief==WREL_ICON) {
 625             segs[0].x1 = segs[0].y1 = segs[0].y2 = 1;
 626             segs[0].x2 = width - 2;
 627             segs[1].x1 = segs[1].y1 = 1;
 628             segs[1].x2 = 1;
 629             segs[1].y2 = height - 2;
 630             XDrawSegments(dpy, d, light, segs, 2);
 631         }
 632         break;
 633 #ifdef unused
 634      case WREL_SUNKEN:
 635         segs[0].x1 = 0;
 636         segs[0].x2 = width - 1;
 637         segs[0].y2 = segs[0].y1 = 0;
 638         segs[1].x1 = segs[1].x2 = 0;
 639         segs[1].y1 = 0;
 640         segs[1].y2 = height - 1;
 641         XDrawSegments(dpy, d, dark, segs, 2);
 642
 643         segs[0].x1 = 0;
 644         segs[0].y1 = segs[0].y2 = height - 1;
 645         segs[0].x2 = width - 1;
 646         segs[1].x2 = segs[1].x1 = width - 1;
 647         segs[1].y1 = 1;
 648         segs[1].y2 = height - 1;
 649         XDrawSegments(dpy, d, light, segs, 2);
 650         break;
 651 #endif
 652     }
 653 }
 654