/[dtapublic]/projs/ets/trunk/src/c_tk_base_7_5_w_mods/tkunixscale.c

Diff of /projs/ets/trunk/src/c_tk_base_7_5_w_mods/tkunixscale.c

Parent Directory | Revision Log | View Patch Patch

-revision 69 by dashley,
Sat Nov  5 10:54:17 2016 UTC
+revision 71 by dashley,
Sat Nov  5 11:07:06 2016 UTC
 Line 1
  /* $Header$ */
  /*
   * tkUnixScale.c --
   *
   *      This file implements the X specific portion of the scrollbar
   *      widget.
   *
   * Copyright (c) 1996 by Sun Microsystems, Inc.
   * Copyright (c) 1998-2000 by Scriptics Corporation.
   *
   * See the file "license.terms" for information on usage and redistribution
   * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
   *
   * RCS: @(#) $Id: tkunixscale.c,v 1.1.1.1 2001/06/13 05:11:27 dtashley Exp $
   */
  #include "tkScale.h"
  #include "tkInt.h"
  /*
   * Forward declarations for procedures defined later in this file:
   */
  static void             DisplayHorizontalScale _ANSI_ARGS_((TkScale *scalePtr,
                              Drawable drawable, XRectangle *drawnAreaPtr));
  static void             DisplayHorizontalValue _ANSI_ARGS_((TkScale *scalePtr,
                              Drawable drawable, double value, int top));
  static void             DisplayVerticalScale _ANSI_ARGS_((TkScale *scalePtr,
                              Drawable drawable, XRectangle *drawnAreaPtr));
  static void             DisplayVerticalValue _ANSI_ARGS_((TkScale *scalePtr,
                              Drawable drawable, double value, int rightEdge));
  /*
   *----------------------------------------------------------------------
   *
   * TkpCreateScale --
   *
   *      Allocate a new TkScale structure.
   *
   * Results:
   *      Returns a newly allocated TkScale structure.
   *
   * Side effects:
   *      None.
   *
   *----------------------------------------------------------------------
   */
  TkScale *
  TkpCreateScale(tkwin)
      Tk_Window tkwin;
  {
      return (TkScale *) ckalloc(sizeof(TkScale));
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkpDestroyScale --
   *
   *      Destroy a TkScale structure.  It's necessary to do this with
   *      Tcl_EventuallyFree to allow the Tcl_Preserve(scalePtr) to work
   *      as expected in TkpDisplayScale. (hobbs)
   *
   * Results:
   *      None
   *
   * Side effects:
   *      Memory is freed.
   *
   *----------------------------------------------------------------------
   */
  void
  TkpDestroyScale(scalePtr)
      TkScale *scalePtr;
  {
      Tcl_EventuallyFree((ClientData) scalePtr, TCL_DYNAMIC);
  }
  /*
   *--------------------------------------------------------------
   *
   * DisplayVerticalScale --
   *
   *      This procedure redraws the contents of a vertical scale
   *      window.  It is invoked as a do-when-idle handler, so it only
   *      runs when there's nothing else for the application to do.
   *
   * Results:
   *      There is no return value.  If only a part of the scale needs
   *      to be redrawn, then drawnAreaPtr is modified to reflect the
   *      area that was actually modified.
   *
   * Side effects:
   *      Information appears on the screen.
   *
   *--------------------------------------------------------------
   */
  static void
  DisplayVerticalScale(scalePtr, drawable, drawnAreaPtr)
      TkScale *scalePtr;                  /* Widget record for scale. */
      Drawable drawable;                  /* Where to display scale (window
                                           * or pixmap). */
      XRectangle *drawnAreaPtr;           /* Initally contains area of window;
                                           * if only a part of the scale is
                                           * redrawn, gets modified to reflect
                                           * the part of the window that was
                                           * redrawn. */
  {
      Tk_Window tkwin = scalePtr->tkwin;
      int x, y, width, height, shadowWidth;
      double tickValue, tickInterval = scalePtr->tickInterval;
      Tk_3DBorder sliderBorder;
      /*
       * Display the information from left to right across the window.
       */
      if (!(scalePtr->flags & REDRAW_OTHER)) {
          drawnAreaPtr->x = scalePtr->vertTickRightX;
          drawnAreaPtr->y = scalePtr->inset;
          drawnAreaPtr->width = scalePtr->vertTroughX + scalePtr->width
                  + 2*scalePtr->borderWidth - scalePtr->vertTickRightX;
          drawnAreaPtr->height -= 2*scalePtr->inset;
      }
      Tk_Fill3DRectangle(tkwin, drawable, scalePtr->bgBorder,
              drawnAreaPtr->x, drawnAreaPtr->y, drawnAreaPtr->width,
              drawnAreaPtr->height, 0, TK_RELIEF_FLAT);
      if (scalePtr->flags & REDRAW_OTHER) {
          /*
           * Display the tick marks.
           */
          if (tickInterval != 0) {
              double ticks, maxTicks;
              /*
               * Ensure that we will only draw enough of the tick values
               * such that they don't overlap
               */
              ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
                      / tickInterval);
              maxTicks = (double) Tk_Height(tkwin)
                  / (double) scalePtr->fontHeight;
              if (ticks > maxTicks) {
                  tickInterval *= (ticks / maxTicks);
              }
              for (tickValue = scalePtr->fromValue; ;
                   tickValue += tickInterval) {
                  /*
                   * The TkRoundToResolution call gets rid of accumulated
                   * round-off errors, if any.
                   */
                  tickValue = TkRoundToResolution(scalePtr, tickValue);
                  if (scalePtr->toValue >= scalePtr->fromValue) {
                      if (tickValue > scalePtr->toValue) {
                          break;
                      }
                  } else {
                      if (tickValue < scalePtr->toValue) {
                          break;
                      }
                  }
                  DisplayVerticalValue(scalePtr, drawable, tickValue,
                          scalePtr->vertTickRightX);
              }
          }
      }
      /*
       * Display the value, if it is desired.
       */
      if (scalePtr->showValue) {
          DisplayVerticalValue(scalePtr, drawable, scalePtr->value,
                  scalePtr->vertValueRightX);
      }
      /*
       * Display the trough and the slider.
       */
      Tk_Draw3DRectangle(tkwin, drawable,
              scalePtr->bgBorder, scalePtr->vertTroughX, scalePtr->inset,
              scalePtr->width + 2*scalePtr->borderWidth,
              Tk_Height(tkwin) - 2*scalePtr->inset, scalePtr->borderWidth,
              TK_RELIEF_SUNKEN);
      XFillRectangle(scalePtr->display, drawable, scalePtr->troughGC,
              scalePtr->vertTroughX + scalePtr->borderWidth,
              scalePtr->inset + scalePtr->borderWidth,
              (unsigned) scalePtr->width,
              (unsigned) (Tk_Height(tkwin) - 2*scalePtr->inset
                  - 2*scalePtr->borderWidth));
      if (scalePtr->state == STATE_ACTIVE) {
          sliderBorder = scalePtr->activeBorder;
      } else {
          sliderBorder = scalePtr->bgBorder;
      }
      width = scalePtr->width;
      height = scalePtr->sliderLength/2;
      x = scalePtr->vertTroughX + scalePtr->borderWidth;
      y = TkScaleValueToPixel(scalePtr, scalePtr->value) - height;
      shadowWidth = scalePtr->borderWidth/2;
      if (shadowWidth == 0) {
          shadowWidth = 1;
      }
      Tk_Draw3DRectangle(tkwin, drawable, sliderBorder, x, y, width,
 *height, shadowWidth, scalePtr->sliderRelief);
      x += shadowWidth;
      y += shadowWidth;
      width -= 2*shadowWidth;
      height -= shadowWidth;
      Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y, width,
              height, shadowWidth, scalePtr->sliderRelief);
      Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y+height,
              width, height, shadowWidth, scalePtr->sliderRelief);
      /*
       * Draw the label to the right of the scale.
       */
      if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelLength != 0)) {
          Tk_FontMetrics fm;
          Tk_GetFontMetrics(scalePtr->tkfont, &fm);
          Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
                  scalePtr->tkfont, scalePtr->label,
                  scalePtr->labelLength, scalePtr->vertLabelX,
                  scalePtr->inset + (3*fm.ascent)/2);
      }
  }
  /*
   *----------------------------------------------------------------------
   *
   * DisplayVerticalValue --
   *
   *      This procedure is called to display values (scale readings)
   *      for vertically-oriented scales.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The numerical value corresponding to value is displayed with
   *      its right edge at "rightEdge", and at a vertical position in
   *      the scale that corresponds to "value".
   *
   *----------------------------------------------------------------------
   */
  static void
  DisplayVerticalValue(scalePtr, drawable, value, rightEdge)
      register TkScale *scalePtr; /* Information about widget in which to
                                   * display value. */
      Drawable drawable;          /* Pixmap or window in which to draw
                                   * the value. */
      double value;               /* Y-coordinate of number to display,
                                   * specified in application coords, not
                                   * in pixels (we'll compute pixels). */
      int rightEdge;              /* X-coordinate of right edge of text,
                                   * specified in pixels. */
  {
      register Tk_Window tkwin = scalePtr->tkwin;
      int y, width, length;
      char valueString[PRINT_CHARS];
      Tk_FontMetrics fm;
      Tk_GetFontMetrics(scalePtr->tkfont, &fm);
      y = TkScaleValueToPixel(scalePtr, value) + fm.ascent/2;
      sprintf(valueString, scalePtr->format, value);
      length = strlen(valueString);
      width = Tk_TextWidth(scalePtr->tkfont, valueString, length);
      /*
       * Adjust the y-coordinate if necessary to keep the text entirely
       * inside the window.
       */
      if ((y - fm.ascent) < (scalePtr->inset + SPACING)) {
          y = scalePtr->inset + SPACING + fm.ascent;
      }
      if ((y + fm.descent) > (Tk_Height(tkwin) - scalePtr->inset - SPACING)) {
          y = Tk_Height(tkwin) - scalePtr->inset - SPACING - fm.descent;
      }
      Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
              scalePtr->tkfont, valueString, length, rightEdge - width, y);
  }
  /*
   *--------------------------------------------------------------
   *
   * DisplayHorizontalScale --
   *
   *      This procedure redraws the contents of a horizontal scale
   *      window.  It is invoked as a do-when-idle handler, so it only
   *      runs when there's nothing else for the application to do.
   *
   * Results:
   *      There is no return value.  If only a part of the scale needs
   *      to be redrawn, then drawnAreaPtr is modified to reflect the
   *      area that was actually modified.
   *
   * Side effects:
   *      Information appears on the screen.
   *
   *--------------------------------------------------------------
   */
  static void
  DisplayHorizontalScale(scalePtr, drawable, drawnAreaPtr)
      TkScale *scalePtr;                  /* Widget record for scale. */
      Drawable drawable;                  /* Where to display scale (window
                                           * or pixmap). */
      XRectangle *drawnAreaPtr;           /* Initally contains area of window;
                                           * if only a part of the scale is
                                           * redrawn, gets modified to reflect
                                           * the part of the window that was
                                           * redrawn. */
  {
      register Tk_Window tkwin = scalePtr->tkwin;
      int x, y, width, height, shadowWidth;
      double tickValue, tickInterval = scalePtr->tickInterval;
      Tk_3DBorder sliderBorder;
      /*
       * Display the information from bottom to top across the window.
       */
      if (!(scalePtr->flags & REDRAW_OTHER)) {
          drawnAreaPtr->x = scalePtr->inset;
          drawnAreaPtr->y = scalePtr->horizValueY;
          drawnAreaPtr->width -= 2*scalePtr->inset;
          drawnAreaPtr->height = scalePtr->horizTroughY + scalePtr->width
                  + 2*scalePtr->borderWidth - scalePtr->horizValueY;
      }
      Tk_Fill3DRectangle(tkwin, drawable, scalePtr->bgBorder,
              drawnAreaPtr->x, drawnAreaPtr->y, drawnAreaPtr->width,
              drawnAreaPtr->height, 0, TK_RELIEF_FLAT);
      if (scalePtr->flags & REDRAW_OTHER) {
          /*
           * Display the tick marks.
           */
          if (tickInterval != 0) {
              char valueString[PRINT_CHARS];
              double ticks, maxTicks;
              /*
               * Ensure that we will only draw enough of the tick values
               * such that they don't overlap.  We base this off the width that
               * fromValue would take.  Not exact, but better than no constraint.
               */
              ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
                      / tickInterval);
              sprintf(valueString, scalePtr->format, scalePtr->fromValue);
              maxTicks = (double) Tk_Width(tkwin)
                  / (double) Tk_TextWidth(scalePtr->tkfont, valueString, -1);
              if (ticks > maxTicks) {
                  tickInterval *= (ticks / maxTicks);
              }
              for (tickValue = scalePtr->fromValue; ;
                   tickValue += tickInterval) {
                  /*
                   * The TkRoundToResolution call gets rid of accumulated
                   * round-off errors, if any.
                   */
                  tickValue = TkRoundToResolution(scalePtr, tickValue);
                  if (scalePtr->toValue >= scalePtr->fromValue) {
                      if (tickValue > scalePtr->toValue) {
                          break;
                      }
                  } else {
                      if (tickValue < scalePtr->toValue) {
                          break;
                      }
                  }
                  DisplayHorizontalValue(scalePtr, drawable, tickValue,
                          scalePtr->horizTickY);
              }
          }
      }
      /*
       * Display the value, if it is desired.
       */
      if (scalePtr->showValue) {
          DisplayHorizontalValue(scalePtr, drawable, scalePtr->value,
                  scalePtr->horizValueY);
      }
      /*
       * Display the trough and the slider.
       */
      y = scalePtr->horizTroughY;
      Tk_Draw3DRectangle(tkwin, drawable,
              scalePtr->bgBorder, scalePtr->inset, y,
              Tk_Width(tkwin) - 2*scalePtr->inset,
              scalePtr->width + 2*scalePtr->borderWidth,
              scalePtr->borderWidth, TK_RELIEF_SUNKEN);
      XFillRectangle(scalePtr->display, drawable, scalePtr->troughGC,
              scalePtr->inset + scalePtr->borderWidth,
              y + scalePtr->borderWidth,
              (unsigned) (Tk_Width(tkwin) - 2*scalePtr->inset
                  - 2*scalePtr->borderWidth),
              (unsigned) scalePtr->width);
      if (scalePtr->state == STATE_ACTIVE) {
          sliderBorder = scalePtr->activeBorder;
      } else {
          sliderBorder = scalePtr->bgBorder;
      }
      width = scalePtr->sliderLength/2;
      height = scalePtr->width;
      x = TkScaleValueToPixel(scalePtr, scalePtr->value) - width;
      y += scalePtr->borderWidth;
      shadowWidth = scalePtr->borderWidth/2;
      if (shadowWidth == 0) {
          shadowWidth = 1;
      }
      Tk_Draw3DRectangle(tkwin, drawable, sliderBorder,
              x, y, 2*width, height, shadowWidth, scalePtr->sliderRelief);
      x += shadowWidth;
      y += shadowWidth;
      width -= shadowWidth;
      height -= 2*shadowWidth;
      Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y, width, height,
              shadowWidth, scalePtr->sliderRelief);
      Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x+width, y,
              width, height, shadowWidth, scalePtr->sliderRelief);
      /*
       * Draw the label at the top of the scale.
       */
      if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelLength != 0)) {
          Tk_FontMetrics fm;
          Tk_GetFontMetrics(scalePtr->tkfont, &fm);
          Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
                  scalePtr->tkfont, scalePtr->label,
                  scalePtr->labelLength, scalePtr->inset + fm.ascent/2,
                  scalePtr->horizLabelY + fm.ascent);
      }
  }
  /*
   *----------------------------------------------------------------------
   *
   * DisplayHorizontalValue --
   *
   *      This procedure is called to display values (scale readings)
   *      for horizontally-oriented scales.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The numerical value corresponding to value is displayed with
   *      its bottom edge at "bottom", and at a horizontal position in
   *      the scale that corresponds to "value".
   *
   *----------------------------------------------------------------------
   */
  static void
  DisplayHorizontalValue(scalePtr, drawable, value, top)
      register TkScale *scalePtr; /* Information about widget in which to
                                   * display value. */
      Drawable drawable;          /* Pixmap or window in which to draw
                                   * the value. */
      double value;               /* X-coordinate of number to display,
                                   * specified in application coords, not
                                   * in pixels (we'll compute pixels). */
      int top;                    /* Y-coordinate of top edge of text,
                                   * specified in pixels. */
  {
      register Tk_Window tkwin = scalePtr->tkwin;
      int x, y, length, width;
      char valueString[PRINT_CHARS];
      Tk_FontMetrics fm;
      x = TkScaleValueToPixel(scalePtr, value);
      Tk_GetFontMetrics(scalePtr->tkfont, &fm);
      y = top + fm.ascent;
      sprintf(valueString, scalePtr->format, value);
      length = strlen(valueString);
      width = Tk_TextWidth(scalePtr->tkfont, valueString, length);
      /*
       * Adjust the x-coordinate if necessary to keep the text entirely
       * inside the window.
       */
      x -= (width)/2;
      if (x < (scalePtr->inset + SPACING)) {
          x = scalePtr->inset + SPACING;
      }
      if (x > (Tk_Width(tkwin) - scalePtr->inset)) {
          x = Tk_Width(tkwin) - scalePtr->inset - SPACING - width;
      }
      Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
              scalePtr->tkfont, valueString, length, x, y);
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkpDisplayScale --
   *
   *      This procedure is invoked as an idle handler to redisplay
   *      the contents of a scale widget.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The scale gets redisplayed.
   *
   *----------------------------------------------------------------------
   */
  void
  TkpDisplayScale(clientData)
      ClientData clientData;      /* Widget record for scale. */
  {
      TkScale *scalePtr = (TkScale *) clientData;
      Tk_Window tkwin = scalePtr->tkwin;
      Tcl_Interp *interp = scalePtr->interp;
      Pixmap pixmap;
      int result;
      char string[PRINT_CHARS];
      XRectangle drawnArea;
      scalePtr->flags &= ~REDRAW_PENDING;
      if ((scalePtr->tkwin == NULL) || !Tk_IsMapped(scalePtr->tkwin)) {
          goto done;
      }
      /*
       * Invoke the scale's command if needed.
       */
      Tcl_Preserve((ClientData) scalePtr);
      if ((scalePtr->flags & INVOKE_COMMAND) && (scalePtr->command != NULL)) {
          Tcl_Preserve((ClientData) interp);
          sprintf(string, scalePtr->format, scalePtr->value);
          result = Tcl_VarEval(interp, scalePtr->command, " ", string,
                  (char *) NULL);
          if (result != TCL_OK) {
              Tcl_AddErrorInfo(interp, "\n    (command executed by scale)");
              Tcl_BackgroundError(interp);
          }
          Tcl_Release((ClientData) interp);
      }
      scalePtr->flags &= ~INVOKE_COMMAND;
      if (scalePtr->flags & SCALE_DELETED) {
          Tcl_Release((ClientData) scalePtr);
          goto done;
      }
      Tcl_Release((ClientData) scalePtr);
      /*
       * In order to avoid screen flashes, this procedure redraws
       * the scale in a pixmap, then copies the pixmap to the
       * screen in a single operation.  This means that there's no
       * point in time where the on-sreen image has been cleared.
       */
      pixmap = Tk_GetPixmap(scalePtr->display, Tk_WindowId(tkwin),
              Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
      drawnArea.x = 0;
      drawnArea.y = 0;
      drawnArea.width = Tk_Width(tkwin);
      drawnArea.height = Tk_Height(tkwin);
      /*
       * Much of the redisplay is done totally differently for
       * horizontal and vertical scales.  Handle the part that's
       * different.
       */
      if (scalePtr->orient == ORIENT_VERTICAL) {
          DisplayVerticalScale(scalePtr, pixmap, &drawnArea);
      } else {
          DisplayHorizontalScale(scalePtr, pixmap, &drawnArea);
      }
      /*
       * Now handle the part of redisplay that is the same for
       * horizontal and vertical scales:  border and traversal
       * highlight.
       */
      if (scalePtr->flags & REDRAW_OTHER) {
          if (scalePtr->relief != TK_RELIEF_FLAT) {
              Tk_Draw3DRectangle(tkwin, pixmap, scalePtr->bgBorder,
                      scalePtr->highlightWidth, scalePtr->highlightWidth,
                      Tk_Width(tkwin) - 2*scalePtr->highlightWidth,
                      Tk_Height(tkwin) - 2*scalePtr->highlightWidth,
                      scalePtr->borderWidth, scalePtr->relief);
          }
          if (scalePtr->highlightWidth != 0) {
              GC gc;
              if (scalePtr->flags & GOT_FOCUS) {
                  gc = Tk_GCForColor(scalePtr->highlightColorPtr, pixmap);
              } else {
                  gc = Tk_GCForColor(
                          Tk_3DBorderColor(scalePtr->highlightBorder), pixmap);
              }
              Tk_DrawFocusHighlight(tkwin, gc, scalePtr->highlightWidth, pixmap);
          }
      }
      /*
       * Copy the information from the off-screen pixmap onto the screen,
       * then delete the pixmap.
       */
      XCopyArea(scalePtr->display, pixmap, Tk_WindowId(tkwin),
              scalePtr->copyGC, drawnArea.x, drawnArea.y, drawnArea.width,
              drawnArea.height, drawnArea.x, drawnArea.y);
      Tk_FreePixmap(scalePtr->display, pixmap);
      done:
      scalePtr->flags &= ~REDRAW_ALL;
  }
  /*
   *----------------------------------------------------------------------
   *
   * TkpScaleElement --
   *
   *      Determine which part of a scale widget lies under a given
   *      point.
   *
   * Results:
   *      The return value is either TROUGH1, SLIDER, TROUGH2, or
   *      OTHER, depending on which of the scale's active elements
   *      (if any) is under the point at (x,y).
   *
   * Side effects:
   *      None.
   *
   *----------------------------------------------------------------------
   */
  int
  TkpScaleElement(scalePtr, x, y)
      TkScale *scalePtr;          /* Widget record for scale. */
      int x, y;                   /* Coordinates within scalePtr's window. */
  {
      int sliderFirst;
      if (scalePtr->orient == ORIENT_VERTICAL) {
          if ((x < scalePtr->vertTroughX)
                  || (x >= (scalePtr->vertTroughX + 2*scalePtr->borderWidth +
                  scalePtr->width))) {
              return OTHER;
          }
          if ((y < scalePtr->inset)
                  || (y >= (Tk_Height(scalePtr->tkwin) - scalePtr->inset))) {
              return OTHER;
          }
          sliderFirst = TkScaleValueToPixel(scalePtr, scalePtr->value)
                  - scalePtr->sliderLength/2;
          if (y < sliderFirst) {
              return TROUGH1;
          }
          if (y < (sliderFirst+scalePtr->sliderLength)) {
              return SLIDER;
          }
          return TROUGH2;
      }
      if ((y < scalePtr->horizTroughY)
              || (y >= (scalePtr->horizTroughY + 2*scalePtr->borderWidth +
              scalePtr->width))) {
          return OTHER;
      }
      if ((x < scalePtr->inset)
              || (x >= (Tk_Width(scalePtr->tkwin) - scalePtr->inset))) {
          return OTHER;
      }
      sliderFirst = TkScaleValueToPixel(scalePtr, scalePtr->value)
              - scalePtr->sliderLength/2;
      if (x < sliderFirst) {
          return TROUGH1;
      }
      if (x < (sliderFirst+scalePtr->sliderLength)) {
          return SLIDER;
      }
      return TROUGH2;
  }
  /* End of tkunixscale.c */

 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
 Legend:



Removed from v.69
 


changed lines


 
Added in v.71
-Removed from v.69
+Added in v.71

dashley@gmail.com	ViewVC Help
Powered by ViewVC 1.1.25