conservatory
/
stk
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
stk/Extensions/pixmap.c

1521 lines
40 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* tixImgXpm.c --
*
* This file implements images of type "pixmap" for Tix.
* ______________________________________________________________________
*
* Copyright statement for tixImgXpm.c
* Copyright 1996, Expert Interface Technologies
*
* The following terms apply only to this file and no other parts of the
* Tix library.
*
* Permission is hereby granted, without written agreement and
* without license or royalty fees, to use, copy, modify, and
* distribute this file, for any purpose, provided that existing
* copyright notices are retained in all copies and that this
* notice is included verbatim in any distributions.
*
* DISCLAIMER OF ALL WARRANTIES
*
* IN NO EVENT SHALL THE AUTHOR OF THIS SOFTWARE BE LIABLE TO ANY
* PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
* CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE
* AND ITS DOCUMENTATION, EVEN IF THE AUTHOR OF THIS SOFTWARE HAS
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* THE AUTHOR OF THIS SOFTWARE SPECIFICALLY DISCLAIMS ANY
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
* BASIS, AND THE AUTHOR OF THIS SOFTWARE HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
* MODIFICATIONS.
* ___________________________________________________________________
*
* This file is adapted from the Tk 4.0 source file tkImgBmap.c
* Original tkImgBmap.c copyright information:
*
* Copyright (c) 1994 The Regents of the University of California.
* Copyright (c) 1994-1995 Sun Microsystems, Inc.
*
*/
#ifdef USE_TK
#ifdef STk_CODE
# include <stk.h>
#endif
#include "tkInt.h"
#include "tkPort.h"
#ifndef STk_CODE
# include <tix.h>
#endif
/* constants used only in this file */
#define XPM_MONO 1
#define XPM_GRAY_4 2
#define XPM_GRAY 3
#define XPM_COLOR 4
#define XPM_SYMBOLIC 5
#define XPM_UNKNOWN 6
/*
* The following data structure represents the master for a pixmap
* image:
*/
typedef struct PixmapMaster {
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. */
char *fileString; /* Value of -file option (malloc'ed).
* valid only if the -file option is specified
*/
char *dataString; /* Value of -data option (malloc'ed).
* valid only if the -data option is specified
*/
/* First in list of all instances associated
* with this master. */
Tk_Uid id; /* ID's for XPM data already compiled
* into the tixwish binary */
int size[2]; /* width and height */
int ncolors; /* number of colors */
int cpp; /* characters per pixel */
char ** data; /* The data that defines this pixmap
* image (array of strings). It is
* converted into an X Pixmap when this
* image is instanciated
*/
int isDataAlloced; /* False iff the data is got from
* the -id switch */
struct PixmapInstance *instancePtr;
} PixmapMaster;
/* Make this more portable */
typedef struct ColorStruct {
char c; /* This is used if CPP is one */
char * cstring; /* This is used if CPP is bigger than one */
XColor * colorPtr;
} ColorStruct;
/*
* The following data structure represents all of the instances of an
* image that lie within a particular window:
*
* %% ToDo
* Currently one instance is created for each window that uses this pixmap.
* This is usually OK because pixmaps are usually not shared or only shared by
* a small number of windows. To improve resource allocation, we can
* create an instance for each (Display x Visual x Depth) combo. This will
* usually reduce the number of instances to one.
*/
typedef struct PixmapInstance {
int refCount; /* Number of instances that share this
* data structure. */
PixmapMaster *masterPtr; /* Pointer to master for image. */
Tk_Window tkwin; /* Window in which the instances will be
* displayed. */
Pixmap pixmap; /* The pixmap to display. */
Pixmap mask; /* Mask: only display pixmap pixels where
* there are 1's here. */
GC gc; /* Graphics context for displaying pixmap.
* None means there was an error while
* setting up the instance, so it cannot
* be displayed. */
struct PixmapInstance *nextPtr;
/* Next in list of all instance structures
* associated with masterPtr (NULL means
* end of list).
*/
ColorStruct * colors;
} PixmapInstance;
/*
* The type record for pixmap images:
*/
static int ImgXpmCreate _ANSI_ARGS_((Tcl_Interp *interp,
char *name, int argc, char **argv,
Tk_ImageType *typePtr, Tk_ImageMaster master,
ClientData *clientDataPtr));
static ClientData ImgXpmGet _ANSI_ARGS_((Tk_Window tkwin,
ClientData clientData));
static void ImgXpmDisplay _ANSI_ARGS_((ClientData clientData,
Display *display, Drawable drawable,
int imageX, int imageY, int width, int height,
int drawableX, int drawableY));
static void ImgXpmFree _ANSI_ARGS_((ClientData clientData,
Display *display));
static void ImgXpmDelete _ANSI_ARGS_((ClientData clientData));
Tk_ImageType tixPixmapImageType = {
"pixmap", /* name */
ImgXpmCreate, /* createProc */
ImgXpmGet, /* getProc */
ImgXpmDisplay, /* displayProc */
ImgXpmFree, /* freeProc */
ImgXpmDelete, /* deleteProc */
(Tk_ImageType *) NULL /* nextPtr */
};
/*
* Information used for parsing configuration specs:
*/
static Tk_ConfigSpec configSpecs[] = {
{TK_CONFIG_STRING, "-data", (char *) NULL, (char *) NULL,
(char *) NULL, Tk_Offset(PixmapMaster, dataString), TK_CONFIG_NULL_OK},
{TK_CONFIG_STRING, "-file", (char *) NULL, (char *) NULL,
(char *) NULL, Tk_Offset(PixmapMaster, fileString), TK_CONFIG_NULL_OK},
#ifndef STk_CODE
{TK_CONFIG_UID, "-id", (char *) NULL, (char *) NULL,
(char *) NULL, Tk_Offset(PixmapMaster, id), TK_CONFIG_NULL_OK},
#endif
{TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
(char *) NULL, 0, 0}
};
/*
* Prototypes for procedures used only locally in this file:
*/
static int ImgXpmCmd _ANSI_ARGS_((ClientData clientData,
Tcl_Interp *interp, int argc, char **argv));
static void ImgXpmCmdDeletedProc _ANSI_ARGS_((
ClientData clientData));
static void ImgXpmConfigureInstance _ANSI_ARGS_((
PixmapInstance *instancePtr));
static int ImgXpmConfigureMaster _ANSI_ARGS_((
PixmapMaster *masterPtr, int argc, char **argv,
int flags));
static int ImgXpmGetData _ANSI_ARGS_((Tcl_Interp *interp,
PixmapMaster *masterPtr));
static char ** ImgXpmGetDataFromFile _ANSI_ARGS_((Tcl_Interp * interp,
char * string, int * numLines_return));
static char ** ImgXpmGetDataFromId _ANSI_ARGS_((Tcl_Interp * interp,
char * id));
static char ** ImgXpmGetDataFromString _ANSI_ARGS_((Tcl_Interp*interp,
char * string, int * numLines_return));
static void ImgXpmGetPixmapFromData _ANSI_ARGS_((
Tcl_Interp * interp,
PixmapMaster *masterPtr,
PixmapInstance *instancePtr));
/* Local data, used only in this file */
static Tcl_HashTable xpmTable;
static int xpmTableInited = 0;
/*
*----------------------------------------------------------------------
*
* ImgXpmCreate --
*
* This procedure is called by the Tk image code to create "pixmap"
* images.
*
* Results:
* A standard Tcl result.
*
* Side effects:
* The data structure for a new image is allocated.
*
*----------------------------------------------------------------------
*/
static int
ImgXpmCreate(interp, name, argc, argv, typePtr, master, clientDataPtr)
Tcl_Interp *interp; /* Interpreter for application containing
* image. */
char *name; /* Name to use for image. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings 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. */
{
PixmapMaster *masterPtr;
masterPtr = (PixmapMaster *) ckalloc(sizeof(PixmapMaster));
masterPtr->tkMaster = master;
masterPtr->interp = interp;
masterPtr->imageCmd = Tcl_CreateCommand(interp, name, ImgXpmCmd,
(ClientData) masterPtr, ImgXpmCmdDeletedProc);
masterPtr->fileString = NULL;
masterPtr->dataString = NULL;
masterPtr->id = NULL;
masterPtr->data = NULL;
masterPtr->isDataAlloced = 0;
masterPtr->instancePtr = NULL;
if (ImgXpmConfigureMaster(masterPtr, argc, argv, 0) != TCL_OK) {
ImgXpmDelete((ClientData) masterPtr);
return TCL_ERROR;
}
*clientDataPtr = (ClientData) masterPtr;
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* ImgXpmConfigureMaster --
*
* This procedure is called when a pixmap 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.
*
* If any error occurs, the state of *masterPtr is restored to
* previous state.
*
*----------------------------------------------------------------------
*/
static int
ImgXpmConfigureMaster(masterPtr, argc, argv, flags)
PixmapMaster *masterPtr; /* Pointer to data structure describing
* overall pixmap 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. */
{
PixmapInstance *instancePtr;
char * oldData, * oldFile;
Tk_Uid oldId;
oldData = masterPtr->dataString;
oldFile = masterPtr->fileString;
oldId = masterPtr->id;
if (Tk_ConfigureWidget(masterPtr->interp, Tk_MainWindow(masterPtr->interp),
configSpecs, argc, argv, (char *) masterPtr, flags)
!= TCL_OK) {
return TCL_ERROR;
}
if (masterPtr->id != NULL ||
masterPtr->dataString != NULL ||
masterPtr->fileString != NULL) {
if (ImgXpmGetData(masterPtr->interp, masterPtr) != TCL_OK) {
goto error;
}
} else {
Tcl_AppendResult(masterPtr->interp,
#ifdef STk_CODE
"must specify :data or :file", NULL);
#else
"must specify one of -data, -file or -id", NULL);
#endif
goto 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) {
ImgXpmConfigureInstance(instancePtr);
}
if (masterPtr->data) {
Tk_ImageChanged(masterPtr->tkMaster, 0, 0,
masterPtr->size[0], masterPtr->size[1],
masterPtr->size[0], masterPtr->size[1]);
} else {
Tk_ImageChanged(masterPtr->tkMaster, 0, 0, 0, 0, 0, 0);
}
return TCL_OK;
error:
/* Restore it to the original (possible valid) mode */
masterPtr->dataString = oldData;
masterPtr->fileString = oldFile;
masterPtr->id = oldId;
return TCL_ERROR;
}
/*
*----------------------------------------------------------------------
*
* ImgXpmGetData --
*
* Given a file name or ASCII string, this procedure parses the
* file or string contents to produce binary data for a pixmap.
*
* Results:
* If the pixmap description was parsed successfully then the data
* is read into an array of strings. This array will later be used
* to create X Pixmaps for each instance.
*
* Side effects:
* The masterPtr->data array is allocated when successful. Contents of
* *masterPtr is changed only when successful.
*----------------------------------------------------------------------
*/
static int
ImgXpmGetData(interp, masterPtr)
Tcl_Interp *interp; /* For reporting errors. */
PixmapMaster *masterPtr;
{
char ** data = NULL;
int isAllocated; /* do we need to free "data"? */
int listArgc;
char ** listArgv = NULL;
int numLines;
int size[2];
int cpp;
int ncolors;
int code = TCL_OK;
if (masterPtr->id != NULL) {
data = ImgXpmGetDataFromId(interp, masterPtr->id);
isAllocated = 0;
}
else if (masterPtr->fileString != NULL) {
data = ImgXpmGetDataFromFile(interp, masterPtr->fileString, &numLines);
isAllocated = 1;
}
else if (masterPtr->dataString != NULL) {
data = ImgXpmGetDataFromString(interp,masterPtr->dataString,&numLines);
isAllocated = 1;
}
else {
/* Should have been enforced by ImgXpmConfigureMaster() */
#ifdef STk_CODE
panic("ImgXpmGetData(): :data and :file are both NULL");
#else
panic("ImgXpmGetData(): -data, -file and -id are all NULL");
#endif
}
if (data == NULL) {
/* nothing has been allocated yet. Don't need to goto done */
return TCL_ERROR;
}
/* Parse the first line of the data and get info about this pixmap */
if (Tcl_SplitList(interp, data[0], &listArgc, &listArgv) != TCL_OK) {
code = TCL_ERROR; goto done;
}
if (listArgc < 4) { /* file format error */
code = TCL_ERROR; goto done;
}
if (Tcl_GetInt(interp, listArgv[0], &size[0]) != TCL_OK) {
code = TCL_ERROR; goto done;
}
if (Tcl_GetInt(interp, listArgv[1], &size[1]) != TCL_OK) {
code = TCL_ERROR; goto done;
}
if (Tcl_GetInt(interp, listArgv[2], &ncolors) != TCL_OK) {
code = TCL_ERROR; goto done;
}
if (Tcl_GetInt(interp, listArgv[3], &cpp) != TCL_OK) {
code = TCL_ERROR; goto done;
}
if (isAllocated) {
if (numLines != size[1] + ncolors + 1) {
/* the number of lines read from the file/data
* is not the same as specified in the data
*/
code = TCL_ERROR; goto done;
}
}
done:
if (code == TCL_OK) {
if (masterPtr->isDataAlloced && masterPtr->data) {
ckfree((char*)masterPtr->data);
}
masterPtr->isDataAlloced = isAllocated;
masterPtr->data = data;
masterPtr->size[0] = size[0];
masterPtr->size[1] = size[1];
masterPtr->cpp = cpp;
masterPtr->ncolors = ncolors;
} else {
if (isAllocated && data) {
ckfree((char*)data);
}
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "File format error", NULL);
}
if (listArgv) {
ckfree((char*)listArgv);
}
return code;
}
static char ** ImgXpmGetDataFromId(interp, id)
Tcl_Interp * interp;
char * id;
{
Tcl_HashEntry * hashPtr;
if (xpmTableInited == 0) {
hashPtr = NULL;
} else {
hashPtr = Tcl_FindHashEntry(&xpmTable, id);
}
if (hashPtr == NULL) {
Tcl_AppendResult(interp, "unknown pixmap ID \"", id,
"\"", NULL);
return (char**)NULL;
} else {
return (char**)Tcl_GetHashValue(hashPtr);
}
}
static char ** ImgXpmGetDataFromString(interp, string, numLines_return)
Tcl_Interp * interp;
char * string;
int * numLines_return;
{
int quoted;
char * p, * list;
int numLines;
char ** data;
/* skip the leading blanks (leading blanks are not defined in the
* the XPM definition, but skipping them shouldn't hurt. Also, the ability
* to skip the leading blanks is good for using in-line XPM data in TCL
* scripts
*/
while (isspace(*string)) {
++ string;
}
/* parse the header */
if (strncmp("/* XPM", string, 6) != 0) {
goto error;
}
/* strip the comments */
for (quoted = 0, p=string; *p;) {
if (!quoted) {
if (*p == '"') {
quoted = 1;
++ p;
continue;
}
if (*p == '/' && *(p+1) == '*') {
*p++ = ' ';
*p++ = ' ';
while (1) {
if (*p == 0) {
break;
}
if (*p == '*' && *(p+1) == '/') {
*p++ = ' ';
*p++ = ' ';
break;
}
*p++ = ' ';
}
continue;
}
++ p;
} else {
if (*p == '"') {
quoted = 0;
}
++ p;
}
}
/* Search for the opening brace */
for (p=string; *p;) {
if (*p != '{') {
++ p;
} else {
++p;
break;
}
}
/* Change the buffer in to a proper TCL list */
quoted = 0;
list = p;
while (*p) {
if (!quoted) {
if (*p == '"') {
quoted = 1;
++ p;
continue;
}
if (isspace(*p)) {
*p = ' ';
}
else if (*p == ',') {
*p = ' ';
}
else if (*p == '}') {
*p = 0;
break;
}
++p;
}
else {
if (*p == '"') {
quoted = 0;
}
++ p;
}
}
/* The following code depends on the fact that Tcl_SplitList
* strips away double quoates inside a list: ie:
* if string == "\"1\" \"2\"" then
* list[0] = "1"
* list[1] = "2"
* and NOT
*
* list[0] = "\"1\""
* list[1] = "\"2\""
*/
if (Tcl_SplitList(interp, list, &numLines, &data) != TCL_OK) {
goto error;
} else {
if (numLines == 0) {
/* error: empty data? */
if (data != NULL) {
ckfree((char*)data);
goto error;
}
}
* numLines_return = numLines;
return data;
}
error:
Tcl_AppendResult(interp, "File format error", NULL);
return (char**) NULL;
}
static char ** ImgXpmGetDataFromFile(interp, fileName, numLines_return)
Tcl_Interp * interp;
char * fileName;
int * numLines_return;
{
int fileId, size;
char ** data;
struct stat statBuf;
char *cmdBuffer = NULL;
Tcl_DString buffer; /* initialized by Tcl_TildeSubst */
fileName = Tcl_TildeSubst(interp, fileName, &buffer);
if (fileName == NULL) {
goto error;
}
fileId = open(fileName, O_RDONLY, 0);
if (fileId < 0) {
Tcl_AppendResult(interp, "couldn't read file \"", fileName,
"\": ", Tcl_PosixError(interp), (char *) NULL);
goto error;
}
if (fstat(fileId, &statBuf) == -1) {
Tcl_AppendResult(interp, "couldn't stat file \"", fileName,
"\": ", Tcl_PosixError(interp), (char *) NULL);
close(fileId);
goto error;
}
cmdBuffer = (char *) ckalloc((unsigned) statBuf.st_size+1);
size = read(fileId, cmdBuffer, (size_t) statBuf.st_size);
if (size < 0) {
Tcl_AppendResult(interp, "error in reading file \"", fileName,
"\": ", Tcl_PosixError(interp), (char *) NULL);
close(fileId);
goto error;
}
if (close(fileId) != 0) {
Tcl_AppendResult(interp, "error closing file \"", fileName,
"\": ", Tcl_PosixError(interp), (char *) NULL);
goto error;
}
cmdBuffer[size] = 0;
data = ImgXpmGetDataFromString(interp, cmdBuffer, numLines_return);
ckfree(cmdBuffer);
Tcl_DStringFree(&buffer);
return data;
error:
if (cmdBuffer != NULL) {
ckfree(cmdBuffer);
}
Tcl_DStringFree(&buffer);
return (char**)NULL;
}
static char * GetType(colorDefn, type_ret)
char * colorDefn;
int * type_ret;
{
char * p = colorDefn;
/* skip white spaces */
while (*p && isspace(*p)) {
p ++;
}
/* parse the type */
if (p[0] != '\0' && p[0] == 'm' &&
p[1] != '\0' && isspace(p[1])) {
*type_ret = XPM_MONO;
p += 2;
}
else if (p[0] != '\0' && p[0] == 'g' &&
p[1] != '\0' && p[1] == '4' &&
p[2] != '\0' && isspace(p[2])) {
*type_ret = XPM_GRAY_4;
p += 3;
}
else if (p[0] != '\0' && p[0] == 'g' &&
p[1] != '\0' && isspace(p[1])) {
*type_ret = XPM_GRAY;
p += 2;
}
else if (p[0] != '\0' && p[0] == 'c' &&
p[1] != '\0' && isspace(p[1])) {
*type_ret = XPM_COLOR;
p += 2;
}
else if (p[0] != '\0' && p[0] == 's' &&
p[1] != '\0' && isspace(p[1])) {
*type_ret = XPM_SYMBOLIC;
p += 2;
}
else {
*type_ret = XPM_UNKNOWN;
return NULL;
}
return p;
}
/* colorName is guaranteed to be big enough */
static char * GetColor(colorDefn, colorName, type_ret)
char * colorDefn;
char * colorName; /* if found, name is copied to this array */
int * type_ret;
{
int type;
char * p;
if (!colorDefn) {
return NULL;
}
if ((colorDefn = GetType(colorDefn, &type)) == NULL) {
/* unknown type */
return NULL;
}
else {
*type_ret = type;
}
/* skip white spaces */
while (*colorDefn && isspace(*colorDefn)) {
colorDefn ++;
}
p = colorName;
while (1) {
int dummy;
while (*colorDefn && !isspace(*colorDefn)) {
*p++ = *colorDefn++;
}
if (!*colorDefn) {
break;
}
if (GetType(colorDefn, &dummy) == NULL) {
/* the next string should also be considered as a part of a color
* name */
while (*colorDefn && isspace(*colorDefn)) {
*p++ = *colorDefn++;
}
} else {
break;
}
if (!*colorDefn) {
break;
}
}
/* Mark the end of the colorName */
*p = '\0';
return colorDefn;
}
/*----------------------------------------------------------------------
* ImgXpmGetPixmapFromData --
*
* Creates a pixmap for an image instance.
*----------------------------------------------------------------------
*/
static void ImgXpmGetPixmapFromData(interp, masterPtr, instancePtr)
Tcl_Interp * interp;
PixmapMaster *masterPtr;
PixmapInstance *instancePtr;
{
XImage * image = NULL, * mask = NULL;
int pad, depth, i, j, k, lOffset, isTransp = 0, isMono;
ColorStruct * colors;
GC gc;
Display *display = Tk_Display(instancePtr->tkwin);
depth = Tk_Depth(instancePtr->tkwin);
if (depth > 16) {
pad = 32;
}
else if (depth > 8) {
pad = 16;
}
else {
pad = 8;
}
switch ((Tk_Visual(instancePtr->tkwin))->class) {
case StaticGray:
case GrayScale:
isMono = 1;
break;
default:
isMono = 0;
}
/*
* Create the XImage structures to store the temporary image
*/
image = XCreateImage(display,
Tk_Visual(instancePtr->tkwin),
depth, ZPixmap, 0, 0,
masterPtr->size[0], masterPtr->size[1], pad, 0);
image->data =
(char *)ckalloc(image->bytes_per_line * masterPtr->size[1]);
mask = XCreateImage(display,
Tk_Visual(instancePtr->tkwin),
1, ZPixmap, 0, 0,
masterPtr->size[0], masterPtr->size[1], pad, 0);
mask->data =
(char *)ckalloc(mask->bytes_per_line * masterPtr->size[1]);
/*
* Parse the colors
*/
lOffset = 1;
colors = (ColorStruct*)ckalloc(sizeof(ColorStruct)*masterPtr->ncolors);
/* Initialize the color structures */
for (i=0; i<masterPtr->ncolors; i++) {
colors[i].colorPtr = NULL;
if (masterPtr->cpp == 1) {
colors[i].c = 0;
} else {
colors[i].cstring = (char*)ckalloc(masterPtr->cpp);
colors[i].cstring[0] = 0;
}
}
for (i=0; i<masterPtr->ncolors; i++) {
char * colorDefn; /* the color definition line */
char * colorName; /* temp place to hold the color name
* defined for one type of visual */
char * useName; /* the color name used for this
* color. If there are many names
* defined, choose the name that is
* "best" for the target visual
*/
int found;
colorDefn = masterPtr->data[i+lOffset]+masterPtr->cpp;
colorName = (char*)ckalloc(strlen(colorDefn));
useName = (char*)ckalloc(strlen(colorDefn));
found = 0;
while (colorDefn && *colorDefn) {
int type;
if ((colorDefn=GetColor(colorDefn, colorName, &type)) == NULL) {
break;
}
if (colorName[0] == '\0') {
continue;
}
switch (type) {
case XPM_MONO:
if (isMono && depth == 1) {
strcpy(useName, colorName);
found = 1; goto gotcolor;
}
break;
case XPM_GRAY_4:
if (isMono && depth == 4) {
strcpy(useName, colorName);
found = 1; goto gotcolor;
}
break;
case XPM_GRAY:
if (isMono && depth > 4) {
strcpy(useName, colorName);
found = 1; goto gotcolor;
}
break;
case XPM_COLOR:
if (!isMono) {
strcpy(useName, colorName);
found = 1; goto gotcolor;
}
break;
}
if (type != XPM_SYMBOLIC && type != XPM_UNKNOWN) {
if (!found) { /* use this color as default */
strcpy(useName, colorName);
found = 1;
}
}
}
gotcolor:
if (masterPtr->cpp == 1) {
colors[i].c = masterPtr->data[i+lOffset][0];
} else {
strncpy(colors[i].cstring, masterPtr->data[i+lOffset],
(size_t)masterPtr->cpp);
}
if (found) {
if (strcasecmp(useName, "none") != 0) {
colors[i].colorPtr = Tk_GetColor(interp,
instancePtr->tkwin, Tk_GetUid(useName));
if (colors[i].colorPtr == NULL) {
colors[i].colorPtr = Tk_GetColor(interp,
instancePtr->tkwin, Tk_GetUid("black"));
}
}
} else {
colors[i].colorPtr = Tk_GetColor(interp,
instancePtr->tkwin, Tk_GetUid("black"));
}
ckfree(colorName);
ckfree(useName);
}
lOffset += masterPtr->ncolors;
/*
* Parse the main body of the image
*/
for (i=0; i<masterPtr->size[1]; i++) {
char * p = masterPtr->data[i+lOffset];
for (j=0; j<masterPtr->size[0]; j++) {
if (masterPtr->cpp == 1) {
for (k=0; k<masterPtr->ncolors; k++) {
if (*p == colors[k].c) {
if (colors[k].colorPtr != NULL) {
XPutPixel(image, j, i, colors[k].colorPtr->pixel);
XPutPixel(mask, j, i, 1);
} else {
XPutPixel(mask, j, i, 0);
isTransp = 1;
}
break;
}
}
if (*p) {
p++;
}
} else {
for (k=0; k<masterPtr->ncolors; k++) {
if (strncmp(p, colors[k].cstring,
(size_t)masterPtr->cpp) == 0) {
if (colors[k].colorPtr != NULL) {
XPutPixel(image, j, i, colors[k].colorPtr->pixel);
XPutPixel(mask, j, i, 1);
} else {
XPutPixel(mask, j, i, 0);
isTransp = 1;
}
break;
}
}
for (k=0; *p && k<masterPtr->cpp; k++) {
p++;
}
}
}
}
/*
* Create the pixmap(s) from the XImage structure. The mask is created
* only if needed (i.e., there is at least one transparent pixel)
*/
instancePtr->colors = colors;
/* main image */
instancePtr->pixmap = Tk_GetPixmap(display,
Tk_WindowId(instancePtr->tkwin),
masterPtr->size[0], masterPtr->size[1], depth);
gc = Tk_GetGC(instancePtr->tkwin, 0, NULL);
TkPutImage(NULL, 0, display, instancePtr->pixmap,
gc, image, 0, 0, 0, 0, masterPtr->size[0], masterPtr->size[1]);
Tk_FreeGC(display, gc);
/* mask, if necessary */
if (isTransp) {
instancePtr->mask = Tk_GetPixmap(display,
Tk_WindowId(instancePtr->tkwin),
masterPtr->size[0], masterPtr->size[1], 1);
gc = XCreateGC(display, instancePtr->mask, 0, NULL);
TkPutImage(NULL, 0, display, instancePtr->mask,
gc, mask, 0, 0, 0, 0, masterPtr->size[0], masterPtr->size[1]);
XFreeGC(display, gc);
} else {
instancePtr->mask = None;
}
/* Done */
if (image) {
ckfree((char*)image->data);
image->data = NULL;
XDestroyImage(image);
}
if (mask) {
ckfree((char*)mask->data);
mask->data = NULL;
XDestroyImage(mask);
}
}
/*
*----------------------------------------------------------------------
*
* ImgXpmConfigureInstance --
*
* This procedure is called to create displaying information for
* a pixmap 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 Tk_BackgroundError if there are problems
* in setting up the instance.
*
*----------------------------------------------------------------------
*/
static void
ImgXpmConfigureInstance(instancePtr)
PixmapInstance *instancePtr; /* Instance to reconfigure. */
{
PixmapMaster *masterPtr = instancePtr->masterPtr;
XGCValues gcValues;
GC gc;
unsigned int gcMask;
if (instancePtr->pixmap != None) {
Tk_FreePixmap(Tk_Display(instancePtr->tkwin), instancePtr->pixmap);
}
if (instancePtr->mask != None) {
Tk_FreePixmap(Tk_Display(instancePtr->tkwin), instancePtr->mask);
}
if (instancePtr->colors != NULL) {
int i;
for (i=0; i<masterPtr->ncolors; i++) {
if (instancePtr->colors[i].colorPtr != NULL) {
Tk_FreeColor(instancePtr->colors[i].colorPtr);
}
if (masterPtr->cpp != 1) {
ckfree(instancePtr->colors[i].cstring);
}
}
ckfree((char*)instancePtr->colors);
}
if (Tk_WindowId(instancePtr->tkwin) == None) {
Tk_MakeWindowExist(instancePtr->tkwin);
}
/* Assumption: masterPtr->data is always non NULL (enfored by
* ImgXpmConfigureMaster()). Also, the data must be in a valid
* format (partially enforced by ImgXpmConfigureMaster(), see comments
* inside that function).
*/
ImgXpmGetPixmapFromData(masterPtr->interp, masterPtr, instancePtr);
/* Allocate a GC for drawing this instance (mask is not used if there
* is no transparent pixels inside the image).*/
if (instancePtr->mask != None) {
gcMask = GCGraphicsExposures|GCClipMask;
} else {
gcMask = GCGraphicsExposures;
}
gcValues.graphics_exposures = False;
gcValues.clip_mask = instancePtr->mask;
gc = Tk_GetGC(instancePtr->tkwin, gcMask, &gcValues);
if (instancePtr->gc != None) {
Tk_FreeGC(Tk_Display(instancePtr->tkwin), instancePtr->gc);
}
instancePtr->gc = gc;
return;
}
/*
*--------------------------------------------------------------
*
* ImgXpmCmd --
*
* 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
ImgXpmCmd(clientData, interp, argc, argv)
ClientData clientData; /* Information about button widget. */
Tcl_Interp *interp; /* Current interpreter. */
int argc; /* Number of arguments. */
char **argv; /* Argument strings. */
{
PixmapMaster *masterPtr = (PixmapMaster *) 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 = ImgXpmConfigureMaster(masterPtr, argc-2, argv+2,
TK_CONFIG_ARGV_ONLY);
}
return code;
} else if ((c == 'r') && (strncmp(argv[1], "refcount", length) == 0)) {
/* For debugging only */
PixmapInstance *instancePtr;
int count = 0;
char buff[30];
for (instancePtr=masterPtr->instancePtr; instancePtr;
instancePtr = instancePtr->nextPtr) {
count += instancePtr->refCount;
}
sprintf(buff, "%d", count);
Tcl_SetResult(interp, buff, TCL_VOLATILE);
return TCL_OK;
} else {
Tcl_AppendResult(interp, "bad option \"", argv[1],
"\": must be cget, configure or refcount", (char *) NULL);
return TCL_ERROR;
}
}
/*
*----------------------------------------------------------------------
*
* ImgXpmGet --
*
* This procedure is called for each use of a pixmap image in a
* widget.
*
* Results:
* The return value is a token for the instance, which is passed
* back to us in calls to ImgXpmDisplay and ImgXpmFre.
*
* Side effects:
* A data structure is set up for the instance (or, an existing
* instance is re-used for the new one).
*
*----------------------------------------------------------------------
*/
static ClientData
ImgXpmGet(tkwin, masterData)
Tk_Window tkwin; /* Window in which the instance will be
* used. */
ClientData masterData; /* Pointer to our master structure for the
* image. */
{
PixmapMaster *masterPtr = (PixmapMaster *) masterData;
PixmapInstance *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 = (PixmapInstance *) ckalloc(sizeof(PixmapInstance));
instancePtr->refCount = 1;
instancePtr->masterPtr = masterPtr;
instancePtr->tkwin = tkwin;
instancePtr->pixmap = None;
instancePtr->mask = None;
instancePtr->gc = None;
instancePtr->nextPtr = masterPtr->instancePtr;
instancePtr->colors = NULL;
masterPtr->instancePtr = instancePtr;
ImgXpmConfigureInstance(instancePtr);
/*
* If this is the first instance, must set the size of the image.
*/
if (instancePtr->nextPtr == NULL) {
if (masterPtr->data) {
Tk_ImageChanged(masterPtr->tkMaster, 0, 0,
masterPtr->size[0], masterPtr->size[1],
masterPtr->size[0], masterPtr->size[1]);
} else {
Tk_ImageChanged(masterPtr->tkMaster, 0, 0, 0, 0, 0, 0);
}
}
return (ClientData) instancePtr;
}
/*
*----------------------------------------------------------------------
*
* ImgXpmDisplay --
*
* This procedure is invoked to draw a pixmap image.
*
* Results:
* None.
*
* Side effects:
* A portion of the image gets rendered in a pixmap or window.
*
*----------------------------------------------------------------------
*/
static void
ImgXpmDisplay(clientData, display, drawable, imageX, imageY, width,
height, drawableX, drawableY)
ClientData clientData; /* Pointer to PixmapInstance 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. */
{
PixmapInstance *instancePtr = (PixmapInstance *) clientData;
/*
* 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;
}
/*
* We always use masking: 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.
*/
XSetClipOrigin(display, instancePtr->gc, drawableX - imageX,
drawableY - imageY);
XCopyArea(display, instancePtr->pixmap, drawable, instancePtr->gc,
imageX, imageY, (unsigned) width, (unsigned) height,
drawableX, drawableY);
XSetClipOrigin(display, instancePtr->gc, 0, 0);
}
/*
*----------------------------------------------------------------------
*
* ImgXpmFree --
*
* 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
ImgXpmFree(clientData, display)
ClientData clientData; /* Pointer to PixmapInstance structure for
* for instance to be displayed. */
Display *display; /* Display containing window that used image.*/
{
PixmapInstance *instancePtr = (PixmapInstance *) clientData;
PixmapInstance *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->pixmap != None) {
Tk_FreePixmap(display, instancePtr->pixmap);
}
if (instancePtr->mask != None) {
Tk_FreePixmap(display, instancePtr->mask);
}
if (instancePtr->gc != None) {
Tk_FreeGC(display, instancePtr->gc);
}
if (instancePtr->colors != NULL) {
int i;
for (i=0; i<instancePtr->masterPtr->ncolors; i++) {
if (instancePtr->colors[i].colorPtr != NULL) {
Tk_FreeColor(instancePtr->colors[i].colorPtr);
}
if (instancePtr->masterPtr->cpp != 1) {
ckfree(instancePtr->colors[i].cstring);
}
}
ckfree((char*)instancePtr->colors);
}
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);
}
/*
*----------------------------------------------------------------------
*
* ImgXpmDelete --
*
* 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
ImgXpmDelete(masterData)
ClientData masterData; /* Pointer to PixmapMaster structure for
* image. Must not have any more instances. */
{
PixmapMaster *masterPtr = (PixmapMaster *) masterData;
if (masterPtr->instancePtr != NULL) {
panic("tried to delete pixmap image when instances still exist");
}
masterPtr->tkMaster = NULL;
if (masterPtr->imageCmd != NULL) {
Tcl_DeleteCommand(masterPtr->interp,
Tcl_GetCommandName(masterPtr->interp, masterPtr->imageCmd));
}
if (masterPtr->isDataAlloced && masterPtr->data != NULL) {
ckfree((char*)masterPtr->data);
}
Tk_FreeOptions(configSpecs, (char *) masterPtr, (Display *) NULL, 0);
ckfree((char *) masterPtr);
}
/*
*----------------------------------------------------------------------
*
* ImgXpmCmdDeletedProc --
*
* 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
ImgXpmCmdDeletedProc(clientData)
ClientData clientData; /* Pointer to PixmapMaster structure for
* image. */
{
PixmapMaster *masterPtr = (PixmapMaster *) clientData;
masterPtr->imageCmd = NULL;
if (masterPtr->tkMaster != NULL) {
Tk_DeleteImage(masterPtr->interp, Tk_NameOfImage(masterPtr->tkMaster));
}
}
#ifdef STk_CODE
PRIMITIVE STk_init_pixmap(void)
{
Tk_CreateImageType(&tixPixmapImageType);
return UNDEFINED;
}
#else
/*
*----------------------------------------------------------------------
*
* Tix_DefinePixmap
*
* Define an XPM data structure with an unique name, so that you can
* later refer to this pixmap using the -id switch in [image create
* pixmap].
*
* Results:
* None.
*
* Side effects:
* The data is stored in a HashTable.
*----------------------------------------------------------------------
*/
int
Tix_DefinePixmap(interp, name, data)
Tcl_Interp * interp;
Tk_Uid name; /* Name to use for bitmap. Must not already
* be defined as a bitmap. */
char **data;
{
int new;
Tcl_HashEntry *hshPtr;
if (!xpmTableInited) {
xpmTableInited = 1;
Tcl_InitHashTable(&xpmTable, TCL_ONE_WORD_KEYS);
}
hshPtr = Tcl_CreateHashEntry(&xpmTable, name, &new);
if (!new) {
Tcl_AppendResult(interp, "pixmap \"", name,
"\" is already defined", (char *) NULL);
return TCL_ERROR;
}
Tcl_SetHashValue(hshPtr, (char*)data);
return TCL_OK;
}
int
Xpm_Init(interp)
Tcl_Interp *interp; /* Interpreter in which the package is
* to be made available. */
{
Tk_CreateImageType(&tixPixmapImageType);
return TCL_OK;
}
#endif
#else
/* Some compilers hate to produce an empty object file. */
static char dumb = '?';
#endif
Reference in New Issue View Git Blame Copy Permalink