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