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

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

Parent Directory | Revision Log | View Patch Patch

-projs/trunk/shared_source/c_tk_base_7_5_w_mods/tktextimage.c
revision 69 by dashley,
Sat Nov  5 10:54:17 2016 UTC
+projs/dtats/trunk/shared_source/c_tk_base_7_5_w_mods/tktextimage.c
revision 98 by dashley,
Sun Dec 18 00:57:31 2016 UTC
 Line 1
  /* $Header$ */
  /*
   * tkImage.c --
   *
   *      This file contains code that allows images to be
   *      nested inside text widgets.  It also implements the "image"
   *      widget command for texts.
   *
   * Copyright (c) 1997 Sun Microsystems, Inc.
   *
   * See the file "license.terms" for information on usage and redistribution
   * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
   *
   * RCS: @(#) $Id: tktextimage.c,v 1.1.1.1 2001/06/13 05:10:24 dtashley Exp $
   */
  #include "tk.h"
  #include "tkText.h"
  #include "tkPort.h"
  /*
   * Definitions for alignment values:
   */
  #define ALIGN_BOTTOM            0
  #define ALIGN_CENTER            1
  #define ALIGN_TOP               2
  #define ALIGN_BASELINE          3
  /*
   * Macro that determines the size of an embedded image segment:
   */
  #define EI_SEG_SIZE ((unsigned) (Tk_Offset(TkTextSegment, body) \
          + sizeof(TkTextEmbImage)))
  /*
   * Prototypes for procedures defined in this file:
   */
  static int              AlignParseProc _ANSI_ARGS_((ClientData clientData,
                              Tcl_Interp *interp, Tk_Window tkwin, char *value,
                              char *widgRec, int offset));
  static char *           AlignPrintProc _ANSI_ARGS_((ClientData clientData,
                              Tk_Window tkwin, char *widgRec, int offset,
                              Tcl_FreeProc **freeProcPtr));
  static TkTextSegment *  EmbImageCleanupProc _ANSI_ARGS_((TkTextSegment *segPtr,
                              TkTextLine *linePtr));
  static void             EmbImageCheckProc _ANSI_ARGS_((TkTextSegment *segPtr,
                              TkTextLine *linePtr));
  static void             EmbImageBboxProc _ANSI_ARGS_((TkTextDispChunk *chunkPtr,
                              int index, int y, int lineHeight, int baseline,
                              int *xPtr, int *yPtr, int *widthPtr,
                              int *heightPtr));
  static int              EmbImageConfigure _ANSI_ARGS_((TkText *textPtr,
                              TkTextSegment *eiPtr, int argc, char **argv));
  static int              EmbImageDeleteProc _ANSI_ARGS_((TkTextSegment *segPtr,
                              TkTextLine *linePtr, int treeGone));
  static void             EmbImageDisplayProc _ANSI_ARGS_((
                              TkTextDispChunk *chunkPtr, int x, int y,
                              int lineHeight, int baseline, Display *display,
                              Drawable dst, int screenY));
  static int              EmbImageLayoutProc _ANSI_ARGS_((TkText *textPtr,
                              TkTextIndex *indexPtr, TkTextSegment *segPtr,
                              int offset, int maxX, int maxChars,
                              int noCharsYet, TkWrapMode wrapMode,
                              TkTextDispChunk *chunkPtr));
  static void             EmbImageProc _ANSI_ARGS_((ClientData clientData,
                              int x, int y, int width, int height,
                              int imageWidth, int imageHeight));
  /*
   * The following structure declares the "embedded image" segment type.
   */
  static Tk_SegType tkTextEmbImageType = {
      "image",                                    /* name */
 ,                                          /* leftGravity */
      (Tk_SegSplitProc *) NULL,                   /* splitProc */
      EmbImageDeleteProc,                         /* deleteProc */
      EmbImageCleanupProc,                        /* cleanupProc */
      (Tk_SegLineChangeProc *) NULL,              /* lineChangeProc */
      EmbImageLayoutProc,                         /* layoutProc */
      EmbImageCheckProc                           /* checkProc */
  };
  /*
   * Information used for parsing image configuration options:
   */
  static Tk_CustomOption alignOption = {AlignParseProc, AlignPrintProc,
          (ClientData) NULL};
  static Tk_ConfigSpec configSpecs[] = {
      {TK_CONFIG_CUSTOM, "-align", (char *) NULL, (char *) NULL,
          "center", 0, TK_CONFIG_DONT_SET_DEFAULT, &alignOption},
      {TK_CONFIG_PIXELS, "-padx", (char *) NULL, (char *) NULL,
          "0", Tk_Offset(TkTextEmbImage, padX),
          TK_CONFIG_DONT_SET_DEFAULT},
      {TK_CONFIG_PIXELS, "-pady", (char *) NULL, (char *) NULL,
          "0", Tk_Offset(TkTextEmbImage, padY),
          TK_CONFIG_DONT_SET_DEFAULT},
      {TK_CONFIG_STRING, "-image", (char *) NULL, (char *) NULL,
          (char *) NULL, Tk_Offset(TkTextEmbImage, imageString),
          TK_CONFIG_DONT_SET_DEFAULT|TK_CONFIG_NULL_OK},
      {TK_CONFIG_STRING, "-name", (char *) NULL, (char *) NULL,
          (char *) NULL, Tk_Offset(TkTextEmbImage, imageName),
          TK_CONFIG_DONT_SET_DEFAULT|TK_CONFIG_NULL_OK},
      {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
          (char *) NULL, 0, 0}
  };
  /*
   *--------------------------------------------------------------
   *
   * TkTextImageCmd --
   *
   *      This procedure implements the "image" widget command
   *      for text widgets.  See the user documentation for details
   *      on what it does.
   *
   * Results:
   *      A standard Tcl result or error.
   *
   * Side effects:
   *      See the user documentation.
   *
   *--------------------------------------------------------------
   */
  int
  TkTextImageCmd(textPtr, interp, argc, argv)
      register TkText *textPtr;   /* Information about text widget. */
      Tcl_Interp *interp;         /* Current interpreter. */
      int argc;                   /* Number of arguments. */
      char **argv;                /* Argument strings.  Someone else has already
                                   * parsed this command enough to know that
                                   * argv[1] is "image". */
  {
      size_t length;
      register TkTextSegment *eiPtr;
      if (argc < 3) {
          Tcl_AppendResult(interp, "wrong # args: should be \"",
                  argv[0], " image option ?arg arg ...?\"", (char *) NULL);
          return TCL_ERROR;
      }
      length = strlen(argv[2]);
      if ((strncmp(argv[2], "cget", length) == 0) && (length >= 2)) {
          TkTextIndex index;
          TkTextSegment *eiPtr;
          if (argc != 5) {
              Tcl_AppendResult(interp, "wrong # args: should be \"",
                      argv[0], " image cget index option\"",
                      (char *) NULL);
              return TCL_ERROR;
          }
          if (TkTextGetIndex(interp, textPtr, argv[3], &index) != TCL_OK) {
              return TCL_ERROR;
          }
          eiPtr = TkTextIndexToSeg(&index, (int *) NULL);
          if (eiPtr->typePtr != &tkTextEmbImageType) {
              Tcl_AppendResult(interp, "no embedded image at index \"",
                      argv[3], "\"", (char *) NULL);
              return TCL_ERROR;
          }
          return Tk_ConfigureValue(interp, textPtr->tkwin, configSpecs,
                  (char *) &eiPtr->body.ei, argv[4], 0);
      } else if ((strncmp(argv[2], "configure", length) == 0) && (length >= 2)) {
          TkTextIndex index;
          TkTextSegment *eiPtr;
          if (argc < 4) {
              Tcl_AppendResult(interp, "wrong # args: should be \"",
                      argv[0], " image configure index ?option value ...?\"",
                      (char *) NULL);
              return TCL_ERROR;
          }
          if (TkTextGetIndex(interp, textPtr, argv[3], &index) != TCL_OK) {
              return TCL_ERROR;
          }
          eiPtr = TkTextIndexToSeg(&index, (int *) NULL);
          if (eiPtr->typePtr != &tkTextEmbImageType) {
              Tcl_AppendResult(interp, "no embedded image at index \"",
                      argv[3], "\"", (char *) NULL);
              return TCL_ERROR;
          }
          if (argc == 4) {
              return Tk_ConfigureInfo(interp, textPtr->tkwin, configSpecs,
                      (char *) &eiPtr->body.ei, (char *) NULL, 0);
          } else if (argc == 5) {
              return Tk_ConfigureInfo(interp, textPtr->tkwin, configSpecs,
                      (char *) &eiPtr->body.ei, argv[4], 0);
          } else {
              TkTextChanged(textPtr, &index, &index);
              return EmbImageConfigure(textPtr, eiPtr, argc-4, argv+4);
          }
      } else if ((strncmp(argv[2], "create", length) == 0) && (length >= 2)) {
          TkTextIndex index;
          int lineIndex;
          /*
           * Add a new image.  Find where to put the new image, and
           * mark that position for redisplay.
           */
          if (argc < 4) {
              Tcl_AppendResult(interp, "wrong # args: should be \"",
                      argv[0], " image create index ?option value ...?\"",
                      (char *) NULL);
              return TCL_ERROR;
          }
          if (TkTextGetIndex(interp, textPtr, argv[3], &index) != TCL_OK) {
              return TCL_ERROR;
          }
          /*
           * Don't allow insertions on the last (dummy) line of the text.
           */
          lineIndex = TkBTreeLineIndex(index.linePtr);
          if (lineIndex == TkBTreeNumLines(textPtr->tree)) {
              lineIndex--;
              TkTextMakeByteIndex(textPtr->tree, lineIndex, 1000000, &index);
          }
          /*
           * Create the new image segment and initialize it.
           */
          eiPtr = (TkTextSegment *) ckalloc(EI_SEG_SIZE);
          eiPtr->typePtr = &tkTextEmbImageType;
          eiPtr->size = 1;
          eiPtr->body.ei.textPtr = textPtr;
          eiPtr->body.ei.linePtr = NULL;
          eiPtr->body.ei.imageName = NULL;
          eiPtr->body.ei.imageString = NULL;
          eiPtr->body.ei.name = NULL;
          eiPtr->body.ei.image = NULL;
          eiPtr->body.ei.align = ALIGN_CENTER;
          eiPtr->body.ei.padX = eiPtr->body.ei.padY = 0;
          eiPtr->body.ei.chunkCount = 0;
          /*
           * Link the segment into the text widget, then configure it (delete
           * it again if the configuration fails).
           */
          TkTextChanged(textPtr, &index, &index);
          TkBTreeLinkSegment(eiPtr, &index);
          if (EmbImageConfigure(textPtr, eiPtr, argc-4, argv+4) != TCL_OK) {
              TkTextIndex index2;
              TkTextIndexForwChars(&index, 1, &index2);
              TkBTreeDeleteChars(&index, &index2);
              return TCL_ERROR;
          }
      } else if (strncmp(argv[2], "names", length) == 0) {
          Tcl_HashSearch search;
          Tcl_HashEntry *hPtr;
          if (argc != 3) {
              Tcl_AppendResult(interp, "wrong # args: should be \"",
                      argv[0], " image names\"", (char *) NULL);
              return TCL_ERROR;
          }
          for (hPtr = Tcl_FirstHashEntry(&textPtr->imageTable, &search);
                  hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
              Tcl_AppendElement(interp,
                      Tcl_GetHashKey(&textPtr->markTable, hPtr));
          }
      } else {
          Tcl_AppendResult(interp, "bad image option \"", argv[2],
                  "\": must be cget, configure, create, or names",
                  (char *) NULL);
          return TCL_ERROR;
      }
      return TCL_OK;
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageConfigure --
   *
   *      This procedure is called to handle configuration options
   *      for an embedded image, using an argc/argv list.
   *
   * Results:
   *      The return value is a standard Tcl result.  If TCL_ERROR is
   *      returned, then the interp's result contains an error message..
   *
   * Side effects:
   *      Configuration information for the embedded image changes,
   *      such as alignment, or name of the image.
   *
   *--------------------------------------------------------------
   */
  static int
  EmbImageConfigure(textPtr, eiPtr, argc, argv)
      TkText *textPtr;            /* Information about text widget that
                                   * contains embedded image. */
      TkTextSegment *eiPtr;       /* Embedded image to be configured. */
      int argc;                   /* Number of strings in argv. */
      char **argv;                /* Array of strings describing configuration
                                   * options. */
  {
      Tk_Image image;
      Tcl_DString newName;
      Tcl_HashEntry *hPtr;
      Tcl_HashSearch search;
      int new;
      char *name;
      int count = 0;              /* The counter for picking a unique name */
      int conflict = 0;           /* True if we have a name conflict */
      unsigned int len;           /* length of image name */
      if (Tk_ConfigureWidget(textPtr->interp, textPtr->tkwin, configSpecs,
              argc, argv, (char *) &eiPtr->body.ei,TK_CONFIG_ARGV_ONLY)
              != TCL_OK) {
          return TCL_ERROR;
      }
      /*
       * Create the image.  Save the old image around and don't free it
       * until after the new one is allocated.  This keeps the reference
       * count from going to zero so the image doesn't have to be recreated
       * if it hasn't changed.
       */
      if (eiPtr->body.ei.imageString != NULL) {
          image = Tk_GetImage(textPtr->interp, textPtr->tkwin, eiPtr->body.ei.imageString,
                  EmbImageProc, (ClientData) eiPtr);
          if (image == NULL) {
              return TCL_ERROR;
          }
      } else {
          image = NULL;
      }
      if (eiPtr->body.ei.image != NULL) {
          Tk_FreeImage(eiPtr->body.ei.image);
      }
      eiPtr->body.ei.image = image;
      if (eiPtr->body.ei.name != NULL) {
          return TCL_OK;
      }
      /*
       * Find a unique name for this image.  Use imageName (or imageString)
       * if available, otherwise tack on a #nn and use it.  If a name is already
       * associated with this image, delete the name.
       */
      name = eiPtr->body.ei.imageName;
      if (name == NULL) {
          name = eiPtr->body.ei.imageString;
      }
      if (name == NULL) {
          Tcl_AppendResult(textPtr->interp,"Either a \"-name\" ",
                  "or a \"-image\" argument must be provided ",
                  "to the \"image create\" subcommand.",
                  (char *) NULL);
          return TCL_ERROR;
      }
      len = strlen(name);
      for (hPtr = Tcl_FirstHashEntry(&textPtr->imageTable, &search);
              hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
          char *haveName = Tcl_GetHashKey(&textPtr->imageTable, hPtr);
          if (strncmp(name, haveName, len) == 0) {
              new = 0;
              sscanf(haveName+len,"#%d",&new);
              if (new > count) {
                  count = new;
              }
              if (len == (int) strlen(haveName)) {
                  conflict = 1;
              }
          }
      }
      Tcl_DStringInit(&newName);
      Tcl_DStringAppend(&newName,name, -1);
      if (conflict) {
          char buf[4 + TCL_INTEGER_SPACE];
          sprintf(buf, "#%d",count+1);
          Tcl_DStringAppend(&newName,buf, -1);
      }
      name = Tcl_DStringValue(&newName);
      hPtr = Tcl_CreateHashEntry(&textPtr->imageTable, name, &new);
      Tcl_SetHashValue(hPtr, eiPtr);
      Tcl_AppendResult(textPtr->interp, name , (char *) NULL);
      eiPtr->body.ei.name = ckalloc((unsigned) Tcl_DStringLength(&newName)+1);
      strcpy(eiPtr->body.ei.name,name);
      Tcl_DStringFree(&newName);
      return TCL_OK;
  }
  /*
   *--------------------------------------------------------------
   *
   * AlignParseProc --
   *
   *      This procedure is invoked by Tk_ConfigureWidget during
   *      option processing to handle "-align" options for embedded
   *      images.
   *
   * Results:
   *      A standard Tcl return value.
   *
   * Side effects:
   *      The alignment for the embedded image may change.
   *
   *--------------------------------------------------------------
   */
          /* ARGSUSED */
  static int
  AlignParseProc(clientData, interp, tkwin, value, widgRec, offset)
      ClientData clientData;              /* Not used.*/
      Tcl_Interp *interp;                 /* Used for reporting errors. */
      Tk_Window tkwin;                    /* Window for text widget. */
      char *value;                        /* Value of option. */
      char *widgRec;                      /* Pointer to TkTextEmbWindow
                                           * structure. */
      int offset;                         /* Offset into item (ignored). */
  {
      register TkTextEmbImage *embPtr = (TkTextEmbImage *) widgRec;
      if (strcmp(value, "baseline") == 0) {
          embPtr->align = ALIGN_BASELINE;
      } else if (strcmp(value, "bottom") == 0) {
          embPtr->align = ALIGN_BOTTOM;
      } else if (strcmp(value, "center") == 0) {
          embPtr->align = ALIGN_CENTER;
      } else if (strcmp(value, "top") == 0) {
          embPtr->align = ALIGN_TOP;
      } else {
          Tcl_AppendResult(interp, "bad alignment \"", value,
                  "\": must be baseline, bottom, center, or top",
                  (char *) NULL);
          return TCL_ERROR;
      }
      return TCL_OK;
  }
  /*
   *--------------------------------------------------------------
   *
   * AlignPrintProc --
   *
   *      This procedure is invoked by the Tk configuration code
   *      to produce a printable string for the "-align" configuration
   *      option for embedded images.
   *
   * Results:
   *      The return value is a string describing the embedded
   *      images's current alignment.
   *
   * Side effects:
   *      None.
   *
   *--------------------------------------------------------------
   */
          /* ARGSUSED */
  static char *
  AlignPrintProc(clientData, tkwin, widgRec, offset, freeProcPtr)
      ClientData clientData;              /* Ignored. */
      Tk_Window tkwin;                    /* Window for text widget. */
      char *widgRec;                      /* Pointer to TkTextEmbImage
                                           * structure. */
      int offset;                         /* Ignored. */
      Tcl_FreeProc **freeProcPtr;         /* Pointer to variable to fill in with
                                           * information about how to reclaim
                                           * storage for return string. */
  {
      switch (((TkTextEmbImage *) widgRec)->align) {
          case ALIGN_BASELINE:
              return "baseline";
          case ALIGN_BOTTOM:
              return "bottom";
          case ALIGN_CENTER:
              return "center";
          case ALIGN_TOP:
              return "top";
          default:
              return "??";
      }
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageDeleteProc --
   *
   *      This procedure is invoked by the text B-tree code whenever
   *      an embedded image lies in a range of characters being deleted.
   *
   * Results:
   *      Returns 0 to indicate that the deletion has been accepted.
   *
   * Side effects:
   *      The embedded image is deleted, if it exists, and any resources
   *      associated with it are released.
   *
   *--------------------------------------------------------------
   */
          /* ARGSUSED */
  static int
  EmbImageDeleteProc(eiPtr, linePtr, treeGone)
      TkTextSegment *eiPtr;               /* Segment being deleted. */
      TkTextLine *linePtr;                /* Line containing segment. */
      int treeGone;                       /* Non-zero means the entire tree is
                                           * being deleted, so everything must
                                           * get cleaned up. */
  {
      Tcl_HashEntry *hPtr;
      if (eiPtr->body.ei.image != NULL) {
          hPtr = Tcl_FindHashEntry(&eiPtr->body.ei.textPtr->imageTable,
                  eiPtr->body.ei.name);
          if (hPtr != NULL) {
              /*
               * (It's possible for there to be no hash table entry for this
               * image, if an error occurred while creating the image segment
               * but before the image got added to the table)
               */
              Tcl_DeleteHashEntry(hPtr);
          }
          Tk_FreeImage(eiPtr->body.ei.image);
      }
      Tk_FreeOptions(configSpecs, (char *) &eiPtr->body.ei,
              eiPtr->body.ei.textPtr->display, 0);
      if (eiPtr->body.ei.name != NULL) {
          ckfree(eiPtr->body.ei.name);
      }
      ckfree((char *) eiPtr);
      return 0;
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageCleanupProc --
   *
   *      This procedure is invoked by the B-tree code whenever a
   *      segment containing an embedded image is moved from one
   *      line to another.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The linePtr field of the segment gets updated.
   *
   *--------------------------------------------------------------
   */
  static TkTextSegment *
  EmbImageCleanupProc(eiPtr, linePtr)
      TkTextSegment *eiPtr;               /* Mark segment that's being moved. */
      TkTextLine *linePtr;                /* Line that now contains segment. */
  {
      eiPtr->body.ei.linePtr = linePtr;
      return eiPtr;
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageLayoutProc --
   *
   *      This procedure is the "layoutProc" for embedded image
   *      segments.
   *
   * Results:
   *      1 is returned to indicate that the segment should be
   *      displayed.  The chunkPtr structure is filled in.
   *
   * Side effects:
   *      None, except for filling in chunkPtr.
   *
   *--------------------------------------------------------------
   */
          /*ARGSUSED*/
  static int
  EmbImageLayoutProc(textPtr, indexPtr, eiPtr, offset, maxX, maxChars,
          noCharsYet, wrapMode, chunkPtr)
      TkText *textPtr;            /* Text widget being layed out. */
      TkTextIndex *indexPtr;      /* Identifies first character in chunk. */
      TkTextSegment *eiPtr;       /* Segment corresponding to indexPtr. */
      int offset;                 /* Offset within segPtr corresponding to
                                   * indexPtr (always 0). */
      int maxX;                   /* Chunk must not occupy pixels at this
                                   * position or higher. */
      int maxChars;               /* Chunk must not include more than this
                                   * many characters. */
      int noCharsYet;             /* Non-zero means no characters have been
                                   * assigned to this line yet. */
      TkWrapMode wrapMode;        /* Wrap mode to use for line: TEXT_WRAPMODE_CHAR,
                                   * TEXT_WRAPMODE_NONE, or TEXT_WRAPMODE_WORD. */
      register TkTextDispChunk *chunkPtr;
                                  /* Structure to fill in with information
                                   * about this chunk.  The x field has already
                                   * been set by the caller. */
  {
      int width, height;
      if (offset != 0) {
          panic("Non-zero offset in EmbImageLayoutProc");
      }
      /*
       * See if there's room for this image on this line.
       */
      if (eiPtr->body.ei.image == NULL) {
          width = 0;
          height = 0;
      } else {
          Tk_SizeOfImage(eiPtr->body.ei.image, &width, &height);
          width += 2*eiPtr->body.ei.padX;
          height += 2*eiPtr->body.ei.padY;
      }
      if ((width > (maxX - chunkPtr->x))
              && !noCharsYet && (textPtr->wrapMode != TEXT_WRAPMODE_NONE)) {
          return 0;
      }
      /*
       * Fill in the chunk structure.
       */
      chunkPtr->displayProc = EmbImageDisplayProc;
      chunkPtr->undisplayProc = (Tk_ChunkUndisplayProc *) NULL;
      chunkPtr->measureProc = (Tk_ChunkMeasureProc *) NULL;
      chunkPtr->bboxProc = EmbImageBboxProc;
      chunkPtr->numBytes = 1;
      if (eiPtr->body.ei.align == ALIGN_BASELINE) {
          chunkPtr->minAscent = height - eiPtr->body.ei.padY;
          chunkPtr->minDescent = eiPtr->body.ei.padY;
          chunkPtr->minHeight = 0;
      } else {
          chunkPtr->minAscent = 0;
          chunkPtr->minDescent = 0;
          chunkPtr->minHeight = height;
      }
      chunkPtr->width = width;
      chunkPtr->breakIndex = -1;
      chunkPtr->breakIndex = 1;
      chunkPtr->clientData = (ClientData) eiPtr;
      eiPtr->body.ei.chunkCount += 1;
      return 1;
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageCheckProc --
   *
   *      This procedure is invoked by the B-tree code to perform
   *      consistency checks on embedded images.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The procedure panics if it detects anything wrong with
   *      the embedded image.
   *
   *--------------------------------------------------------------
   */
  static void
  EmbImageCheckProc(eiPtr, linePtr)
      TkTextSegment *eiPtr;               /* Segment to check. */
      TkTextLine *linePtr;                /* Line containing segment. */
  {
      if (eiPtr->nextPtr == NULL) {
          panic("EmbImageCheckProc: embedded image is last segment in line");
      }
      if (eiPtr->size != 1) {
          panic("EmbImageCheckProc: embedded image has size %d", eiPtr->size);
      }
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageDisplayProc --
   *
   *      This procedure is invoked by the text displaying code
   *      when it is time to actually draw an embedded image
   *      chunk on the screen.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The embedded image gets moved to the correct location
   *      and drawn onto the display.
   *
   *--------------------------------------------------------------
   */
  static void
  EmbImageDisplayProc(chunkPtr, x, y, lineHeight, baseline, display, dst, screenY)
      TkTextDispChunk *chunkPtr;          /* Chunk that is to be drawn. */
      int x;                              /* X-position in dst at which to
                                           * draw this chunk (differs from
                                           * the x-position in the chunk because
                                           * of scrolling). */
      int y;                              /* Top of rectangular bounding box
                                           * for line: tells where to draw this
                                           * chunk in dst (x-position is in
                                           * the chunk itself). */
      int lineHeight;                     /* Total height of line. */
      int baseline;                       /* Offset of baseline from y. */
      Display *display;                   /* Display to use for drawing. */
      Drawable dst;                       /* Pixmap or window in which to draw */
      int screenY;                        /* Y-coordinate in text window that
                                           * corresponds to y. */
  {
      TkTextSegment *eiPtr = (TkTextSegment *) chunkPtr->clientData;
      int lineX, imageX, imageY, width, height;
      Tk_Image image;
      image = eiPtr->body.ei.image;
      if (image == NULL) {
          return;
      }
      if ((x + chunkPtr->width) <= 0) {
          return;
      }
      /*
       * Compute the image's location and size in the text widget, taking
       * into account the align value for the image.
       */
      EmbImageBboxProc(chunkPtr, 0, y, lineHeight, baseline, &lineX,
              &imageY, &width, &height);
      imageX = lineX - chunkPtr->x + x;
      Tk_RedrawImage(image, 0, 0, width, height, dst,
              imageX, imageY);
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageBboxProc --
   *
   *      This procedure is called to compute the bounding box of
   *      the area occupied by an embedded image.
   *
   * Results:
   *      There is no return value.  *xPtr and *yPtr are filled in
   *      with the coordinates of the upper left corner of the
   *      image, and *widthPtr and *heightPtr are filled in with
   *      the dimensions of the image in pixels.  Note:  not all
   *      of the returned bbox is necessarily visible on the screen
   *      (the rightmost part might be off-screen to the right,
   *      and the bottommost part might be off-screen to the bottom).
   *
   * Side effects:
   *      None.
   *
   *--------------------------------------------------------------
   */
  static void
  EmbImageBboxProc(chunkPtr, index, y, lineHeight, baseline, xPtr, yPtr,
          widthPtr, heightPtr)
      TkTextDispChunk *chunkPtr;          /* Chunk containing desired char. */
      int index;                          /* Index of desired character within
                                           * the chunk. */
      int y;                              /* Topmost pixel in area allocated
                                           * for this line. */
      int lineHeight;                     /* Total height of line. */
      int baseline;                       /* Location of line's baseline, in
                                           * pixels measured down from y. */
      int *xPtr, *yPtr;                   /* Gets filled in with coords of
                                           * character's upper-left pixel. */
      int *widthPtr;                      /* Gets filled in with width of
                                           * character, in pixels. */
      int *heightPtr;                     /* Gets filled in with height of
                                           * character, in pixels. */
  {
      TkTextSegment *eiPtr = (TkTextSegment *) chunkPtr->clientData;
      Tk_Image image;
      image = eiPtr->body.ei.image;
      if (image != NULL) {
          Tk_SizeOfImage(image, widthPtr, heightPtr);
      } else {
          *widthPtr = 0;
          *heightPtr = 0;
      }
      *xPtr = chunkPtr->x + eiPtr->body.ei.padX;
      switch (eiPtr->body.ei.align) {
          case ALIGN_BOTTOM:
              *yPtr = y + (lineHeight - *heightPtr - eiPtr->body.ei.padY);
              break;
          case ALIGN_CENTER:
              *yPtr = y + (lineHeight - *heightPtr)/2;
              break;
          case ALIGN_TOP:
              *yPtr = y + eiPtr->body.ei.padY;
              break;
          case ALIGN_BASELINE:
              *yPtr = y + (baseline - *heightPtr);
              break;
      }
  }
  /*
   *--------------------------------------------------------------
   *
   * TkTextImageIndex --
   *
   *      Given the name of an embedded image within a text widget,
   *      returns an index corresponding to the image's position
   *      in the text.
   *
   * Results:
   *      The return value is 1 if there is an embedded image by
   *      the given name in the text widget, 0 otherwise.  If the
   *      image exists, *indexPtr is filled in with its index.
   *
   * Side effects:
   *      None.
   *
   *--------------------------------------------------------------
   */
  int
  TkTextImageIndex(textPtr, name, indexPtr)
      TkText *textPtr;            /* Text widget containing image. */
      char *name;                 /* Name of image. */
      TkTextIndex *indexPtr;      /* Index information gets stored here. */
  {
      Tcl_HashEntry *hPtr;
      TkTextSegment *eiPtr;
      hPtr = Tcl_FindHashEntry(&textPtr->imageTable, name);
      if (hPtr == NULL) {
          return 0;
      }
      eiPtr = (TkTextSegment *) Tcl_GetHashValue(hPtr);
      indexPtr->tree = textPtr->tree;
      indexPtr->linePtr = eiPtr->body.ei.linePtr;
      indexPtr->byteIndex = TkTextSegToOffset(eiPtr, indexPtr->linePtr);
      return 1;
  }
  /*
   *--------------------------------------------------------------
   *
   * EmbImageProc --
   *
   *      This procedure is called by the image code whenever an
   *      image or its contents changes.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The image will be redisplayed.
   *
   *--------------------------------------------------------------
   */
  static void
  EmbImageProc(clientData, x, y, width, height, imgWidth, imgHeight)
      ClientData clientData;              /* Pointer to widget record. */
      int x, y;                           /* Upper left pixel (within image)
                                           * that must be redisplayed. */
      int width, height;                  /* Dimensions of area to redisplay
                                           * (may be <= 0). */
      int imgWidth, imgHeight;            /* New dimensions of image. */
  {
      TkTextSegment *eiPtr = (TkTextSegment *) clientData;
      TkTextIndex index;
      index.tree = eiPtr->body.ei.textPtr->tree;
      index.linePtr = eiPtr->body.ei.linePtr;
      index.byteIndex = TkTextSegToOffset(eiPtr, eiPtr->body.ei.linePtr);
      TkTextChanged(eiPtr->body.ei.textPtr, &index, &index);
  }
  /* End of tktextimage.c */

 Legend:



Removed from v.69
 


changed lines


 
Added in v.98
 Legend:



Removed from v.69
 


changed lines


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

dashley@gmail.com	ViewVC Help
Powered by ViewVC 1.1.25