URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [insight/] [tk/] [generic/] [tkImgBmap.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
 * tkImgBmap.c --
 *
 *      This procedure implements images of type "bitmap" for Tk.
 *
 * Copyright (c) 1994 The Regents of the University of California.
 * Copyright (c) 1994-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: tkImgBmap.c,v 1.1.1.1 2002-01-16 10:25:52 markom Exp $
 */
 
#include "tkInt.h"
#include "tkPort.h"
 
/*
 * The following data structure represents the master for a bitmap
 * image:
 */
 
typedef struct BitmapMaster {
    Tk_ImageMaster tkMaster;    /* Tk's token for image master.  NULL means
                                 * the image is being deleted. */
    Tcl_Interp *interp;         /* Interpreter for application that is
                                 * using image. */
    Tcl_Command imageCmd;       /* Token for image command (used to delete
                                 * it when the image goes away).  NULL means
                                 * the image command has already been
                                 * deleted. */
    int width, height;          /* Dimensions of image. */
    char *data;                 /* Data comprising bitmap (suitable for
                                 * input to XCreateBitmapFromData).   May
                                 * be NULL if no data.  Malloc'ed. */
    char *maskData;             /* Data for bitmap's mask (suitable for
                                 * input to XCreateBitmapFromData).
                                 * Malloc'ed. */
    Tk_Uid fgUid;               /* Value of -foreground option (malloc'ed). */
    Tk_Uid bgUid;               /* Value of -background option (malloc'ed). */
    char *fileString;           /* Value of -file option (malloc'ed). */
    char *dataString;           /* Value of -data option (malloc'ed). */
    char *maskFileString;       /* Value of -maskfile option (malloc'ed). */
    char *maskDataString;       /* Value of -maskdata option (malloc'ed). */
    struct BitmapInstance *instancePtr;
                                /* First in list of all instances associated
                                 * with this master. */
} BitmapMaster;
 
/*
 * The following data structure represents all of the instances of an
 * image that lie within a particular window:
 */
 
typedef struct BitmapInstance {
    int refCount;               /* Number of instances that share this
                                 * data structure. */
    BitmapMaster *masterPtr;    /* Pointer to master for image. */
    Tk_Window tkwin;            /* Window in which the instances will be
                                 * displayed. */
    XColor *fg;                 /* Foreground color for displaying image. */
    XColor *bg;                 /* Background color for displaying image. */
    Pixmap bitmap;              /* The bitmap to display. */
    Pixmap mask;                /* Mask: only display bitmap pixels where
                                 * there are 1's here. */
    GC gc;                      /* Graphics context for displaying bitmap.
                                 * None means there was an error while
                                 * setting up the instance, so it cannot
                                 * be displayed. */
    struct BitmapInstance *nextPtr;
                                /* Next in list of all instance structures
                                 * associated with masterPtr (NULL means
                                 * end of list). */
} BitmapInstance;
 
/*
 * The type record for bitmap images:
 */
 
static int              GetByte _ANSI_ARGS_((Tcl_Channel chan));
static int              ImgBmapCreate _ANSI_ARGS_((Tcl_Interp *interp,
                            char *name, int argc, Tcl_Obj *CONST objv[],
                            Tk_ImageType *typePtr, Tk_ImageMaster master,
                            ClientData *clientDataPtr));
static ClientData       ImgBmapGet _ANSI_ARGS_((Tk_Window tkwin,
                            ClientData clientData));
static void             ImgBmapDisplay _ANSI_ARGS_((ClientData clientData,
                            Display *display, Drawable drawable,
                            int imageX, int imageY, int width, int height,
                            int drawableX, int drawableY));
static void             ImgBmapFree _ANSI_ARGS_((ClientData clientData,
                            Display *display));
static void             ImgBmapDelete _ANSI_ARGS_((ClientData clientData));
 
Tk_ImageType tkBitmapImageType = {
    "bitmap",                   /* name */
    ImgBmapCreate,              /* createProc */
    ImgBmapGet,                 /* getProc */
    ImgBmapDisplay,             /* displayProc */
    ImgBmapFree,                /* freeProc */
    ImgBmapDelete,              /* deleteProc */
    (Tk_ImageType *) NULL       /* nextPtr */
};
 
/*
 * Information used for parsing configuration specs:
 */
 
static Tk_ConfigSpec configSpecs[] = {
    {TK_CONFIG_UID, "-background", (char *) NULL, (char *) NULL,
        "", Tk_Offset(BitmapMaster, bgUid), 0},
    {TK_CONFIG_STRING, "-data", (char *) NULL, (char *) NULL,
        (char *) NULL, Tk_Offset(BitmapMaster, dataString), TK_CONFIG_NULL_OK},
    {TK_CONFIG_STRING, "-file", (char *) NULL, (char *) NULL,
        (char *) NULL, Tk_Offset(BitmapMaster, fileString), TK_CONFIG_NULL_OK},
    {TK_CONFIG_UID, "-foreground", (char *) NULL, (char *) NULL,
        "#000000", Tk_Offset(BitmapMaster, fgUid), 0},
    {TK_CONFIG_STRING, "-maskdata", (char *) NULL, (char *) NULL,
        (char *) NULL, Tk_Offset(BitmapMaster, maskDataString),
        TK_CONFIG_NULL_OK},
    {TK_CONFIG_STRING, "-maskfile", (char *) NULL, (char *) NULL,
        (char *) NULL, Tk_Offset(BitmapMaster, maskFileString),
        TK_CONFIG_NULL_OK},
    {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
        (char *) NULL, 0, 0}
};
 
/*
 * The following data structure is used to describe the state of
 * parsing a bitmap file or string.  It is used for communication
 * between TkGetBitmapData and NextBitmapWord.
 */
 
#define MAX_WORD_LENGTH 100
typedef struct ParseInfo {
    char *string;               /* Next character of string data for bitmap,
                                 * or NULL if bitmap is being read from
                                 * file. */
    Tcl_Channel chan;           /* File containing bitmap data, or NULL
                                 * if no file. */
    char word[MAX_WORD_LENGTH+1];
                                /* Current word of bitmap data, NULL
                                 * terminated. */
    int wordLength;             /* Number of non-NULL bytes in word. */
} ParseInfo;
 
/*
 * Prototypes for procedures used only locally in this file:
 */
 
static int              ImgBmapCmd _ANSI_ARGS_((ClientData clientData,
                            Tcl_Interp *interp, int argc, char **argv));
static void             ImgBmapCmdDeletedProc _ANSI_ARGS_((
                            ClientData clientData));
static void             ImgBmapConfigureInstance _ANSI_ARGS_((
                            BitmapInstance *instancePtr));
static int              ImgBmapConfigureMaster _ANSI_ARGS_((
                            BitmapMaster *masterPtr, int argc, char **argv,
                            int flags));
static int              NextBitmapWord _ANSI_ARGS_((ParseInfo *parseInfoPtr));
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapCreate --
 *
 *      This procedure is called by the Tk image code to create "test"
 *      images.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      The data structure for a new image is allocated.
 *
 *----------------------------------------------------------------------
 */
 
        /* ARGSUSED */
static int
ImgBmapCreate(interp, name, argc, objv, typePtr, master, clientDataPtr)
    Tcl_Interp *interp;         /* Interpreter for application containing
                                 * image. */
    char *name;                 /* Name to use for image. */
    int argc;                   /* Number of arguments. */
    Tcl_Obj *CONST objv[];      /* Argument objects for options (doesn't
                                 * include image name or type). */
    Tk_ImageType *typePtr;      /* Pointer to our type record (not used). */
    Tk_ImageMaster master;      /* Token for image, to be used by us in
                                 * later callbacks. */
    ClientData *clientDataPtr;  /* Store manager's token for image here;
                                 * it will be returned in later callbacks. */
{
    BitmapMaster *masterPtr;
    char **argv;
    int i;
 
    masterPtr = (BitmapMaster *) ckalloc(sizeof(BitmapMaster));
    masterPtr->tkMaster = master;
    masterPtr->interp = interp;
    masterPtr->imageCmd = Tcl_CreateCommand(interp, name, ImgBmapCmd,
            (ClientData) masterPtr, ImgBmapCmdDeletedProc);
    masterPtr->width = masterPtr->height = 0;
    masterPtr->data = NULL;
    masterPtr->maskData = NULL;
    masterPtr->fgUid = NULL;
    masterPtr->bgUid = NULL;
    masterPtr->fileString = NULL;
    masterPtr->dataString = NULL;
    masterPtr->maskFileString = NULL;
    masterPtr->maskDataString = NULL;
    masterPtr->instancePtr = NULL;
 
    /*
     * Convert the objv arguments into string equivalent.
     * A proper conversion to object format will need to be done in the future
     */
    argv = (char **) ckalloc(argc * sizeof(char *));
    for (i = 0; i < argc; i++) {
      argv[i] = Tcl_GetStringFromObj(objv[i], NULL);
    }
    if (ImgBmapConfigureMaster(masterPtr, argc, argv, 0) != TCL_OK) {
        ImgBmapDelete((ClientData) masterPtr);
        ckfree((char *) argv);
        return TCL_ERROR;
    }
    ckfree((char *) argv);
    *clientDataPtr = (ClientData) masterPtr;
    return TCL_OK;
}
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapConfigureMaster --
 *
 *      This procedure is called when a bitmap image is created or
 *      reconfigured.  It process configuration options and resets
 *      any instances of the image.
 *
 * Results:
 *      A standard Tcl return value.  If TCL_ERROR is returned then
 *      an error message is left in masterPtr->interp->result.
 *
 * Side effects:
 *      Existing instances of the image will be redisplayed to match
 *      the new configuration options.
 *
 *----------------------------------------------------------------------
 */
 
static int
ImgBmapConfigureMaster(masterPtr, argc, argv, flags)
    BitmapMaster *masterPtr;    /* Pointer to data structure describing
                                 * overall bitmap image to (reconfigure). */
    int argc;                   /* Number of entries in argv. */
    char **argv;                /* Pairs of configuration options for image. */
    int flags;                  /* Flags to pass to Tk_ConfigureWidget,
                                 * such as TK_CONFIG_ARGV_ONLY. */
{
    BitmapInstance *instancePtr;
    int maskWidth, maskHeight, dummy1, dummy2;
 
    if (Tk_ConfigureWidget(masterPtr->interp, Tk_MainWindow(masterPtr->interp),
            configSpecs, argc, argv, (char *) masterPtr, flags)
            != TCL_OK) {
        return TCL_ERROR;
    }
 
    /*
     * Parse the bitmap and/or mask to create binary data.  Make sure that
     * the bitmap and mask have the same dimensions.
     */
 
    if (masterPtr->data != NULL) {
        ckfree(masterPtr->data);
        masterPtr->data = NULL;
    }
    if ((masterPtr->fileString != NULL) || (masterPtr->dataString != NULL)) {
        masterPtr->data = TkGetBitmapData(masterPtr->interp,
                masterPtr->dataString, masterPtr->fileString,
                &masterPtr->width, &masterPtr->height, &dummy1, &dummy2);
        if (masterPtr->data == NULL) {
            return TCL_ERROR;
        }
    }
    if (masterPtr->maskData != NULL) {
        ckfree(masterPtr->maskData);
        masterPtr->maskData = NULL;
    }
    if ((masterPtr->maskFileString != NULL)
            || (masterPtr->maskDataString != NULL)) {
        if (masterPtr->data == NULL) {
            masterPtr->interp->result = "can't have mask without bitmap";
            return TCL_ERROR;
        }
        masterPtr->maskData = TkGetBitmapData(masterPtr->interp,
                masterPtr->maskDataString, masterPtr->maskFileString,
                &maskWidth, &maskHeight, &dummy1, &dummy2);
        if (masterPtr->maskData == NULL) {
            return TCL_ERROR;
        }
        if ((maskWidth != masterPtr->width)
                || (maskHeight != masterPtr->height)) {
            ckfree(masterPtr->maskData);
            masterPtr->maskData = NULL;
            masterPtr->interp->result = "bitmap and mask have different sizes";
            return TCL_ERROR;
        }
    }
 
    /*
     * Cycle through all of the instances of this image, regenerating
     * the information for each instance.  Then force the image to be
     * redisplayed everywhere that it is used.
     */
 
    for (instancePtr = masterPtr->instancePtr; instancePtr != NULL;
            instancePtr = instancePtr->nextPtr) {
        ImgBmapConfigureInstance(instancePtr);
    }
    Tk_ImageChanged(masterPtr->tkMaster, 0, 0, masterPtr->width,
            masterPtr->height, masterPtr->width, masterPtr->height);
    return TCL_OK;
}
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapConfigureInstance --
 *
 *      This procedure is called to create displaying information for
 *      a bitmap image instance based on the configuration information
 *      in the master.  It is invoked both when new instances are
 *      created and when the master is reconfigured.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Generates errors via Tcl_BackgroundError if there are problems
 *      in setting up the instance.
 *
 *----------------------------------------------------------------------
 */
 
static void
ImgBmapConfigureInstance(instancePtr)
    BitmapInstance *instancePtr;        /* Instance to reconfigure. */
{
    BitmapMaster *masterPtr = instancePtr->masterPtr;
    XColor *colorPtr;
    XGCValues gcValues;
    GC gc;
    unsigned int mask;
 
    /*
     * For each of the options in masterPtr, translate the string
     * form into an internal form appropriate for instancePtr.
     */
 
    if (*masterPtr->bgUid != 0) {
        colorPtr = Tk_GetColor(masterPtr->interp, instancePtr->tkwin,
                masterPtr->bgUid);
        if (colorPtr == NULL) {
            goto error;
        }
    } else {
        colorPtr = NULL;
    }
    if (instancePtr->bg != NULL) {
        Tk_FreeColor(instancePtr->bg);
    }
    instancePtr->bg = colorPtr;
 
    colorPtr = Tk_GetColor(masterPtr->interp, instancePtr->tkwin,
            masterPtr->fgUid);
    if (colorPtr == NULL) {
        goto error;
    }
    if (instancePtr->fg != NULL) {
        Tk_FreeColor(instancePtr->fg);
    }
    instancePtr->fg = colorPtr;
 
    if (instancePtr->bitmap != None) {
        Tk_FreePixmap(Tk_Display(instancePtr->tkwin), instancePtr->bitmap);
        instancePtr->bitmap = None;
    }
    if (masterPtr->data != NULL) {
        instancePtr->bitmap = XCreateBitmapFromData(
                Tk_Display(instancePtr->tkwin),
                RootWindowOfScreen(Tk_Screen(instancePtr->tkwin)),
                masterPtr->data, (unsigned) masterPtr->width,
                (unsigned) masterPtr->height);
    }
 
    if (instancePtr->mask != None) {
        Tk_FreePixmap(Tk_Display(instancePtr->tkwin), instancePtr->mask);
        instancePtr->mask = None;
    }
    if (masterPtr->maskData != NULL) {
        instancePtr->mask = XCreateBitmapFromData(
                Tk_Display(instancePtr->tkwin),
                RootWindowOfScreen(Tk_Screen(instancePtr->tkwin)),
                masterPtr->maskData, (unsigned) masterPtr->width,
                (unsigned) masterPtr->height);
    }
 
    if (masterPtr->data != NULL) {
        gcValues.foreground = instancePtr->fg->pixel;
        gcValues.graphics_exposures = False;
        mask = GCForeground|GCGraphicsExposures;
        if (instancePtr->bg != NULL) {
            gcValues.background = instancePtr->bg->pixel;
            mask |= GCBackground;
            if (instancePtr->mask != None) {
                gcValues.clip_mask = instancePtr->mask;
                mask |= GCClipMask;
            }
        } else {
            gcValues.clip_mask = instancePtr->bitmap;
            mask |= GCClipMask;
        }
        gc = Tk_GetGCColor(instancePtr->tkwin, mask, &gcValues,
                           instancePtr->fg, instancePtr->bg);
    } else {
        gc = None;
    }
    if (instancePtr->gc != None) {
        Tk_FreeGC(Tk_Display(instancePtr->tkwin), instancePtr->gc);
    }
    instancePtr->gc = gc;
    return;
 
    error:
    /*
     * An error occurred: clear the graphics context in the instance to
     * make it clear that this instance cannot be displayed.  Then report
     * the error.
     */
 
    if (instancePtr->gc != None) {
        Tk_FreeGC(Tk_Display(instancePtr->tkwin), instancePtr->gc);
    }
    instancePtr->gc = None;
    Tcl_AddErrorInfo(masterPtr->interp, "\n    (while configuring image \"");
    Tcl_AddErrorInfo(masterPtr->interp, Tk_NameOfImage(masterPtr->tkMaster));
    Tcl_AddErrorInfo(masterPtr->interp, "\")");
    Tcl_BackgroundError(masterPtr->interp);
}
 
/*
 *----------------------------------------------------------------------
 *
 * TkGetBitmapData --
 *
 *      Given a file name or ASCII string, this procedure parses the
 *      file or string contents to produce binary data for a bitmap.
 *
 * Results:
 *      If the bitmap description was parsed successfully then the
 *      return value is a malloc-ed array containing the bitmap data.
 *      The dimensions of the data are stored in *widthPtr and
 *      *heightPtr.  *hotXPtr and *hotYPtr are set to the bitmap
 *      hotspot if one is defined, otherwise they are set to -1, -1.
 *      If an error occurred, NULL is returned and an error message is
 *      left in interp->result.
 *
 * Side effects:
 *      A bitmap is created.
 *
 *----------------------------------------------------------------------
 */
 
char *
TkGetBitmapData(interp, string, fileName, widthPtr, heightPtr,
        hotXPtr, hotYPtr)
    Tcl_Interp *interp;                 /* For reporting errors, or NULL. */
    char *string;                       /* String describing bitmap.  May
                                         * be NULL. */
    char *fileName;                     /* Name of file containing bitmap
                                         * description.  Used only if string
                                         * is NULL.  Must not be NULL if
                                         * string is NULL. */
    int *widthPtr, *heightPtr;          /* Dimensions of bitmap get returned
                                         * here. */
    int *hotXPtr, *hotYPtr;             /* Position of hot spot or -1,-1. */
{
    int width, height, numBytes, hotX, hotY;
    char *p, *end, *expandedFileName;
    ParseInfo pi;
    char *data = NULL;
    Tcl_DString buffer;
 
    pi.string = string;
    if (string == NULL) {
        if ((interp != NULL) && Tcl_IsSafe(interp)) {
            Tcl_AppendResult(interp, "can't get bitmap data from a file in a",
                    " safe interpreter", (char *) NULL);
            return NULL;
        }
        expandedFileName = Tcl_TranslateFileName(interp, fileName, &buffer);
        if (expandedFileName == NULL) {
            return NULL;
        }
        pi.chan = Tcl_OpenFileChannel(interp, expandedFileName, "r", 0);
        Tcl_DStringFree(&buffer);
        if (pi.chan == NULL) {
            if (interp != NULL) {
                Tcl_ResetResult(interp);
                Tcl_AppendResult(interp, "couldn't read bitmap file \"",
                        fileName, "\": ", Tcl_PosixError(interp),
                        (char *) NULL);
            }
            return NULL;
        }
    } else {
        pi.chan = NULL;
    }
 
    /*
     * Parse the lines that define the dimensions of the bitmap,
     * plus the first line that defines the bitmap data (it declares
     * the name of a data variable but doesn't include any actual
     * data).  These lines look something like the following:
     *
     *          #define foo_width 16
     *          #define foo_height 16
     *          #define foo_x_hot 3
     *          #define foo_y_hot 3
     *          static char foo_bits[] = {
     *
     * The x_hot and y_hot lines may or may not be present.  It's
     * important to check for "char" in the last line, in order to
     * reject old X10-style bitmaps that used shorts.
     */
 
    width = 0;
    height = 0;
    hotX = -1;
    hotY = -1;
    while (1) {
        if (NextBitmapWord(&pi) != TCL_OK) {
            goto error;
        }
        if ((pi.wordLength >= 6) && (pi.word[pi.wordLength-6] == '_')
                && (strcmp(pi.word+pi.wordLength-6, "_width") == 0)) {
            if (NextBitmapWord(&pi) != TCL_OK) {
                goto error;
            }
            width = strtol(pi.word, &end, 0);
            if ((end == pi.word) || (*end != 0)) {
                goto error;
            }
        } else if ((pi.wordLength >= 7) && (pi.word[pi.wordLength-7] == '_')
                && (strcmp(pi.word+pi.wordLength-7, "_height") == 0)) {
            if (NextBitmapWord(&pi) != TCL_OK) {
                goto error;
            }
            height = strtol(pi.word, &end, 0);
            if ((end == pi.word) || (*end != 0)) {
                goto error;
            }
        } else if ((pi.wordLength >= 6) && (pi.word[pi.wordLength-6] == '_')
                && (strcmp(pi.word+pi.wordLength-6, "_x_hot") == 0)) {
            if (NextBitmapWord(&pi) != TCL_OK) {
                goto error;
            }
            hotX = strtol(pi.word, &end, 0);
            if ((end == pi.word) || (*end != 0)) {
                goto error;
            }
        } else if ((pi.wordLength >= 6) && (pi.word[pi.wordLength-6] == '_')
                && (strcmp(pi.word+pi.wordLength-6, "_y_hot") == 0)) {
            if (NextBitmapWord(&pi) != TCL_OK) {
                goto error;
            }
            hotY = strtol(pi.word, &end, 0);
            if ((end == pi.word) || (*end != 0)) {
                goto error;
            }
        } else if ((pi.word[0] == 'c') && (strcmp(pi.word, "char") == 0)) {
            while (1) {
                if (NextBitmapWord(&pi) != TCL_OK) {
                    goto error;
                }
                if ((pi.word[0] == '{') && (pi.word[1] == 0)) {
                    goto getData;
                }
            }
        } else if ((pi.word[0] == '{') && (pi.word[1] == 0)) {
            if (interp != NULL) {
                Tcl_AppendResult(interp, "format error in bitmap data; ",
                        "looks like it's an obsolete X10 bitmap file",
                        (char *) NULL);
            }
            goto errorCleanup;
        }
    }
 
    /*
     * Now we've read everything but the data.  Allocate an array
     * and read in the data.
     */
 
    getData:
    if ((width <= 0) || (height <= 0)) {
        goto error;
    }
    numBytes = ((width+7)/8) * height;
    data = (char *) ckalloc((unsigned) numBytes);
    for (p = data; numBytes > 0; p++, numBytes--) {
        if (NextBitmapWord(&pi) != TCL_OK) {
            goto error;
        }
        *p = (char) strtol(pi.word, &end, 0);
        if (end == pi.word) {
            goto error;
        }
    }
 
    /*
     * All done.  Clean up and return.
     */
 
    if (pi.chan != NULL) {
        Tcl_Close(NULL, pi.chan);
    }
    *widthPtr = width;
    *heightPtr = height;
    *hotXPtr = hotX;
    *hotYPtr = hotY;
    return data;
 
    error:
    if (interp != NULL) {
        interp->result = "format error in bitmap data";
    }
    errorCleanup:
    if (data != NULL) {
        ckfree(data);
    }
    if (pi.chan != NULL) {
        Tcl_Close(NULL, pi.chan);
    }
    return NULL;
}
 
/*
 *----------------------------------------------------------------------
 *
 * NextBitmapWord --
 *
 *      This procedure retrieves the next word of information (stuff
 *      between commas or white space) from a bitmap description.
 *
 * Results:
 *      Returns TCL_OK if all went well.  In this case the next word,
 *      and its length, will be availble in *parseInfoPtr.  If the end
 *      of the bitmap description was reached then TCL_ERROR is returned.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */
 
static int
NextBitmapWord(parseInfoPtr)
    ParseInfo *parseInfoPtr;            /* Describes what we're reading
                                         * and where we are in it. */
{
    char *src, *dst;
    int c;
 
    parseInfoPtr->wordLength = 0;
    dst = parseInfoPtr->word;
    if (parseInfoPtr->string != NULL) {
        for (src = parseInfoPtr->string; isspace(UCHAR(*src)) || (*src == ',');
                src++) {
            if (*src == 0) {
                return TCL_ERROR;
            }
        }
        for ( ; !isspace(UCHAR(*src)) && (*src != ',') && (*src != 0); src++) {
            *dst = *src;
            dst++;
            parseInfoPtr->wordLength++;
            if (parseInfoPtr->wordLength > MAX_WORD_LENGTH) {
                return TCL_ERROR;
            }
        }
        parseInfoPtr->string = src;
    } else {
        for (c = GetByte(parseInfoPtr->chan); isspace(UCHAR(c)) || (c == ',');
                c = GetByte(parseInfoPtr->chan)) {
            if (c == EOF) {
                return TCL_ERROR;
            }
        }
        for ( ; !isspace(UCHAR(c)) && (c != ',') && (c != EOF);
                c = GetByte(parseInfoPtr->chan)) {
            *dst = c;
            dst++;
            parseInfoPtr->wordLength++;
            if (parseInfoPtr->wordLength > MAX_WORD_LENGTH) {
                return TCL_ERROR;
            }
        }
    }
    if (parseInfoPtr->wordLength == 0) {
        return TCL_ERROR;
    }
    parseInfoPtr->word[parseInfoPtr->wordLength] = 0;
    return TCL_OK;
}
 
/*
 *--------------------------------------------------------------
 *
 * ImgBmapCmd --
 *
 *      This procedure is invoked to process the Tcl command
 *      that corresponds to an image managed by this module.
 *      See the user documentation for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 *
 *--------------------------------------------------------------
 */
 
static int
ImgBmapCmd(clientData, interp, argc, argv)
    ClientData clientData;      /* Information about the image master. */
    Tcl_Interp *interp;         /* Current interpreter. */
    int argc;                   /* Number of arguments. */
    char **argv;                /* Argument strings. */
{
    BitmapMaster *masterPtr = (BitmapMaster *) clientData;
    int c, code;
    size_t length;
 
    if (argc < 2) {
        sprintf(interp->result,
                "wrong # args: should be \"%.50s option ?arg arg ...?\"",
                argv[0]);
        return TCL_ERROR;
    }
    c = argv[1][0];
    length = strlen(argv[1]);
    if ((c == 'c') && (strncmp(argv[1], "cget", length) == 0)
            && (length >= 2)) {
        if (argc != 3) {
            Tcl_AppendResult(interp, "wrong # args: should be \"",
                    argv[0], " cget option\"",
                    (char *) NULL);
            return TCL_ERROR;
        }
        return Tk_ConfigureValue(interp, Tk_MainWindow(interp), configSpecs,
                (char *) masterPtr, argv[2], 0);
    } else if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)
            && (length >= 2)) {
        if (argc == 2) {
            code = Tk_ConfigureInfo(interp, Tk_MainWindow(interp),
                    configSpecs, (char *) masterPtr, (char *) NULL, 0);
        } else if (argc == 3) {
            code = Tk_ConfigureInfo(interp, Tk_MainWindow(interp),
                    configSpecs, (char *) masterPtr, argv[2], 0);
        } else {
            code = ImgBmapConfigureMaster(masterPtr, argc-2, argv+2,
                    TK_CONFIG_ARGV_ONLY);
        }
        return code;
    } else {
        Tcl_AppendResult(interp, "bad option \"", argv[1],
                "\": must be cget or configure", (char *) NULL);
        return TCL_ERROR;
    }
}
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapGet --
 *
 *      This procedure is called for each use of a bitmap image in a
 *      widget.
 *
 * Results:
 *      The return value is a token for the instance, which is passed
 *      back to us in calls to ImgBmapDisplay and ImgBmapFree.
 *
 * Side effects:
 *      A data structure is set up for the instance (or, an existing
 *      instance is re-used for the new one).
 *
 *----------------------------------------------------------------------
 */
 
