home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / tcl / tkstep0.3b3 / tkstep0 / tkstep / tkScrollbar.c.diff < prev    next >
Encoding:
Text File  |  1996-07-08  |  26.1 KB  |  791 lines
  1. --- ../tk4.1/generic/tkScrollbar.c    Fri Feb 16 22:32:13 1996
  2. +++ tkScrollbar.c    Mon Jul  8 19:24:13 1996
  3. @@ -14,6 +14,10 @@
  4.   *
  5.   * SCCS: @(#) tkScrollbar.c 1.79 96/02/15 18:52:40
  6.   */
  7. +/*
  8. + * TkSTEP modifications Copyright
  9. + * by Alfredo K. Kojima 
  10. + */ 
  11.  
  12.  #include "tkPort.h"
  13.  #include "default.h"
  14. @@ -59,7 +63,9 @@
  15.      Tk_3DBorder activeBorder;    /* For drawing backgrounds when active (i.e.
  16.                   * when mouse is positioned over element). */
  17.      XColor *troughColorPtr;    /* Color for drawing trough. */
  18. -    GC troughGC;        /* For drawing trough. */
  19. +    XColor *darkPtr;        /* Color for background stipple */    
  20. +    GC troughGC;        /* For drawing trough's stippled part. */
  21. +    GC troughBackGC;        /* For drawing trough */
  22.      GC copyGC;            /* Used for copying from pixmap onto screen. */
  23.      int relief;            /* Indicates whether window as a whole is
  24.                   * raised, sunken, or flat. */
  25. @@ -70,6 +76,8 @@
  26.                  /* Color for drawing traversal highlight
  27.                   * area when highlight is off. */
  28.      XColor *highlightColorPtr;    /* Color for drawing traversal highlight. */
  29. +    Pixmap stipple;        /* trough base pattern */
  30. +    Pixmap bump;        /* bump in the slider */
  31.      int inset;            /* Total width of all borders, including
  32.                   * traversal highlight and 3-D border.
  33.                   * Indicates how much interior stuff must
  34. @@ -166,6 +174,7 @@
  35.  #define NEW_STYLE_COMMANDS    2
  36.  #define GOT_FOCUS        4
  37.  
  38. +#define RECONFIGURE        256
  39.  /*
  40.   * Minimum slider length, in pixels (designed to make sure that the slider
  41.   * is always easy to grab with the mouse).
  42. @@ -174,30 +183,43 @@
  43.  #define MIN_SLIDER_LENGTH    5
  44.  
  45.  /*
  46. + * If you want to make Tk ignore attribute settings that may be violating
  47. + * NEXTSTEP(tm) styles leave DISABLE_FORCE_STEP undef'ed, otherwise define it
  48. + * somewhere
  49. + */
  50. +#ifndef DISABLE_FORCE_STEP
  51. +#  define DISABLE_CHANGE    TK_CONFIG_DONT_CHANGE_DEFAULT
  52. +#else
  53. +#  define DISABLE_CHANGE    0
  54. +#endif
  55. +
  56. +/*
  57.   * Information used for argv parsing.
  58.   */
  59.  
  60.  static Tk_ConfigSpec configSpecs[] = {
  61.      {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground",
  62.      DEF_SCROLLBAR_ACTIVE_BG_COLOR, Tk_Offset(Scrollbar, activeBorder),
  63. -    TK_CONFIG_COLOR_ONLY},
  64. +    TK_CONFIG_COLOR_ONLY|DISABLE_CHANGE},
  65.      {TK_CONFIG_BORDER, "-activebackground", "activeBackground", "Foreground",
  66.      DEF_SCROLLBAR_ACTIVE_BG_MONO, Tk_Offset(Scrollbar, activeBorder),
  67. -    TK_CONFIG_MONO_ONLY},
  68. +    TK_CONFIG_MONO_ONLY|DISABLE_CHANGE},
  69.      {TK_CONFIG_RELIEF, "-activerelief", "activeRelief", "Relief",
  70. -    DEF_SCROLLBAR_ACTIVE_RELIEF, Tk_Offset(Scrollbar, activeRelief), 0},
  71. +    DEF_SCROLLBAR_ACTIVE_RELIEF, Tk_Offset(Scrollbar, activeRelief), 
  72. +        0},
  73.      {TK_CONFIG_BORDER, "-background", "background", "Background",
  74.      DEF_SCROLLBAR_BG_COLOR, Tk_Offset(Scrollbar, bgBorder),
  75. -    TK_CONFIG_COLOR_ONLY},
  76. +    TK_CONFIG_COLOR_ONLY|DISABLE_CHANGE},
  77.      {TK_CONFIG_BORDER, "-background", "background", "Background",
  78.      DEF_SCROLLBAR_BG_MONO, Tk_Offset(Scrollbar, bgBorder),
  79. -    TK_CONFIG_MONO_ONLY},
  80. +    TK_CONFIG_MONO_ONLY|DISABLE_CHANGE},
  81.      {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
  82.      (char *) NULL, 0, 0},
  83.      {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
  84.      (char *) NULL, 0, 0},
  85.      {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
  86. -    DEF_SCROLLBAR_BORDER_WIDTH, Tk_Offset(Scrollbar, borderWidth), 0},
  87. +    DEF_SCROLLBAR_BORDER_WIDTH, Tk_Offset(Scrollbar, borderWidth), 
  88. +        DISABLE_CHANGE},
  89.      {TK_CONFIG_STRING, "-command", "command", "Command",
  90.      DEF_SCROLLBAR_COMMAND, Tk_Offset(Scrollbar, command),
  91.      TK_CONFIG_NULL_OK},
  92. @@ -208,19 +230,23 @@
  93.      Tk_Offset(Scrollbar, elementBorderWidth), 0},
  94.      {TK_CONFIG_COLOR, "-highlightbackground", "highlightBackground",
  95.      "HighlightBackground", DEF_SCROLLBAR_HIGHLIGHT_BG,
  96. -    Tk_Offset(Scrollbar, highlightBgColorPtr), 0},
  97. +    Tk_Offset(Scrollbar, highlightBgColorPtr), 
  98. +        DISABLE_CHANGE},
  99.      {TK_CONFIG_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
  100.      DEF_SCROLLBAR_HIGHLIGHT,
  101. -    Tk_Offset(Scrollbar, highlightColorPtr), 0},
  102. +    Tk_Offset(Scrollbar, highlightColorPtr), 
  103. +        DISABLE_CHANGE},
  104.      {TK_CONFIG_PIXELS, "-highlightthickness", "highlightThickness",
  105.      "HighlightThickness",
  106. -    DEF_SCROLLBAR_HIGHLIGHT_WIDTH, Tk_Offset(Scrollbar, highlightWidth), 0},
  107. +    DEF_SCROLLBAR_HIGHLIGHT_WIDTH, Tk_Offset(Scrollbar, highlightWidth), 
  108. +        DISABLE_CHANGE},
  109.      {TK_CONFIG_BOOLEAN, "-jump", "jump", "Jump",
  110.      DEF_SCROLLBAR_JUMP, Tk_Offset(Scrollbar, jump), 0},
  111.      {TK_CONFIG_UID, "-orient", "orient", "Orient",
  112.      DEF_SCROLLBAR_ORIENT, Tk_Offset(Scrollbar, orientUid), 0},
  113.      {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
  114. -    DEF_SCROLLBAR_RELIEF, Tk_Offset(Scrollbar, relief), 0},
  115. +    DEF_SCROLLBAR_RELIEF, Tk_Offset(Scrollbar, relief), 
  116. +        DISABLE_CHANGE},
  117.      {TK_CONFIG_INT, "-repeatdelay", "repeatDelay", "RepeatDelay",
  118.      DEF_SCROLLBAR_REPEAT_DELAY, Tk_Offset(Scrollbar, repeatDelay), 0},
  119.      {TK_CONFIG_INT, "-repeatinterval", "repeatInterval", "RepeatInterval",
  120. @@ -230,16 +256,35 @@
  121.      TK_CONFIG_NULL_OK},
  122.      {TK_CONFIG_COLOR, "-troughcolor", "troughColor", "Background",
  123.      DEF_SCROLLBAR_TROUGH_COLOR, Tk_Offset(Scrollbar, troughColorPtr),
  124. -    TK_CONFIG_COLOR_ONLY},
  125. +    TK_CONFIG_COLOR_ONLY|DISABLE_CHANGE},
  126.      {TK_CONFIG_COLOR, "-troughcolor", "troughColor", "Background",
  127.      DEF_SCROLLBAR_TROUGH_MONO, Tk_Offset(Scrollbar, troughColorPtr),
  128. -    TK_CONFIG_MONO_ONLY},
  129. +    TK_CONFIG_MONO_ONLY|DISABLE_CHANGE},
  130.      {TK_CONFIG_PIXELS, "-width", "width", "Width",
  131. -    DEF_SCROLLBAR_WIDTH, Tk_Offset(Scrollbar, width), 0},
  132. +    DEF_SCROLLBAR_WIDTH, Tk_Offset(Scrollbar, width), 
  133. +        DISABLE_CHANGE},
  134.      {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
  135.      (char *) NULL, 0, 0}
  136.  };
  137.  
  138. +
  139. + 
  140. +#define SB_BUMP_WIDTH  6
  141. +#define SB_BUMP_HEIGHT 6
  142. +static char scrollbar_bump[] = {
  143. +" dbbb "\
  144. +"dbdddd"\
  145. +"bdd   "\
  146. +"bd  ww"\
  147. +"bd www"\
  148. +" d ww "
  149. +};
  150. +
  151. +
  152. +static unsigned char scrollbar_bump_bmp[] = {
  153. +   0x1e, 0x21, 0x39, 0x35, 0x3d, 0x1e};
  154. +
  155. +
  156.  /*
  157.   * Forward declarations for procedures defined later in this file:
  158.   */
  159. @@ -261,6 +306,83 @@
  160.  static int        ScrollbarWidgetCmd _ANSI_ARGS_((ClientData clientData,
  161.                  Tcl_Interp *, int argc, char **argv));
  162.  
  163. +
  164. +/*
  165. + *--------------------------------------------------------
  166. + * PaintPixmap -
  167. + *    Dirty routine to draw pixmaps from char data
  168. + *    
  169. + * gotta find a better way to do this...
  170. + *--------------------------------------------------------
  171. + */
  172. +static void PaintPixmap(clientData, d, data, width, height)
  173. +    ClientData clientData;
  174. +    Drawable d;
  175. +    char *data;
  176. +    int width, height;
  177. +{
  178. +    int x, y, ofs=0;
  179. +    Scrollbar *scrollPtr = (Scrollbar *)clientData;
  180. +    Display *display = scrollPtr->display;
  181. +    GC lightGC, backGC, darkGC, dark2GC;
  182. +
  183. +
  184. +    backGC = Tk_3DBorderGC( scrollPtr->tkwin, scrollPtr->bgBorder, 
  185. +               TK_3D_FLAT_GC);
  186. +    lightGC = Tk_3DBorderGC( scrollPtr->tkwin, scrollPtr->bgBorder, 
  187. +              TK_3D_LIGHT_GC);
  188. +    darkGC = Tk_3DBorderGC( scrollPtr->tkwin, scrollPtr->bgBorder, 
  189. +               TK_3D_DARK_GC);
  190. +    dark2GC = Tk_3DBorderGC( scrollPtr->tkwin, scrollPtr->bgBorder, 
  191. +               TK_3D_DARK2_GC);
  192. +    for(y = 0; y < height; y++) {
  193. +    for(x = 0; x < width; x++) {
  194. +        switch (data[ofs++]) {
  195. +         case 'b': /* black */
  196. +        XDrawPoint( scrollPtr->display, d, dark2GC, x, y);
  197. +        break;
  198. +         case 'd': /* dark */
  199. +        XDrawPoint( scrollPtr->display, d, darkGC, x, y);
  200. +        break;
  201. +         case 'w': /* white */
  202. +        XDrawPoint( scrollPtr->display, d, lightGC, x, y);
  203. +        break;
  204. +         default:
  205. +        XDrawPoint( scrollPtr->display, d, backGC, x, y);
  206. +        }
  207. +    }
  208. +    }
  209. +}
  210. +
  211. +
  212. +/*
  213. + *---------------------------------------------
  214. + *  
  215. + * MakePixmaps
  216. + *   Make pixmaps needed by scrollbar with 
  217. + * PaintPixmap
  218. + *
  219. + *---------------------------------------------
  220. + */
  221. +static void MakePixmaps(clientData)
  222. +    ClientData clientData;
  223. +{
  224. +    register Scrollbar *scrollPtr = (Scrollbar *) clientData;
  225. +
  226. +    if (Tk_Depth(scrollPtr->tkwin) > 1) {
  227. +    scrollPtr->bump = Tk_GetPixmap( scrollPtr->display, 
  228. +        Tk_WindowId(scrollPtr->tkwin),
  229. +        SB_BUMP_WIDTH, SB_BUMP_HEIGHT, Tk_Depth(scrollPtr->tkwin) );
  230. +    PaintPixmap(clientData, scrollPtr->bump, scrollbar_bump,
  231. +            SB_BUMP_WIDTH, SB_BUMP_HEIGHT);
  232. +    
  233. +    } else { /* monochrome display */
  234. +    scrollPtr->bump = XCreateBitmapFromData( scrollPtr->display,
  235. +        Tk_WindowId(scrollPtr->tkwin), scrollbar_bump_bmp,
  236. +        SB_BUMP_WIDTH, SB_BUMP_HEIGHT);
  237. +    }
  238. +}
  239. +
  240.  /*
  241.   *--------------------------------------------------------------
  242.   *
  243. @@ -326,6 +448,10 @@
  244.      scrollPtr->bgBorder = NULL;
  245.      scrollPtr->activeBorder = NULL;
  246.      scrollPtr->troughColorPtr = NULL;
  247. +    scrollPtr->darkPtr = NULL;
  248. +    scrollPtr->troughBackGC = None;
  249. +    scrollPtr->bump = None;
  250. +    scrollPtr->stipple = None;    
  251.      scrollPtr->troughGC = None;
  252.      scrollPtr->copyGC = None;
  253.      scrollPtr->relief = TK_RELIEF_FLAT;
  254. @@ -442,6 +568,8 @@
  255.          (char *) scrollPtr, argv[2], 0);
  256.      } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)
  257.          && (length >= 2)) {
  258. +    /* make sure that fg colors will be changed */    
  259. +    scrollPtr->flags|=RECONFIGURE;
  260.      if (argc == 2) {
  261.          result = Tk_ConfigureInfo(interp, scrollPtr->tkwin, configSpecs,
  262.              (char *) scrollPtr, (char *) NULL, 0);
  263. @@ -676,6 +804,18 @@
  264.      if (scrollPtr->copyGC != None) {
  265.      Tk_FreeGC(scrollPtr->display, scrollPtr->copyGC);
  266.      }
  267. +    if (scrollPtr->troughBackGC != None) {
  268. +    Tk_FreeGC(scrollPtr->display, scrollPtr->troughBackGC);
  269. +    }
  270. +    if (scrollPtr->bump != None) {
  271. +    Tk_FreePixmap(scrollPtr->display, scrollPtr->bump);
  272. +    }
  273. +    if (scrollPtr->stipple != None) {
  274. +    Tk_FreeBitmap(scrollPtr->display, scrollPtr->stipple);
  275. +    }    
  276. +    if (scrollPtr->darkPtr != NULL) {
  277. +    Tk_FreeColor(scrollPtr->darkPtr);
  278. +    }    
  279.      Tk_FreeOptions(configSpecs, (char *) scrollPtr, scrollPtr->display, 0);
  280.      ckfree((char *) scrollPtr);
  281.  }
  282. @@ -700,7 +840,6 @@
  283.   *
  284.   *----------------------------------------------------------------------
  285.   */
  286. -
  287.  static int
  288.  ConfigureScrollbar(interp, scrollPtr, argc, argv, flags)
  289.      Tcl_Interp *interp;            /* Used for error reporting. */
  290. @@ -714,13 +853,16 @@
  291.  {
  292.      size_t length;
  293.      XGCValues gcValues;
  294. +    XColor newcolor;
  295.      GC new;
  296.  
  297. +    if (Tk_StrictMotif(scrollPtr->tkwin)) {
  298. +    flags|=TK_CONFIG_CHECK_MY_FLAG;
  299. +    } 
  300.      if (Tk_ConfigureWidget(interp, scrollPtr->tkwin, configSpecs,
  301.          argc, argv, (char *) scrollPtr, flags) != TCL_OK) {
  302.      return TCL_ERROR;
  303.      }
  304. -
  305.      /*
  306.       * A few options need special processing, such as parsing the
  307.       * orientation or setting the background from a 3-D border.
  308. @@ -743,20 +885,57 @@
  309.      scrollPtr->commandSize = 0;
  310.      }
  311.  
  312. -    Tk_SetBackgroundFromBorder(scrollPtr->tkwin, scrollPtr->bgBorder);
  313. +    if (scrollPtr->stipple==None) {
  314. +    scrollPtr->stipple = Tk_GetBitmap((Tcl_Interp *)NULL, scrollPtr->tkwin,
  315. +        Tk_GetUid("gray50"));
  316. +    if (scrollPtr->stipple == None) {
  317. +        panic("ScrollBar couldn't allocate bitmap for trough");
  318. +    }
  319. +    }
  320. +    
  321. +    Tk_SetBackgroundFromBorder(scrollPtr->tkwin, scrollPtr->bgBorder);    
  322. +    /* alloc color for trough base stipple */
  323. +    newcolor.red = (60 * (int) scrollPtr->troughColorPtr->red)/100;
  324. +    newcolor.green =(60 * (int) scrollPtr->troughColorPtr->green)/100;
  325. +    newcolor.blue = (60 * (int) scrollPtr->troughColorPtr->blue)/100;
  326. +    
  327. +    if (scrollPtr->darkPtr != NULL) {
  328. +    Tk_FreeColor(scrollPtr->darkPtr);
  329. +    }    
  330. +    scrollPtr->darkPtr = Tk_GetColorByValue(scrollPtr->tkwin,
  331. +    &newcolor);
  332. +
  333. +    gcValues.background = scrollPtr->troughColorPtr->pixel;
  334. +    gcValues.foreground = scrollPtr->darkPtr->pixel;   
  335. +    gcValues.stipple = scrollPtr->stipple;
  336. +    gcValues.fill_style = FillOpaqueStippled;
  337.  
  338. -    gcValues.foreground = scrollPtr->troughColorPtr->pixel;
  339. -    new = Tk_GetGC(scrollPtr->tkwin, GCForeground, &gcValues);
  340. +    new = Tk_GetGC(scrollPtr->tkwin, GCForeground|GCBackground|GCStipple|
  341. +    GCFillStyle, &gcValues);
  342.      if (scrollPtr->troughGC != None) {
  343.      Tk_FreeGC(scrollPtr->display, scrollPtr->troughGC);
  344.      }
  345.      scrollPtr->troughGC = new;
  346. +    gcValues.foreground = scrollPtr->troughColorPtr->pixel;
  347. +    new = Tk_GetGC(scrollPtr->tkwin, GCForeground, &gcValues);
  348. +    if (scrollPtr->troughBackGC != None) {
  349. +    Tk_FreeGC(scrollPtr->display, scrollPtr->troughBackGC);
  350. +    }
  351. +    scrollPtr->troughBackGC = new;
  352. +    
  353.      if (scrollPtr->copyGC == None) {
  354.      gcValues.graphics_exposures = False;
  355.      scrollPtr->copyGC = Tk_GetGC(scrollPtr->tkwin, GCGraphicsExposures,
  356.          &gcValues);
  357.      }
  358.  
  359. +    if (Tk_IsMapped(scrollPtr->tkwin)&&(scrollPtr->flags & RECONFIGURE)) {
  360. +    scrollPtr->flags &= ~RECONFIGURE;
  361. +    if (scrollPtr->bump != None) {
  362. +        Tk_FreePixmap(scrollPtr->display, scrollPtr->bump);
  363. +    }
  364. +    MakePixmaps(scrollPtr);
  365. +    }
  366.      /*
  367.       * Register the desired geometry for the window (leave enough space
  368.       * for the two arrows plus a minimum-size slider, plus border around
  369. @@ -766,8 +945,85 @@
  370.  
  371.      ComputeScrollbarGeometry(scrollPtr);
  372.      EventuallyRedraw(scrollPtr);
  373. +
  374.      return TCL_OK;
  375.  }
  376. +
  377. +#define ARROW_UP    0
  378. +#define ARROW_DOWN    1
  379. +#define ARROW_LEFT    2
  380. +#define ARROW_RIGHT    3
  381. +/*
  382. + * DrawArrow --
  383. + *       Draws an antialiased arrow with direction dir and size w x h. 
  384. + *      It's coordinates are relative to the center of the arrow. 
  385. + */
  386. +static void DrawArrow(scrollPtr, drawable, x, y, w, h, dir)
  387. +    Scrollbar   *scrollPtr;
  388. +    Drawable    drawable;
  389. +    int     x, y;    /* position relative to middle of arrow */
  390. +    int     w, h;
  391. +    char    dir;
  392. +{
  393. +    int i, hw;
  394. +    float d, s;
  395. +    GC     core, border;
  396. +
  397. +    core = Tk_3DBorderGC(scrollPtr->tkwin,scrollPtr->bgBorder,TK_3D_DARK2_GC);
  398. +    border = Tk_3DBorderGC(scrollPtr->tkwin,scrollPtr->bgBorder,TK_3D_DARK_GC);
  399. +
  400. +    if (h<3) h=3;
  401. +    if (w<3) w=3;
  402. +    if (dir<2) { /* vertical */
  403. +    hw = w/2;
  404. +    d = ((float)w/2)/(float)h;
  405. +    y -= h/2;    
  406. +    } else {
  407. +    hw = h/2;
  408. +    d = ((float)h/2)/(float)w;
  409. +    x -= w/2;
  410. +    }    
  411. +    s=0;
  412. +    switch (dir) {
  413. +     case ARROW_DOWN:
  414. +    s=h*d+0.5;
  415. +    d=-d;
  416. +     case ARROW_UP:
  417. +    for(i = 0; i < h; i++) {
  418. +        s += d;    
  419. +        XDrawLine(scrollPtr->display, drawable, core,
  420. +              (unsigned)(x-(int)(s-0.5)), y+i,
  421. +              (unsigned)(x+(int)(s-0.5)), y+i);
  422. +        /* anti-aliasing */    
  423. +        if ((int)(s+0.5)!=(int)s) {
  424. +        XDrawPoint(scrollPtr->display, drawable, 
  425. +               border, (unsigned)(x+(int)s), y+i);
  426. +        XDrawPoint(scrollPtr->display, drawable,
  427. +               border, (unsigned)(x-(int)s), y+i);
  428. +        }
  429. +    }
  430. +    break;
  431. +     case ARROW_RIGHT:
  432. +    s=h*d+0.5;
  433. +    d=-d;
  434. +     case ARROW_LEFT:
  435. +    for(i = 0; i < h; i++) {
  436. +        s += d;    
  437. +        XDrawLine(scrollPtr->display, drawable,
  438. +              core, x+i,(unsigned)(y-(int)(s-0.5)),
  439. +              x+i,(unsigned)(y+(int)(s-0.5)));
  440. +        /* anti-aliasing */    
  441. +        if ((int)(s+0.5)!=(int)s) {
  442. +        XDrawPoint(scrollPtr->display, drawable,
  443. +               border, x+i,(unsigned)(y+(int)s));
  444. +        XDrawPoint(scrollPtr->display, drawable,
  445. +               border, x+i,(unsigned)(y-(int)s));
  446. +        }
  447. +    }
  448. +    break;
  449. +    }
  450. +}
  451. +
  452.  
  453.  /*
  454.   *--------------------------------------------------------------
  455. @@ -793,15 +1049,21 @@
  456.  {
  457.      register Scrollbar *scrollPtr = (Scrollbar *) clientData;
  458.      register Tk_Window tkwin = scrollPtr->tkwin;
  459. -    XPoint points[7];
  460.      Tk_3DBorder border;
  461. -    int relief, width, elementBorderWidth;
  462. +    int relief, width, elementBorderWidth, sliderSize, delta;
  463. +    int arrowl = scrollPtr->arrowLength;
  464.      Pixmap pixmap;
  465. +    int empty=0;    
  466. +
  467.  
  468.      if ((scrollPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
  469.      goto done;
  470.      }
  471.  
  472. +    if ((scrollPtr->firstFraction<=0.0) && (scrollPtr->lastFraction>=1.0)) {
  473. +    empty=1;
  474. +    }
  475. +    
  476.      if (scrollPtr->vertical) {
  477.      width = Tk_Width(tkwin) - 2*scrollPtr->inset;
  478.      } else {
  479. @@ -812,6 +1074,10 @@
  480.      elementBorderWidth = scrollPtr->borderWidth;
  481.      }
  482.  
  483. +    if (scrollPtr->bump == None) {
  484. +    MakePixmaps((ClientData)scrollPtr);
  485. +    }
  486. +
  487.      /*
  488.       * In order to avoid screen flashes, this procedure redraws
  489.       * the scrollbar in a pixmap, then copies the pixmap to the
  490. @@ -822,6 +1088,7 @@
  491.      pixmap = Tk_GetPixmap(scrollPtr->display, Tk_WindowId(tkwin),
  492.          Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
  493.  
  494. +    sliderSize = scrollPtr->sliderLast - scrollPtr->sliderFirst + 1;
  495.      if (scrollPtr->highlightWidth != 0) {
  496.      GC gc;
  497.  
  498. @@ -832,16 +1099,60 @@
  499.      }
  500.      Tk_DrawFocusHighlight(tkwin, gc, scrollPtr->highlightWidth, pixmap);
  501.      }
  502. -    Tk_Draw3DRectangle(tkwin, pixmap, scrollPtr->bgBorder,
  503. +    /*
  504. +     * Tk_Draw3DRectangle(tkwin, pixmap, scrollPtr->bgBorder,
  505.          scrollPtr->highlightWidth, scrollPtr->highlightWidth,
  506.          Tk_Width(tkwin) - 2*scrollPtr->highlightWidth,
  507.          Tk_Height(tkwin) - 2*scrollPtr->highlightWidth,
  508.          scrollPtr->borderWidth, scrollPtr->relief);
  509. -    XFillRectangle(scrollPtr->display, pixmap, scrollPtr->troughGC,
  510. -        scrollPtr->inset, scrollPtr->inset,
  511. -        (unsigned) (Tk_Width(tkwin) - 2*scrollPtr->inset),
  512. -        (unsigned) (Tk_Height(tkwin) - 2*scrollPtr->inset));
  513. +     */
  514. +    XFillRectangle(scrollPtr->display, pixmap, scrollPtr->troughBackGC,
  515. +    scrollPtr->highlightWidth, scrollPtr->highlightWidth,
  516. +     Tk_Width(tkwin) - 2*scrollPtr->highlightWidth,
  517. +      Tk_Height(tkwin) - 2*scrollPtr->highlightWidth);
  518. +    
  519. +    XDrawRectangle(scrollPtr->display, pixmap, 
  520. +    Tk_3DBorderGC(scrollPtr->tkwin,scrollPtr->bgBorder,TK_3D_DARK2_GC),
  521. +     scrollPtr->highlightWidth, scrollPtr->highlightWidth,
  522. +     Tk_Width(tkwin) - 2*scrollPtr->highlightWidth-1,
  523. +     Tk_Height(tkwin) - 2*scrollPtr->highlightWidth-1);
  524.  
  525. +    if (scrollPtr->vertical) {
  526. +    if (!empty) {
  527. +        XFillRectangle(scrollPtr->display, pixmap, scrollPtr->troughGC,
  528. +           scrollPtr->inset, scrollPtr->inset,
  529. +           (unsigned) (Tk_Width(tkwin) - 2*scrollPtr->inset),
  530. +           (unsigned) (Tk_Height(tkwin) + 1 -
  531. +           (scrollPtr->arrowLength + scrollPtr->inset)*2));
  532. +    } else {
  533. +        XFillRectangle(scrollPtr->display, pixmap, scrollPtr->troughGC,
  534. +           scrollPtr->inset, scrollPtr->inset,
  535. +           (unsigned) (Tk_Width(tkwin) - 2*scrollPtr->inset),
  536. +           (unsigned) (Tk_Height(tkwin) - 2*scrollPtr->inset));
  537. +    }
  538. +    } else {
  539. +    if (!empty) {
  540. +        XFillRectangle(scrollPtr->display, pixmap, scrollPtr->troughGC,
  541. +           scrollPtr->arrowLength * 2+2,
  542. +           scrollPtr->inset,
  543. +           (unsigned) (Tk_Width(tkwin) -
  544. +           (scrollPtr->arrowLength*2 + scrollPtr->inset*2)),
  545. +           (unsigned) (Tk_Height(tkwin) - 2*scrollPtr->inset));
  546. +    } else {
  547. +        XFillRectangle(scrollPtr->display, pixmap, scrollPtr->troughGC,
  548. +           scrollPtr->inset, scrollPtr->inset,
  549. +           (unsigned) (Tk_Width(tkwin) - 2*scrollPtr->inset),
  550. +           (unsigned) (Tk_Height(tkwin) - 2*scrollPtr->inset));
  551. +    }
  552. +    }
  553. +    
  554. +    /* 
  555. +     * don't draw slider/arrows if everything is visible
  556. +     */
  557. +    if (empty) {
  558. +    goto docopy;
  559. +    }    
  560. +    
  561.      /*
  562.       * Draw the top or left arrow.  The coordinates of the polygon
  563.       * points probably seem odd, but they were carefully chosen with
  564. @@ -849,33 +1160,42 @@
  565.       * cause the arrows to just fill the narrow dimension of the
  566.       * scrollbar and be properly centered.
  567.       */
  568. -
  569.      if (scrollPtr->activeField == TOP_ARROW) {
  570.      border = scrollPtr->activeBorder;
  571.      relief = scrollPtr->activeField == TOP_ARROW ? scrollPtr->activeRelief
  572.          : TK_RELIEF_RAISED;
  573. +    delta = (relief == TK_RELIEF_SUNKEN) ? scrollPtr->borderWidth/2+1 : 0;
  574.      } else {
  575.      border = scrollPtr->bgBorder;
  576.      relief = TK_RELIEF_RAISED;
  577. +    delta = 0;
  578.      }
  579. +    
  580.      if (scrollPtr->vertical) {
  581. -    points[0].x = scrollPtr->inset - 1;
  582. -    points[0].y = scrollPtr->arrowLength + scrollPtr->inset - 1;
  583. -    points[1].x = width + scrollPtr->inset;
  584. -    points[1].y = points[0].y;
  585. -    points[2].x = width/2 + scrollPtr->inset;
  586. -    points[2].y = scrollPtr->inset - 1;
  587. -    Tk_Fill3DPolygon(tkwin, pixmap, border, points, 3,
  588. +    Tk_Fill3DRectangle(tkwin, pixmap, border, scrollPtr->inset,
  589. +         Tk_Height(tkwin) - scrollPtr->arrowLength*2,
  590. +        scrollPtr->width, scrollPtr->width,
  591.          elementBorderWidth, relief);
  592. +    if (width >= 5) {
  593. +        DrawArrow(scrollPtr, pixmap, scrollPtr->inset+arrowl/2+delta
  594. +              -(2-(arrowl&1)),
  595. +              Tk_Height(tkwin) - (2-(arrowl&1)) + scrollPtr->inset/2 -
  596. +              arrowl*2 + (arrowl-scrollPtr->inset)/2+delta,
  597. +              arrowl-2*scrollPtr->inset-3, arrowl-2*scrollPtr->inset-3,
  598. +              ARROW_UP);
  599. +    }    
  600.      } else {
  601. -    points[0].x = scrollPtr->arrowLength + scrollPtr->inset - 1;
  602. -    points[0].y = scrollPtr->inset - 1;
  603. -    points[1].x = scrollPtr->inset;
  604. -    points[1].y = width/2 + scrollPtr->inset;
  605. -    points[2].x = points[0].x;
  606. -    points[2].y = width + scrollPtr->inset;
  607. -    Tk_Fill3DPolygon(tkwin, pixmap, border, points, 3,
  608. +    Tk_Fill3DRectangle(tkwin, pixmap, border,
  609. +         scrollPtr->inset, scrollPtr->inset,
  610. +        scrollPtr->width, scrollPtr->width,
  611.          elementBorderWidth, relief);
  612. +    if (width >= 5) {
  613. +        DrawArrow(scrollPtr, pixmap, 3*scrollPtr->inset/2 - (arrowl&1) +
  614. +              (arrowl-scrollPtr->inset)/2+delta,
  615. +              scrollPtr->inset+ arrowl/2-(arrowl&1)+delta,
  616. +              arrowl-2*scrollPtr->inset-3, arrowl-2*scrollPtr->inset-3,
  617. +              ARROW_LEFT);
  618. +    }
  619.      }
  620.  
  621.      /*
  622. @@ -886,40 +1206,48 @@
  623.      border = scrollPtr->activeBorder;
  624.      relief = scrollPtr->activeField == BOTTOM_ARROW
  625.          ? scrollPtr->activeRelief : TK_RELIEF_RAISED;
  626. +    delta = (relief == TK_RELIEF_SUNKEN) ? scrollPtr->borderWidth/2+1 : 0;
  627.      } else {
  628.      border = scrollPtr->bgBorder;
  629.      relief = TK_RELIEF_RAISED;
  630. +    delta = 0;
  631.      }
  632.      if (scrollPtr->vertical) {
  633. -    points[0].x = scrollPtr->inset;
  634. -    points[0].y = Tk_Height(tkwin) - scrollPtr->arrowLength
  635. -        - scrollPtr->inset + 1;
  636. -    points[1].x = width/2 + scrollPtr->inset;
  637. -    points[1].y = Tk_Height(tkwin) - scrollPtr->inset;
  638. -    points[2].x = width + scrollPtr->inset;
  639. -    points[2].y = points[0].y;
  640. -    Tk_Fill3DPolygon(tkwin, pixmap, border,
  641. -        points, 3, elementBorderWidth, relief);
  642. +    Tk_Fill3DRectangle(tkwin, pixmap, border, scrollPtr->inset,
  643. +         Tk_Height(tkwin) - scrollPtr->arrowLength,
  644. +        scrollPtr->width, scrollPtr->width,
  645. +        elementBorderWidth, relief);
  646. +    if (width >= 5 ) {
  647. +        DrawArrow(scrollPtr, pixmap, scrollPtr->inset+arrowl/2-
  648. +              (2-(arrowl&1))+delta,
  649. +              scrollPtr->inset/2+Tk_Height(tkwin) - (1-(arrowl&1)) -
  650. +              arrowl + (arrowl-scrollPtr->inset)/2+delta,
  651. +              arrowl-2*scrollPtr->inset-3, arrowl-2*scrollPtr->inset-3,
  652. +              ARROW_DOWN);        
  653. +    }    
  654.      } else {
  655. -    points[0].x = Tk_Width(tkwin) - scrollPtr->arrowLength
  656. -        - scrollPtr->inset + 1;
  657. -    points[0].y = scrollPtr->inset - 1;
  658. -    points[1].x = points[0].x;
  659. -    points[1].y = width + scrollPtr->inset;
  660. -    points[2].x = Tk_Width(tkwin) - scrollPtr->inset;
  661. -    points[2].y = width/2 + scrollPtr->inset;
  662. -    Tk_Fill3DPolygon(tkwin, pixmap, border,
  663. -        points, 3, elementBorderWidth, relief);
  664. +    Tk_Fill3DRectangle(tkwin, pixmap, border, 
  665. +         scrollPtr->inset + scrollPtr->arrowLength,
  666. +        scrollPtr->inset, scrollPtr->width, scrollPtr->width,
  667. +        elementBorderWidth, relief);
  668. +    if (width >= 5) {
  669. +        DrawArrow(scrollPtr, pixmap, 3*scrollPtr->inset/2+delta-
  670. +              (arrowl&1) + arrowl + (arrowl-scrollPtr->inset)/2,
  671. +              scrollPtr->inset+arrowl/2-(arrowl&1)+delta,
  672. +              arrowl-2*scrollPtr->inset-3, arrowl-2*scrollPtr->inset-3,
  673. +              ARROW_RIGHT);
  674. +    }
  675.      }
  676.  
  677. +
  678.      /*
  679.       * Display the slider.
  680.       */
  681.  
  682.      if (scrollPtr->activeField == SLIDER) {
  683.      border = scrollPtr->activeBorder;
  684. -    relief = scrollPtr->activeField == SLIDER ? scrollPtr->activeRelief
  685. -        : TK_RELIEF_RAISED;
  686. +    relief = /*scrollPtr->activeField == SLIDER ? scrollPtr->activeRelief
  687. +        :*/ TK_RELIEF_RAISED;
  688.      } else {
  689.      border = scrollPtr->bgBorder;
  690.      relief = TK_RELIEF_RAISED;
  691. @@ -927,20 +1255,32 @@
  692.      if (scrollPtr->vertical) {
  693.      Tk_Fill3DRectangle(tkwin, pixmap, border,
  694.          scrollPtr->inset, scrollPtr->sliderFirst,
  695. -        width, scrollPtr->sliderLast - scrollPtr->sliderFirst,
  696. +        width, sliderSize,
  697.          elementBorderWidth, relief);
  698. +    if ((sliderSize > SB_BUMP_HEIGHT*2) && (width > SB_BUMP_WIDTH)) {
  699. +        XCopyArea(scrollPtr->display, scrollPtr->bump, pixmap,
  700. +        scrollPtr->copyGC, 0, 0, SB_BUMP_WIDTH, SB_BUMP_HEIGHT,
  701. +        scrollPtr->inset + (width - SB_BUMP_WIDTH)/2-1, 
  702. +        scrollPtr->sliderFirst - 1  + (sliderSize - SB_BUMP_HEIGHT)/2);
  703. +    }
  704.      } else {
  705.      Tk_Fill3DRectangle(tkwin, pixmap, border,
  706.          scrollPtr->sliderFirst, scrollPtr->inset,
  707. -        scrollPtr->sliderLast - scrollPtr->sliderFirst, width,
  708. +        sliderSize-1, width,
  709.          elementBorderWidth, relief);
  710. +    if ((sliderSize > SB_BUMP_HEIGHT*2) && (width > SB_BUMP_HEIGHT)) {
  711. +        XCopyArea(scrollPtr->display, scrollPtr->bump, pixmap,
  712. +        scrollPtr->copyGC, 0, 0, SB_BUMP_WIDTH, SB_BUMP_HEIGHT,
  713. +        scrollPtr->sliderFirst + (sliderSize - SB_BUMP_HEIGHT)/2-1, 
  714. +        scrollPtr->inset - 1 + (width - SB_BUMP_WIDTH)/2);
  715. +    }
  716.      }
  717.  
  718.      /*
  719.       * Copy the information from the off-screen pixmap onto the screen,
  720.       * then delete the pixmap.
  721.       */
  722. -
  723. +    docopy:
  724.      XCopyArea(scrollPtr->display, pixmap, Tk_WindowId(tkwin),
  725.          scrollPtr->copyGC, 0, 0, (unsigned) Tk_Width(tkwin),
  726.          (unsigned) Tk_Height(tkwin), 0, 0);
  727. @@ -1106,8 +1446,13 @@
  728.      if (scrollPtr->sliderLast > fieldLength) {
  729.      scrollPtr->sliderLast = fieldLength;
  730.      }
  731. -    scrollPtr->sliderFirst += scrollPtr->arrowLength + scrollPtr->inset;
  732. -    scrollPtr->sliderLast += scrollPtr->arrowLength + scrollPtr->inset;
  733. +    if (scrollPtr->vertical) {    
  734. +    scrollPtr->sliderFirst += scrollPtr->inset;
  735. +    scrollPtr->sliderLast += scrollPtr->inset;
  736. +    } else {
  737. +    scrollPtr->sliderFirst += scrollPtr->arrowLength*2 + scrollPtr->inset;
  738. +    scrollPtr->sliderLast += scrollPtr->arrowLength*2 +scrollPtr->inset;
  739. +    }        
  740.  
  741.      /*
  742.       * Register the desired geometry for the window (leave enough space
  743. @@ -1177,20 +1522,35 @@
  744.       * All of the calculations in this procedure mirror those in
  745.       * DisplayScrollbar.  Be sure to keep the two consistent.
  746.       */
  747. -
  748. -    if (y < (scrollPtr->inset + scrollPtr->arrowLength)) {
  749. -    return TOP_ARROW;
  750. -    }
  751. -    if (y < scrollPtr->sliderFirst) {
  752. -    return TOP_GAP;
  753. -    }
  754. -    if (y < scrollPtr->sliderLast) {
  755. -    return SLIDER;
  756. -    }
  757. -    if (y >= (length - (scrollPtr->arrowLength + scrollPtr->inset))) {
  758. +    if (scrollPtr->vertical) {    
  759. +    if (y < scrollPtr->sliderFirst) {
  760. +        return TOP_GAP;
  761. +    }
  762. +    if (y < scrollPtr->sliderLast) {        
  763. +        return SLIDER;
  764. +    }
  765. +    if (y < (length - (scrollPtr->arrowLength*2 + scrollPtr->inset + 1))) {
  766. +        return BOTTOM_GAP;
  767. +    }
  768. +    if (y < (length - (scrollPtr->arrowLength + scrollPtr->inset))) {
  769. +        return TOP_ARROW;
  770. +    }
  771.      return BOTTOM_ARROW;
  772. +    } else {
  773. +    if (y < (scrollPtr->arrowLength + scrollPtr->inset)) {
  774. +        return TOP_ARROW;
  775. +    }
  776. +    if (y < (scrollPtr->arrowLength*2 + scrollPtr->inset + 1)) {
  777. +        return BOTTOM_ARROW;
  778. +    }
  779. +    if (y < (scrollPtr->sliderFirst)) {
  780. +        return TOP_GAP;
  781. +    }
  782. +    if (y < (scrollPtr->sliderLast)) {
  783. +        return SLIDER;
  784. +    }
  785. +    return BOTTOM_GAP;
  786.      }
  787. -    return BOTTOM_GAP;
  788.  }
  789.  
  790.  /*
  791.