/* ARGSUSED */
Pixmap
Tk_GetBitmapFromData(
Tcl_Interp *interp, /* Interpreter to use for error reporting. */
Tk_Window tkwin, /* Window in which bitmap will be used. */
const void *source, /* Bitmap data for bitmap shape. */
int width, int height) /* Dimensions of bitmap. */
{
DataKey nameKey;
Tcl_HashEntry *dataHashPtr;
int isNew;
char string[16 + TCL_INTEGER_SPACE];
char *name;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
ThreadSpecificData *tsdPtr =
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
if (!tsdPtr->initialized) {
BitmapInit(dispPtr);
}
nameKey.source = source;
nameKey.width = width;
nameKey.height = height;
dataHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapDataTable,
(char *) &nameKey, &isNew);
if (!isNew) {
name = Tcl_GetHashValue(dataHashPtr);
} else {
dispPtr->bitmapAutoNumber++;
sprintf(string, "_tk%d", dispPtr->bitmapAutoNumber);
name = string;
Tcl_SetHashValue(dataHashPtr, name);
if (Tk_DefineBitmap(interp, name, source, width, height) != TCL_OK) {
Tcl_DeleteHashEntry(dataHashPtr);
return TCL_ERROR;
}
}
return Tk_GetBitmap(interp, tkwin, name);
}
void
TreeDragImage_Draw(
TreeDragImage dragImage, /* Drag image record. */
TreeDrawable td) /* Where to draw. */
{
#ifdef DRAG_PIXMAP
DrawPixmap(tree->dragImage, tdrawable);
#elif 1 /* Use XOR dotted rectangles where possible. */
TreeCtrl *tree = dragImage->tree;
if (!dragImage->visible)
return;
#ifdef DRAGIMAGE_STYLE
if (dragImage->instanceStyle != NULL) {
DragImage_DrawStyle(dragImage, td);
return;
}
#endif /* DRAGIMAGE_STYLE */
/* Yes this is XOR drawing but we aren't erasing the previous
* dragimage as when TreeDragImage_IsXOR() returns TRUE. */
TreeDragImage_DrawXOR(dragImage, td.drawable,
0 - tree->xOrigin, 0 - tree->yOrigin);
#else /* */
TreeCtrl *tree = dragImage->tree;
GC gc;
DragElem *elem;
#if 1 /* Stippled rectangles: BUG not clipped to contentbox. */
XGCValues gcValues;
unsigned long mask;
XPoint points[5];
if (!dragImage->visible)
return;
gcValues.stipple = Tk_GetBitmap(tree->interp, tree->tkwin, "gray50");
gcValues.fill_style = FillStippled;
mask = GCStipple|GCFillStyle;
gc = Tk_GetGC(tree->tkwin, mask, &gcValues);
for (elem = dragImage->elem; elem != NULL; elem = elem->next) {
XRectangle rect;
rect.x = dragImage->x + elem->x /*- dragImage->bounds[0]*/ - tree->drawableXOrigin;
rect.y = dragImage->y + elem->y /*- dragImage->bounds[1]*/ - tree->drawableYOrigin;
rect.width = elem->width;
rect.height = elem->height;
#ifdef WIN32
/* XDrawRectangle ignores the stipple pattern. */
points[0].x = rect.x, points[0].y = rect.y;
points[1].x = rect.x + rect.width - 1, points[1].y = rect.y;
points[2].x = rect.x + rect.width - 1, points[2].y = rect.y + rect.height - 1;
points[3].x = rect.x, points[3].y = rect.y + rect.height - 1;
points[4] = points[0];
XDrawLines(tree->display, td.drawable, gc, points, 5, CoordModeOrigin);
#else /* !WIN32 */
XDrawRectangle(tree->display, td.drawable, gc, rect.x, rect.y,
rect.width - 1, rect.height - 1);
#endif
}
Tk_FreeGC(tree->display, gc);
#else /* Debug/test: gray rectangles */
XColor *colorPtr;
TkRegion rgn;
if (!dragImage->visible)
return;
colorPtr = Tk_GetColor(tree->interp, tree->tkwin, "gray50");
gc = Tk_GCForColor(colorPtr, Tk_WindowId(tree->tkwin));
rgn = Tree_GetRegion(tree);
for (elem = dragImage->elem; elem != NULL; elem = elem->next) {
XRectangle rect;
rect.x = dragImage->x + elem->x /*- dragImage->bounds[0]*/ - tree->drawableXOrigin;
rect.y = dragImage->y + elem->y /*- dragImage->bounds[1]*/ - tree->drawableYOrigin;
rect.width = elem->width;
rect.height = elem->height;
TkUnionRectWithRegion(&rect, rgn, rgn);
}
Tree_FillRegion(tree->display, td.drawable, gc, rgn);
Tree_FreeRegion(tree, rgn);
#endif /* Debug/test: gray rectangles */
#endif /* XOR */
}
static int
DoConfig(
Tcl_Interp *interp, /* Interpreter for error reporting. */
Tk_Window tkwin, /* Window containing widget (needed to set up
* X resources). */
Tk_ConfigSpec *specPtr, /* Specifier to apply. */
Tk_Uid value, /* Value to use to fill in widgRec. */
int valueIsUid, /* Non-zero means value is a Tk_Uid; zero
* means it's an ordinary string. */
char *widgRec) /* Record whose fields are to be modified.
* Values must be properly initialized. */
{
char *ptr;
Tk_Uid uid;
int nullValue;
nullValue = 0;
if ((*value == 0) && (specPtr->specFlags & TK_CONFIG_NULL_OK)) {
nullValue = 1;
}
do {
ptr = widgRec + specPtr->offset;
switch (specPtr->type) {
case TK_CONFIG_BOOLEAN:
if (Tcl_GetBoolean(interp, value, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_INT:
if (Tcl_GetInt(interp, value, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_DOUBLE:
if (Tcl_GetDouble(interp, value, (double *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_STRING: {
char *oldStr, *newStr;
if (nullValue) {
newStr = NULL;
} else {
newStr = (char *) ckalloc((unsigned) (strlen(value) + 1));
strcpy(newStr, value);
}
oldStr = *((char **) ptr);
if (oldStr != NULL) {
ckfree(oldStr);
}
*((char **) ptr) = newStr;
break;
}
case TK_CONFIG_UID:
if (nullValue) {
*((Tk_Uid *) ptr) = NULL;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
*((Tk_Uid *) ptr) = uid;
}
break;
case TK_CONFIG_COLOR: {
XColor *newPtr, *oldPtr;
if (nullValue) {
newPtr = NULL;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newPtr = Tk_GetColor(interp, tkwin, uid);
if (newPtr == NULL) {
return TCL_ERROR;
}
}
oldPtr = *((XColor **) ptr);
if (oldPtr != NULL) {
Tk_FreeColor(oldPtr);
}
*((XColor **) ptr) = newPtr;
break;
}
case TK_CONFIG_FONT: {
Tk_Font newFont;
if (nullValue) {
newFont = NULL;
} else {
newFont = Tk_GetFont(interp, tkwin, value);
if (newFont == NULL) {
return TCL_ERROR;
}
}
Tk_FreeFont(*((Tk_Font *) ptr));
*((Tk_Font *) ptr) = newFont;
break;
}
case TK_CONFIG_BITMAP: {
Pixmap newBmp, oldBmp;
if (nullValue) {
newBmp = None;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newBmp = Tk_GetBitmap(interp, tkwin, uid);
if (newBmp == None) {
return TCL_ERROR;
}
}
oldBmp = *((Pixmap *) ptr);
if (oldBmp != None) {
Tk_FreeBitmap(Tk_Display(tkwin), oldBmp);
}
*((Pixmap *) ptr) = newBmp;
break;
}
case TK_CONFIG_BORDER: {
Tk_3DBorder newBorder, oldBorder;
if (nullValue) {
newBorder = NULL;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newBorder = Tk_Get3DBorder(interp, tkwin, uid);
if (newBorder == NULL) {
return TCL_ERROR;
}
}
oldBorder = *((Tk_3DBorder *) ptr);
if (oldBorder != NULL) {
Tk_Free3DBorder(oldBorder);
}
*((Tk_3DBorder *) ptr) = newBorder;
break;
}
case TK_CONFIG_RELIEF:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetRelief(interp, uid, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_CURSOR:
case TK_CONFIG_ACTIVE_CURSOR: {
Tk_Cursor newCursor, oldCursor;
if (nullValue) {
newCursor = None;
} else {
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
newCursor = Tk_GetCursor(interp, tkwin, uid);
if (newCursor == None) {
return TCL_ERROR;
}
}
oldCursor = *((Tk_Cursor *) ptr);
if (oldCursor != None) {
Tk_FreeCursor(Tk_Display(tkwin), oldCursor);
}
*((Tk_Cursor *) ptr) = newCursor;
if (specPtr->type == TK_CONFIG_ACTIVE_CURSOR) {
Tk_DefineCursor(tkwin, newCursor);
}
break;
}
case TK_CONFIG_JUSTIFY:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetJustify(interp, uid, (Tk_Justify *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_ANCHOR:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetAnchor(interp, uid, (Tk_Anchor *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_CAP_STYLE:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetCapStyle(interp, uid, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_JOIN_STYLE:
uid = valueIsUid ? (Tk_Uid) value : Tk_GetUid(value);
if (Tk_GetJoinStyle(interp, uid, (int *) ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_PIXELS:
if (Tk_GetPixels(interp, tkwin, value, (int *) ptr)
!= TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_MM:
if (Tk_GetScreenMM(interp, tkwin, value, (double*)ptr) != TCL_OK) {
return TCL_ERROR;
}
break;
case TK_CONFIG_WINDOW: {
Tk_Window tkwin2;
if (nullValue) {
tkwin2 = NULL;
} else {
tkwin2 = Tk_NameToWindow(interp, value, tkwin);
if (tkwin2 == NULL) {
return TCL_ERROR;
}
}
*((Tk_Window *) ptr) = tkwin2;
break;
}
case TK_CONFIG_CUSTOM:
if ((*specPtr->customPtr->parseProc)(
specPtr->customPtr->clientData, interp, tkwin, value,
widgRec, specPtr->offset) != TCL_OK) {
return TCL_ERROR;
}
break;
default: {
char buf[64 + TCL_INTEGER_SPACE];
sprintf(buf, "bad config table: unknown type %d", specPtr->type);
Tcl_SetResult(interp, buf, TCL_VOLATILE);
return TCL_ERROR;
}
}
specPtr++;
} while ((specPtr->argvName == NULL) && (specPtr->type != TK_CONFIG_END));
return TCL_OK;
}
void
TreeMarquee_Draw(
TreeMarquee marquee, /* Marquee token. */
TreeDrawable td) /* Where to draw. */
{
#if 1 /* Use XOR dotted rectangles where possible. */
TreeCtrl *tree = marquee->tree;
if (!marquee->visible)
return;
/* Yes this is XOR drawing but we aren't erasing the previous
* marquee as when TreeMarquee_IsXOR() returns TRUE. */
TreeMarquee_DrawXOR(marquee, td.drawable,
0 - tree->xOrigin, 0 - tree->yOrigin);
#else /* */
TreeCtrl *tree = marquee->tree;
int x, y, w, h;
GC gc;
XGCValues gcValues;
unsigned long mask;
#ifdef WIN32
XPoint points[5];
XRectangle rect;
#endif
#if 0
XColor *colorPtr;
#endif
if (!marquee->visible)
return;
x = MIN(marquee->x1, marquee->x2);
w = abs(marquee->x1 - marquee->x2) + 1;
y = MIN(marquee->y1, marquee->y2);
h = abs(marquee->y1 - marquee->y2) + 1;
#if 0
colorPtr = Tk_GetColor(tree->interp, tree->tkwin, "gray50");
gc = Tk_GCForColor(colorPtr, Tk_WindowId(tree->tkwin));
XFillRectangle(tree->display, td.drawable, gc,
x - tree->drawableXOrigin, y - tree->drawableYOrigin,
w - 1, h - 1);
#else /* Stippled rectangles: BUG not clipped to contentbox. */
gcValues.stipple = Tk_GetBitmap(tree->interp, tree->tkwin, "gray50");
gcValues.fill_style = FillStippled;
mask = GCStipple|GCFillStyle;
gc = Tk_GetGC(tree->tkwin, mask, &gcValues);
#ifdef WIN32
/* XDrawRectangle ignores the stipple pattern. */
rect.x = x - tree->drawableXOrigin;
rect.y = y - tree->drawableYOrigin;
rect.width = w;
rect.height = h;
points[0].x = rect.x, points[0].y = rect.y;
points[1].x = rect.x + rect.width - 1, points[1].y = rect.y;
points[2].x = rect.x + rect.width - 1, points[2].y = rect.y + rect.height - 1;
points[3].x = rect.x, points[3].y = rect.y + rect.height - 1;
points[4] = points[0];
XDrawLines(tree->display, td.drawable, gc, points, 5, CoordModeOrigin);
#else
XDrawRectangle(tree->display, td.drawable, gc,
x - tree->drawableXOrigin, y - tree->drawableYOrigin,
w - 1, h - 1);
#endif
Tk_FreeGC(tree->display, gc);
#endif
#endif /* */
}
void
TkMenuButtonWorldChanged(
ClientData instanceData) /* Information about widget. */
{
XGCValues gcValues;
GC gc;
unsigned long mask;
TkMenuButton *mbPtr = instanceData;
gcValues.font = Tk_FontId(mbPtr->tkfont);
gcValues.foreground = mbPtr->normalFg->pixel;
gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel;
/*
* Note: GraphicsExpose events are disabled in GC's because they're used
* to copy stuff from an off-screen pixmap onto the screen (we know that
* there's no problem with obscured areas).
*/
gcValues.graphics_exposures = False;
mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
if (mbPtr->normalTextGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->normalTextGC);
}
mbPtr->normalTextGC = gc;
gcValues.foreground = mbPtr->activeFg->pixel;
gcValues.background = Tk_3DBorderColor(mbPtr->activeBorder)->pixel;
mask = GCForeground | GCBackground | GCFont;
gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
if (mbPtr->activeTextGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->activeTextGC);
}
mbPtr->activeTextGC = gc;
gcValues.background = Tk_3DBorderColor(mbPtr->normalBorder)->pixel;
/*
* Create the GC that can be used for stippling
*/
if (mbPtr->stippleGC == None) {
gcValues.foreground = gcValues.background;
mask = GCForeground;
if (mbPtr->gray == None) {
mbPtr->gray = Tk_GetBitmap(NULL, mbPtr->tkwin, "gray50");
}
if (mbPtr->gray != None) {
gcValues.fill_style = FillStippled;
gcValues.stipple = mbPtr->gray;
mask |= GCFillStyle | GCStipple;
}
mbPtr->stippleGC = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
}
/*
* Allocate the disabled graphics context, for drawing text in its
* disabled state.
*/
mask = GCForeground | GCBackground | GCFont;
if (mbPtr->disabledFg != NULL) {
gcValues.foreground = mbPtr->disabledFg->pixel;
} else {
gcValues.foreground = gcValues.background;
}
gc = Tk_GetGC(mbPtr->tkwin, mask, &gcValues);
if (mbPtr->disabledGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->disabledGC);
}
mbPtr->disabledGC = gc;
TkpComputeMenuButtonGeometry(mbPtr);
/*
* Lastly, arrange for the button to be redisplayed.
*/
if (Tk_IsMapped(mbPtr->tkwin) && !(mbPtr->flags & REDRAW_PENDING)) {
Tcl_DoWhenIdle(TkpDisplayMenuButton, mbPtr);
mbPtr->flags |= REDRAW_PENDING;
}
}
void
plD_esc_ntk(PLStream *pls, PLINT op, void *ptr)
{
PLINT i,j;
short *xa, *ya;
Pixmap bitmap;
static unsigned char bit_pat[] = {
0x24, 0x01, 0x92, 0x00, 0x49, 0x00, 0x24, 0x00, 0x12, 0x00, 0x09, 0x00,
0x04, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff};
switch (op) {
case PLESC_DASH:
xa = (short *) malloc(sizeof(short) * pls->dev_npts);
ya = (short *) malloc(sizeof(short) * pls->dev_npts);
for (i = 0; i < pls->dev_npts; i++) {
xa[i] = pls->dev_x[i];
ya[i] = pls->dev_y[i];
}
j = sprintf(dash, "-dash {");
for (i = 0; i < pls->nms; i++)
j += sprintf(&dash[j]," %d %d",
(int) ceil(pls->mark[i]/1e3 * ppm),
(int) ceil(pls->space[i]/1e3 * ppm));
sprintf(&dash[j], "}");
plD_polyline_ntk(pls, xa, ya, pls->dev_npts);
free(xa); free(ya);
dash[0] = 0;
break;
case PLESC_FLUSH:
tk_cmd("update");
break;
case PLESC_GETC:
getcursor(pls, (PLGraphicsIn *) ptr);
break;
case PLESC_FILL:
if (pls->patt != 0) {
/* this is a hack! The real solution is in the if(0) bellow */
pls->xpmm *= scale;
pls->ypmm *= scale;
plfill_soft( pls->dev_x, pls->dev_y, pls->dev_npts);
pls->xpmm /= scale;
pls->ypmm /= scale;
} else {
j = sprintf(cmd, "$plf.f2.c%d create polygon ", ccanv);
for (i = 0; i < pls->dev_npts; i++)
j += sprintf(&cmd[j], "%.1f %.1f ", pls->dev_x[i]/scale,
ymax-pls->dev_y[i]/scale);
j += sprintf(&cmd[j]," -fill %s", curcolor);
tk_cmd(cmd);
}
if (0) {
if (pls->patt != 0) {
Tk_DefineBitmap(interp, Tk_GetUid("foo"), bit_pat, 16, 16);
bitmap = Tk_GetBitmap(interp, mainw, Tk_GetUid("patt"));
}
j = sprintf(cmd, "$plf.f2.c%d create polygon ", ccanv);
for (i = 0; i < pls->dev_npts; i++)
j += sprintf(&cmd[j], "%.1f %.1f ", pls->dev_x[i]/scale,
ymax-pls->dev_y[i]/scale);
j += sprintf(&cmd[j]," -fill %s", curcolor);
if (pls->patt != 0)
sprintf(&cmd[j], " -stipple patt -outline black");
tk_cmd(cmd);
/*Tk_FreeBitmap(display, bitmap)*/
}
break;
}
}