static ClientData
ImgBmapGet(tkwin, masterData)
    Tk_Window tkwin;            /* Window in which the instance will be
                                 * used. */
    ClientData masterData;      /* Pointer to our master structure for the
                                 * image. */
{
    BitmapMaster *masterPtr = (BitmapMaster *) masterData;
    BitmapInstance *instancePtr;
 
    /*
     * See if there is already an instance for this window.  If so
     * then just re-use it.
     */
 
    for (instancePtr = masterPtr->instancePtr; instancePtr != NULL;
            instancePtr = instancePtr->nextPtr) {
        if (instancePtr->tkwin == tkwin) {
            instancePtr->refCount++;
            return (ClientData) instancePtr;
        }
    }
 
    /*
     * The image isn't already in use in this window.  Make a new
     * instance of the image.
     */
 
    instancePtr = (BitmapInstance *) ckalloc(sizeof(BitmapInstance));
    instancePtr->refCount = 1;
    instancePtr->masterPtr = masterPtr;
    instancePtr->tkwin = tkwin;
    instancePtr->fg = NULL;
    instancePtr->bg = NULL;
    instancePtr->bitmap = None;
    instancePtr->mask = None;
    instancePtr->gc = None;
    instancePtr->nextPtr = masterPtr->instancePtr;
    masterPtr->instancePtr = instancePtr;
    ImgBmapConfigureInstance(instancePtr);
 
    /*
     * If this is the first instance, must set the size of the image.
     */
 
    if (instancePtr->nextPtr == NULL) {
        Tk_ImageChanged(masterPtr->tkMaster, 0, 0, 0, 0, masterPtr->width,
                masterPtr->height);
    }
 
    return (ClientData) instancePtr;
}
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapDisplay --
 *
 *      This procedure is invoked to draw a bitmap image.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      A portion of the image gets rendered in a pixmap or window.
 *
 *----------------------------------------------------------------------
 */
 
