git.chise.org Git - chise/xemacs-chise.git.1/blob - lwlib/xlwgcs.c

   1  /* Tabs Widget for XEmacs.
   2     Copyright (C) 1999 Edward A. Falk
   3
   4  This file is part of XEmacs.
   5
   6  XEmacs is free software; you can redistribute it and/or modify it
   7  under the terms of the GNU General Public License as published by the
   8  Free Software Foundation; either version 2, or (at your option) any
   9  later version.
  10
  11  XEmacs is distributed in the hope that it will be useful, but WITHOUT
  12  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  for more details.
  15
  16  You should have received a copy of the GNU General Public License
  17  along with XEmacs; see the file COPYING.  If not, write to
  18  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  Boston, MA 02111-1307, USA.  */
  20
  21 /* Synched up with: Gcs.c 1.7 */
  22
  23  /* #### This code is duplicated many times within lwlib and XEmacs. It
  24     should be modularised. */
  25
  26 /*
  27  * Gcs.c - Utility functions to allocate GCs.
  28  *
  29  * Author: Edward A. Falk
  30  *         falk@falconer.vip.best.com
  31  *
  32  * Date: Sept 29, 1998
  33  */
  34
  35 /* Functions:
  36  *
  37  * GC AllocFgGC(w, fg, font)
  38  *      Return a GC with foreground set as specified.
  39  *      If font is None, then the returned GC is allocated with font specified
  40  *      as a "don't care" value.
  41  *
  42  * GC
  43  * AllocBackgroundGC(w, font)
  44  *      Return a GC with the foreground set to the widget's background color.
  45  *
  46  * GC
  47  * AllocGreyGC(w, fg, font, contrast, be_nice_to_cmap)
  48  *      Widget  w ;
  49  *      Pixel   fg ;
  50  *      Font    font ;
  51  *      int     contrast ;
  52  *      int     be_nice_to_cmap ;
  53  *
  54  *      Return a GC suitable for rendering a widget in its "inactive" color.
  55  *      Normally returns a GC with a color somewhere between the widget's
  56  *      background color and the specified foreground. If font is None, then
  57  *      the returned GC is allocated with font specified as "don't care".
  58  *      If be_nice_to_cmap is True, the returned GC is created using a 50%
  59  *      dither instead of a new color.
  60  *
  61  *
  62  * GC
  63  * AllocShadeGC(w, fg, bg, font, contrast, be_nice_to_cmap)
  64  *      Widget  w ;
  65  *      Pixel   fg, bg ;
  66  *      Font    font ;
  67  *      int     contrast ;
  68  *      int     be_nice_to_cmap ;
  69  *
  70  *      Return a GC suitable for rendering in a shade somewhere between
  71  *      bg and fg, as determined by contrast (0 = bg, 100 = fg)
  72  *      If font is None, then the returned GC is allocated with
  73  *      font specified as "don't care".  If be_nice_to_cmap
  74  *      is True, the returned GC is created using a 50% dither
  75  *      instead of a new color.
  76  *
  77  *
  78  * GC
  79  * AllocTopShadowGC(w, contrast, be_nice_to_cmap)
  80  *      Return a GC suitable for rendering the "top shadow" decorations of
  81  *      a widget.  Returns a GC with foreground computed from widget's
  82  *      background color and contrast.  If be_nice_to_cmap is True, the
  83  *      returned GC will use a foreground color of white.  If widget depth
  84  *      is 1, this function will use a foreground color of black.
  85  *
  86  * GC
  87  * AllocBotShadowGC(w, contrast, be_nice_to_cmap)
  88  *      Return a GC suitable for rendering the "bottom shadow" decorations
  89  *      of a widget. Returns a GC with foreground computed from widget's
  90  *      background color and contrast. If be_nice_to_cmap is True, the
  91  *      returned GC will use a foreground color of black.
  92  *
  93  * GC
  94  * AllocArmGC(w, contrast, be_nice_to_cmap)
  95  *      Return a GC suitable for rendering the "armed" decorations of a
  96  *      widget. This GC would typically be used to fill in the widget's
  97  *      background. Returns a GC with foreground computed from widget's
  98  *      background color and contrast.  If be_nice_to_cmap is True, the
  99  *      returned GC will use a foreground color of black and a 50% dither.
 100  *
 101  *
 102  * void
 103  * Draw3dBox(w, x,y,wid,hgt,s, topgc, botgc)
 104  *      Utility function.  Draws a raised shadow box with outside dimensions
 105  *      as specified by x,y,wid,hgt and shadow width specified by s.
 106  *      A lowered shadow box may be generated by swapping topgc and botgc.
 107  *
 108  */
 109
 110 #include        <config.h>
 111 #include        <stdio.h>
 112
 113 #include        <X11/Xlib.h>
 114 #include        <X11/IntrinsicP.h>
 115 #include        <X11/StringDefs.h>
 116 #include        "../src/xmu.h"
 117 #include        "xlwgcs.h"
 118
 119         /* Color & GC allocation.
 120          *
 121          * Frame widgets use the following graphics contexts:
 122          *
 123          *  Foreground          tab label text drawn this way
 124          *  Insensitive Fg      foreground color greyed out.
 125          *  Background          frame background color
 126          *  Top shadow          upper-left highlight around widget
 127          *  Bottom shadow       lower-right highlight around widget
 128          *  Arm shadow          button pressed and ready to be released
 129          *
 130          *
 131          * GC's are defined as follows, depending on attributes and
 132          * window depth:
 133          *
 134          * Monochrome:
 135          *      Foreground = foreground color attribute or BlackPixel()
 136          *      Grey = Foreground color + 50% dither
 137          *      Background = background color attribute or WhitePixel()
 138          *      top shadow = foreground
 139          *      bottom shadow = foreground
 140          *      arm shadow = (what?)
 141          *
 142          * Color, beNiceToColormap=true:
 143          *      Foreground = foreground color attribute or BlackPixel()
 144          *      Grey = Foreground color + 50% dither
 145          *      Background = background color attribute or WhitePixel()
 146          *      top shadow = white
 147          *      bottom shadow = black
 148          *      arm shadow = (what?)
 149          *
 150          * Color, beNiceToColormap=false:
 151          *      Foreground = foreground color attribute or BlackPixel()
 152          *      Grey = (foreground color + background color)/2
 153          *      Background = background color attribute or WhitePixel()
 154          *      top shadow = background * 1.2
 155          *      bottom shadow = background * .6
 156          *      arm shadow = background * .8
 157          *
 158          * Special cases:
 159          *      If background is white,   ??
 160          *      if background is black,   ??
 161          *
 162          *
 163          * If the widget's background is solid white or solid black,
 164          * this code just picks some numbers.  (The choice is designed
 165          * to be compatibile with ThreeD interface.)
 166          */
 167
 168
 169
 170 #if     XtSpecificationRelease  < 5
 171
 172 static  GC      XtAllocateGC(Widget, int, u_long, XGCValues *, u_long, u_long) ;
 173
 174 #endif
 175
 176
 177 #if     NeedFunctionPrototypes
 178 static  Pixmap  getDitherPixmap(Widget, int contrast) ;
 179 #else
 180 static  Pixmap  getDitherPixmap() ;
 181 #endif
 182
 183         /* return a GC with the specified foreground and optional font */
 184
 185 GC
 186 AllocFgGC(Widget w, Pixel fg, Font font)
 187 {
 188         XGCValues       values ;
 189         u_long          vmask, dcmask ;
 190
 191         values.foreground = fg ;
 192         values.font = font ;
 193
 194         if( font != None ) {
 195           vmask = GCForeground|GCFont ;
 196           dcmask = GCSubwindowMode|GCDashOffset|
 197                 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ;
 198         } else {
 199           vmask = GCForeground ;
 200           dcmask = GCFont|GCSubwindowMode|GCDashOffset|
 201                 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ;
 202         }
 203
 204         return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
 205 }
 206
 207
 208         /* return gc with widget background color as the foreground */
 209
 210 GC
 211 AllocBackgroundGC(Widget w, Font font)
 212 {
 213         return AllocFgGC(w, w->core.background_pixel, font) ;
 214 }
 215
 216
 217         /* Allocate an "inactive" GC.  Color is grey (possibly via
 218          * dither pattern).
 219          */
 220
 221 GC
 222 AllocGreyGC(Widget w, Pixel fg, Font font, int contrast, Bool be_nice_to_cmap)
 223 {
 224         return AllocShadeGC(w, fg, w->core.background_pixel,
 225                 font, contrast, be_nice_to_cmap) ;
 226 }
 227
 228
 229         /* Allocate a GC somewhere between two colors.  */
 230
 231 GC
 232 AllocShadeGC(Widget w, Pixel fg, Pixel bg, Font font,
 233         int contrast, Bool be_nice_to_cmap)
 234 {
 235         XGCValues       values ;
 236         u_long          vmask, dcmask ;
 237
 238         values.foreground = fg ;
 239         values.background = bg ;
 240         values.font = font ;
 241
 242         if( font != None ) {
 243           vmask = GCForeground|GCFont ;
 244           dcmask = GCSubwindowMode|GCDashOffset|
 245                 GCDashList|GCArcMode|GCGraphicsExposures ;
 246         } else {
 247           vmask = GCForeground;
 248           dcmask = GCFont|GCSubwindowMode|GCDashOffset|
 249                 GCDashList|GCArcMode|GCGraphicsExposures ;
 250         }
 251 #ifdef HAVE_XMU
 252         if( be_nice_to_cmap || w->core.depth == 1)
 253         {
 254           if( contrast <= 5 )
 255             values.foreground = bg ;
 256           else if( contrast >= 95 )
 257             values.foreground = fg ;
 258           else {
 259             vmask |= GCBackground|GCStipple|GCFillStyle ;
 260             values.fill_style = FillOpaqueStippled ;
 261             values.stipple = getDitherPixmap(w, contrast) ;
 262           }
 263
 264           return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
 265         }
 266         else
 267 #endif
 268         {
 269           dcmask |= GCBackground ;
 270           values.foreground = AllocGreyPixel(w, fg, bg, contrast) ;
 271           return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ;
 272         }
 273 }
 274
 275         /* return top-shadow gc. */
 276
 277 GC
 278 AllocTopShadowGC(Widget w, int contrast, Bool be_nice_to_cmap)
 279 {
 280         Screen          *scr = XtScreen (w);
 281         XGCValues       values ;
 282
 283         if( w->core.depth == 1 )
 284           values.foreground = BlackPixelOfScreen(scr) ;
 285         else if( be_nice_to_cmap )
 286           values.foreground = WhitePixelOfScreen(scr) ;
 287         else
 288           values.foreground = AllocShadowPixel(w, 100+contrast) ;
 289
 290         return XtAllocateGC(w, w->core.depth,
 291             GCForeground, &values,
 292             0L,
 293             GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
 294                 GCDashOffset|GCDashList|GCArcMode) ;
 295 }
 296
 297         /* return bottom-shadow gc. */
 298
 299 GC
 300 AllocBotShadowGC(Widget w, int contrast, Bool be_nice_to_cmap)
 301 {
 302         Screen          *scr = XtScreen (w);
 303         XGCValues       values ;
 304
 305         if( w->core.depth == 1 || be_nice_to_cmap )
 306           values.foreground = BlackPixelOfScreen(scr) ;
 307         else
 308           values.foreground = AllocShadowPixel(w, 100-contrast) ;
 309
 310         return XtAllocateGC(w, w->core.depth,
 311             GCForeground, &values,
 312             0L,
 313             GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
 314                 GCDashOffset|GCDashList|GCArcMode) ;
 315 }
 316
 317         /* return arm-shadow gc. */
 318
 319 GC
 320 AllocArmGC(Widget w, int contrast, Bool be_nice_to_cmap)
 321 {
 322         Screen          *scr = XtScreen (w);
 323         XGCValues       values ;
 324
 325         /* Not clear exactly what we should do here.  Take a look at
 326          * Xaw3d to see what they do.
 327          */
 328 #ifdef HAVE_XMU
 329         if( w->core.depth == 1 || be_nice_to_cmap )
 330         {
 331           values.background = w->core.background_pixel ;
 332           if( values.background == BlackPixelOfScreen(scr) )
 333             values.foreground = WhitePixelOfScreen(scr) ;
 334           else
 335             values.foreground = BlackPixelOfScreen(scr) ;
 336           values.fill_style = FillStippled ;
 337           values.stipple = XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ;
 338
 339           return XtAllocateGC(w, w->core.depth,
 340               GCForeground|GCBackground|GCStipple|GCFillStyle,
 341               &values, 0L,
 342               GCFont|GCSubwindowMode|GCGraphicsExposures|
 343                   GCDashOffset|GCDashList|GCArcMode) ;
 344         }
 345         else
 346 #endif
 347           {
 348           values.foreground = AllocShadowPixel(w, 100-contrast) ;
 349           return XtAllocateGC(w, w->core.depth,
 350               GCForeground, &values,
 351               0L,
 352               GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures|
 353                   GCDashOffset|GCDashList|GCArcMode) ;
 354         }
 355 }
 356
 357
 358 Pixel
 359 AllocShadowPixel(Widget w, int scale)
 360 {
 361         XColor  get_c, set_c ;
 362         Display *dpy = XtDisplay(w) ;
 363         Screen  *scr = XtScreen(w) ;
 364         Colormap cmap ;
 365         Pixel   maxColor ;
 366
 367         cmap = w->core.colormap ;
 368
 369         get_c.pixel = w->core.background_pixel ;
 370         if( get_c.pixel == WhitePixelOfScreen(scr)  ||
 371             get_c.pixel == BlackPixelOfScreen(scr) )
 372         {
 373           /* what we *ought* to do is choose gray75 as the base color,
 374            * or perhaps gray83.  Instead, we choose colors that are
 375            * the same as ThreeD would choose.
 376            */
 377           if( scale > 100 )     scale = 200 - scale ;
 378           set_c.red = set_c.green = set_c.blue = 65535*scale/100 ;
 379         }
 380         else
 381         {
 382           XQueryColor(dpy, cmap, &get_c) ;
 383           /* adjust scale so that brightest component does not
 384            * exceed 65535; otherwise hue would change.
 385            */
 386           if( scale > 100 ) {
 387             maxColor = Max(get_c.red, Max(get_c.green, get_c.blue)) ;
 388             if( scale*maxColor > 65535*100 )
 389               scale = 65535*100/maxColor ;
 390           }
 391           set_c.red = scale * get_c.red / 100 ;
 392           set_c.green = scale * get_c.green / 100 ;
 393           set_c.blue = scale * get_c.blue / 100 ;
 394         }
 395         set_c.flags = DoRed | DoGreen | DoBlue ;
 396         if( XAllocColor(dpy, cmap, &set_c) )
 397           return set_c.pixel ;
 398         else if( scale > 100 )
 399           return WhitePixelOfScreen(scr) ;
 400         else
 401           return BlackPixelOfScreen(scr) ;
 402 }
 403
 404
 405         /* Allocate a pixel partway between foreground and background */
 406
 407
 408 Pixel
 409 AllocGreyPixel(Widget w, Pixel fg, Pixel bg, int scale)
 410 {
 411   XColor        get_cf, get_cb ;
 412   Display       *dpy = XtDisplay(w) ;
 413   Colormap cmap ;
 414
 415   cmap = w->core.colormap ;
 416
 417   get_cf.pixel = fg ;
 418   get_cb.pixel = bg ;
 419
 420   XQueryColor(dpy, cmap, &get_cf) ;
 421   XQueryColor(dpy, cmap, &get_cb) ;
 422
 423   return AllocGreyPixelC(w, &get_cf, &get_cb, scale) ;
 424 }
 425
 426
 427
 428         /* Allocate a pixel partway between foreground and background */
 429
 430
 431 Pixel
 432 AllocGreyPixelC(Widget w, XColor *fg, XColor *bg, int scale)
 433 {
 434   XColor        set_c ;
 435   Display       *dpy = XtDisplay(w) ;
 436   int           r,g,b ;
 437   Colormap      cmap = w->core.colormap ;
 438
 439   r = (fg->red * scale +   bg->red * (100-scale)) / 100 ;
 440   g = (fg->green * scale + bg->green * (100-scale)) / 100 ;
 441   b = (fg->blue * scale +  bg->blue * (100-scale)) / 100 ;
 442
 443   if( scale > 100 || scale < 0 )        /* look out for overflow */
 444   {
 445     int minc, maxc ;
 446     maxc = Max(r, Max(g,b)) ;
 447     minc = Min(r, Min(g,b)) ;
 448     if( maxc > 65535 )
 449     {
 450       maxc /= 16 ;
 451       r = r*(65535/16) / maxc ;
 452       g = g*(65535/16) / maxc ;
 453       b = b*(65535/16) / maxc ;
 454     }
 455     if( minc < 0 )
 456     {
 457       r = Max(r,0) ;
 458       g = Max(g,0) ;
 459       b = Max(b,0) ;
 460     }
 461   }
 462
 463   set_c.red = r ; set_c.green = g ; set_c.blue = b ;
 464   set_c.flags = DoRed | DoGreen | DoBlue ;
 465   (void)XAllocColor(dpy, cmap, &set_c) ;
 466   return set_c.pixel ;
 467 }
 468
 469
 470
 471
 472
 473         /* draw a 3-d box */
 474
 475 void
 476 Draw3dBox(Widget w, int x, int y, int wid, int hgt, int s, GC topgc, GC botgc)
 477 {
 478         Display         *dpy = XtDisplay(w) ;
 479         Window          win = XtWindow(w) ;
 480
 481         if( s == 0 ) return ;
 482
 483         if( s == 1 ) {
 484           XDrawLine(dpy,win,botgc, x,y+hgt-1, x+wid-1,y+hgt-1) ;
 485           XDrawLine(dpy,win,botgc, x+wid-1,y, x+wid-1,y+hgt-1) ;
 486           XDrawLine(dpy,win,topgc, x,y, x,y+hgt-1) ;
 487           XDrawLine(dpy,win,topgc, x,y, x+wid-1,y) ;
 488         }
 489         else
 490         {
 491           XPoint pts[6] ;
 492
 493           /* bottom-right shadow */
 494           pts[0].x = x ;        pts[0].y = y + hgt ;
 495           pts[1].x = s ;        pts[1].y = -s ;
 496           pts[2].x = wid-2*s ;  pts[2].y = 0 ;
 497           pts[3].x = 0 ;        pts[3].y = -(hgt-2*s) ;
 498           pts[4].x = s ;        pts[4].y = -s ;
 499           pts[5].x = 0 ;        pts[5].y = hgt ;
 500           XFillPolygon(dpy,win,botgc, pts,6, Nonconvex,CoordModePrevious) ;
 501
 502           /* top-left shadow */
 503           pts[0].x = x ;        pts[0].y = y ;
 504           pts[1].x = wid ;      pts[1].y = 0 ;
 505           pts[2].x = -s ;       pts[2].y = s ;
 506           pts[3].x = -wid+2*s ; pts[3].y = 0 ;
 507           pts[4].x = 0 ;        pts[4].y = hgt-2*s ;
 508           pts[5].x = -s ;       pts[5].y = s ;
 509           XFillPolygon(dpy,win,topgc, pts,6, Nonconvex,CoordModePrevious) ;
 510         }
 511 }
 512
 513 #if XtSpecificationRelease < 5
 514
 515 static  GC
 516 XtAllocateGC(Widget w, int depth, u_long mask, XGCValues *values,
 517         u_long dynamic, du_long ontcare)
 518 {
 519         return XtGetGC(w, mask, values) ;
 520 }
 521 #endif
 522
 523
 524 static  u_char  screen0[2] = {0,0} ;
 525 static  u_char  screen25[2] = {0,0xaa} ;
 526 static  u_char  screen75[2] = {0xaa,0xff} ;
 527 static  u_char  screen100[2] = {0xff,0xff} ;
 528
 529 static  Pixmap
 530 getDitherPixmap(Widget w, int contrast)
 531 {
 532         Display *dpy = XtDisplay(w) ;
 533         Window  win = XtWindow(w) ;
 534
 535         if( contrast <= 5 )
 536           return XCreateBitmapFromData(dpy,win, (char *)screen0, 2,2) ;
 537         else if( contrast <= 37 )
 538           return XCreateBitmapFromData(dpy,win, (char *)screen25, 2,2) ;
 539         else if( contrast <= 62 )
 540           return XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ;
 541         else if( contrast <= 95 )
 542           return XCreateBitmapFromData(dpy,win, (char *)screen75, 2,2) ;
 543         else
 544           return XCreateBitmapFromData(dpy,win, (char *)screen100, 2,2) ;
 545 }