static void
ImgBmapDisplay(clientData, display, drawable, imageX, imageY, width,
        height, drawableX, drawableY)
    ClientData clientData;      /* Pointer to BitmapInstance structure for
                                 * for instance to be displayed. */
    Display *display;           /* Display on which to draw image. */
    Drawable drawable;          /* Pixmap or window in which to draw image. */
    int imageX, imageY;         /* Upper-left corner of region within image
                                 * to draw. */
    int width, height;          /* Dimensions of region within image to draw. */
    int drawableX, drawableY;   /* Coordinates within drawable that
                                 * correspond to imageX and imageY. */
{
    BitmapInstance *instancePtr = (BitmapInstance *) clientData;
    int masking;
 
    /*
     * If there's no graphics context, it means that an error occurred
     * while creating the image instance so it can't be displayed.
     */
 
    if (instancePtr->gc == None) {
        return;
    }
 
    /*
     * If masking is in effect, must modify the mask origin within
     * the graphics context to line up with the image's origin.
     * Then draw the image and reset the clip origin, if there's
     * a mask.
     */
 
    masking = (instancePtr->mask != None) || (instancePtr->bg == NULL);
    if (masking) {
        XSetClipOrigin(display, instancePtr->gc, drawableX - imageX,
                drawableY - imageY);
    }
    XCopyPlane(display, instancePtr->bitmap, drawable, instancePtr->gc,
            imageX, imageY, (unsigned) width, (unsigned) height,
            drawableX, drawableY, 1);
    if (masking) {
        XSetClipOrigin(display, instancePtr->gc, 0, 0);
    }
}
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapFree --
 *
 *      This procedure is called when a widget ceases to use a
 *      particular instance of an image.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Internal data structures get cleaned up.
 *
 *----------------------------------------------------------------------
 */
 
static void
ImgBmapFree(clientData, display)
    ClientData clientData;      /* Pointer to BitmapInstance structure for
                                 * for instance to be displayed. */
    Display *display;           /* Display containing window that used image. */
{
    BitmapInstance *instancePtr = (BitmapInstance *) clientData;
    BitmapInstance *prevPtr;
 
    instancePtr->refCount--;
    if (instancePtr->refCount > 0) {
        return;
    }
 
    /*
     * There are no more uses of the image within this widget.  Free
     * the instance structure.
     */
 
    if (instancePtr->fg != NULL) {
        Tk_FreeColor(instancePtr->fg);
    }
    if (instancePtr->bg != NULL) {
        Tk_FreeColor(instancePtr->bg);
    }
    if (instancePtr->bitmap != None) {
        Tk_FreePixmap(display, instancePtr->bitmap);
    }
    if (instancePtr->mask != None) {
        Tk_FreePixmap(display, instancePtr->mask);
    }
    if (instancePtr->gc != None) {
        Tk_FreeGC(display, instancePtr->gc);
    }
    if (instancePtr->masterPtr->instancePtr == instancePtr) {
        instancePtr->masterPtr->instancePtr = instancePtr->nextPtr;
    } else {
        for (prevPtr = instancePtr->masterPtr->instancePtr;
                prevPtr->nextPtr != instancePtr; prevPtr = prevPtr->nextPtr) {
            /* Empty loop body */
        }
        prevPtr->nextPtr = instancePtr->nextPtr;
    }
    ckfree((char *) instancePtr);
}
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapDelete --
 *
 *      This procedure is called by the image code to delete the
 *      master structure for an image.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Resources associated with the image get freed.
 *
 *----------------------------------------------------------------------
 */
 
static void
ImgBmapDelete(masterData)
    ClientData masterData;      /* Pointer to BitmapMaster structure for
                                 * image.  Must not have any more instances. */
{
    BitmapMaster *masterPtr = (BitmapMaster *) masterData;
 
    if (masterPtr->instancePtr != NULL) {
        panic("tried to delete bitmap image when instances still exist");
    }
    masterPtr->tkMaster = NULL;
    if (masterPtr->imageCmd != NULL) {
        Tcl_DeleteCommandFromToken(masterPtr->interp, masterPtr->imageCmd);
    }
    if (masterPtr->data != NULL) {
        ckfree(masterPtr->data);
    }
    if (masterPtr->maskData != NULL) {
        ckfree(masterPtr->maskData);
    }
    Tk_FreeOptions(configSpecs, (char *) masterPtr, (Display *) NULL, 0);
    ckfree((char *) masterPtr);
}
 
/*
 *----------------------------------------------------------------------
 *
 * ImgBmapCmdDeletedProc --
 *
 *      This procedure is invoked when the image command for an image
 *      is deleted.  It deletes the image.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The image is deleted.
 *
 *----------------------------------------------------------------------
 */
 
static void
ImgBmapCmdDeletedProc(clientData)
    ClientData clientData;      /* Pointer to BitmapMaster structure for
                                 * image. */
{
    BitmapMaster *masterPtr = (BitmapMaster *) clientData;
 
    masterPtr->imageCmd = NULL;
    if (masterPtr->tkMaster != NULL) {
        Tk_DeleteImage(masterPtr->interp, Tk_NameOfImage(masterPtr->tkMaster));
    }
}
 
/*
 *----------------------------------------------------------------------
 *
 * GetByte --
 *
 *      Get the next byte from the open channel.
 *
 * Results:
 *      The next byte or EOF.
 *
 * Side effects:
 *      We read from the channel.
 *
 *----------------------------------------------------------------------
 */
 
static int
GetByte(chan)
    Tcl_Channel chan;   /* The channel we read from. */
{
    char buffer;
    int size;
 
    size = Tcl_Read(chan, &buffer, 1);
    if (size <= 0) {
        return EOF;
    } else {
        return buffer;
    }
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [insight/] [tk/] [generic/] [tkImgBmap.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	578	markom	`/*`
2			`* tkImgBmap.c --`
3			`*`
4			`* This procedure implements images of type "bitmap" for Tk.`
5			`*`
6			`* Copyright (c) 1994 The Regents of the University of California.`
7			`* Copyright (c) 1994-1997 Sun Microsystems, Inc.`
8			`*`
9			`* See the file "license.terms" for information on usage and redistribution`
10			`* of this file, and for a DISCLAIMER OF ALL WARRANTIES.`
11			`*`
12			`* RCS: @(#) $Id: tkImgBmap.c,v 1.1.1.1 2002-01-16 10:25:52 markom Exp $`
13			`*/`
14
15			`#include "tkInt.h"`
16			`#include "tkPort.h"`
17
18			`/*`
19			`* The following data structure represents the master for a bitmap`
20			`* image:`
21			`*/`
22
23			`typedef struct BitmapMaster {`
24			`Tk_ImageMaster tkMaster; /* Tk's token for image master. NULL means`
25			`* the image is being deleted. */`
26			`Tcl_Interp interp; / Interpreter for application that is`
27			`* using image. */`
28			`Tcl_Command imageCmd; /* Token for image command (used to delete`
29			`* it when the image goes away). NULL means`
30			`* the image command has already been`
31			`* deleted. */`
32			`int width, height; /* Dimensions of image. */`
33			`char data; / Data comprising bitmap (suitable for`
34			`* input to XCreateBitmapFromData). May`
35			`* be NULL if no data. Malloc'ed. */`
36			`char maskData; / Data for bitmap's mask (suitable for`
37			`* input to XCreateBitmapFromData).`
38			`* Malloc'ed. */`
39			`Tk_Uid fgUid; /* Value of -foreground option (malloc'ed). */`
40			`Tk_Uid bgUid; /* Value of -background option (malloc'ed). */`