static void BorderElementDraw(
void *clientData, void *elementRecord,
Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned int state)
{
BorderElement *bd = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, bd->borderObj);
XColor *borderColor = Tk_GetColorFromObj(tkwin, bd->borderColorObj);
int borderWidth = 2;
int relief = TK_RELIEF_FLAT;
int defaultState = TTK_BUTTON_DEFAULT_DISABLED;
/*
* Get option values.
*/
Tcl_GetIntFromObj(NULL, bd->borderWidthObj, &borderWidth);
Tk_GetReliefFromObj(NULL, bd->reliefObj, &relief);
Ttk_GetButtonDefaultStateFromObj(NULL, bd->defaultStateObj, &defaultState);
if (defaultState == TTK_BUTTON_DEFAULT_ACTIVE) {
GC gc = Tk_GCForColor(borderColor, d);
XDrawRectangle(Tk_Display(tkwin), d, gc,
b.x, b.y, b.width-1, b.height-1);
}
if (defaultState != TTK_BUTTON_DEFAULT_DISABLED) {
/* Space for default ring: */
b = Ttk_PadBox(b, Ttk_UniformPadding(1));
}
DrawBorder(tkwin, d, border, borderColor, b, borderWidth, relief);
}
static void TreeitemIndicatorDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, Ttk_State state)
{
TreeitemIndicator *indicator = elementRecord;
XColor *color = Tk_GetColorFromObj(tkwin, indicator->colorObj);
GC gc = Tk_GCForColor(color, d);
Ttk_Padding padding = Ttk_UniformPadding(0);
int w = WIN32_XDRAWLINE_HACK;
int cx, cy;
if (state & TTK_STATE_LEAF) {
/* don't draw anything ... */
return;
}
Ttk_GetPaddingFromObj(NULL,tkwin,indicator->marginObj,&padding);
b = Ttk_PadBox(b, padding);
XDrawRectangle(Tk_Display(tkwin), d, gc,
b.x, b.y, b.width - 1, b.height - 1);
cx = b.x + (b.width - 1) / 2;
cy = b.y + (b.height - 1) / 2;
XDrawLine(Tk_Display(tkwin), d, gc, b.x+2, cy, b.x+b.width-3+w, cy);
if (!(state & TTK_STATE_OPEN)) {
/* turn '-' into a '+' */
XDrawLine(Tk_Display(tkwin), d, gc, cx, b.y+2, cx, b.y+b.height-3+w);
}
}
static void MenubuttonArrowElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
MenubuttonArrowElement *arrow = elementRecord;
XColor *arrowColor = Tk_GetColorFromObj(tkwin, arrow->colorObj);
GC gc = Tk_GCForColor(arrowColor, d);
int size = MENUBUTTON_ARROW_SIZE;
int postDirection = POST_BELOW;
ArrowDirection arrowDirection = ARROW_DOWN;
int width = 0, height = 0;
Tk_GetPixelsFromObj(NULL, tkwin, arrow->sizeObj, &size);
Tcl_GetIndexFromObjStruct(NULL, arrow->directionObj, directionStrings,
sizeof(char *), ""/*message*/, 0/*flags*/, &postDirection);
/* ... this might not be such a great idea ... */
switch (postDirection) {
case POST_ABOVE: arrowDirection = ARROW_UP; break;
case POST_BELOW: arrowDirection = ARROW_DOWN; break;
case POST_LEFT: arrowDirection = ARROW_LEFT; break;
case POST_RIGHT: arrowDirection = ARROW_RIGHT; break;
case POST_FLUSH: arrowDirection = ARROW_DOWN; break;
}
TtkArrowSize(size, arrowDirection, &width, &height);
b = Ttk_PadBox(b, MenubuttonArrowPadding);
b = Ttk_AnchorBox(b, width, height, TK_ANCHOR_CENTER);
TtkFillArrow(Tk_Display(tkwin), d, gc, b, arrowDirection);
}
void
Tk_FreeColorFromObj(
Tk_Window tkwin, /* The window this color lives in. Needed for
* the screen and colormap values. */
Tcl_Obj *objPtr) /* The Tcl_Obj * to be freed. */
{
Tk_FreeColor(Tk_GetColorFromObj(tkwin, objPtr));
FreeColorObjProc(objPtr);
}
static void ArrowElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
int direction = *(int *)clientData;
ArrowElement *arrow = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, arrow->borderObj);
XColor *borderColor = Tk_GetColorFromObj(tkwin, arrow->borderColorObj);
XColor *arrowColor = Tk_GetColorFromObj(tkwin, arrow->colorObj);
int relief = TK_RELIEF_RAISED;
int borderWidth = 2;
Tk_GetReliefFromObj(NULL, arrow->reliefObj, &relief);
Tk_Fill3DRectangle(
tkwin, d, border, b.x, b.y, b.width, b.height, 0, TK_RELIEF_FLAT);
DrawBorder(tkwin,d,border,borderColor,b,borderWidth,relief);
TtkFillArrow(Tk_Display(tkwin), d, Tk_GCForColor(arrowColor, d),
Ttk_PadBox(b, ArrowPadding), direction);
}
static void FieldElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
FieldElement *field = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, field->borderObj);
XColor *borderColor = Tk_GetColorFromObj(tkwin, field->borderColorObj);
Tk_Fill3DRectangle(
tkwin, d, border, b.x, b.y, b.width, b.height, 0, TK_RELIEF_SUNKEN);
DrawFieldBorder(tkwin, d, border, borderColor, b);
}
static void HighlightElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
HighlightElement *hl = elementRecord;
int highlightThickness = 0;
XColor *highlightColor = Tk_GetColorFromObj(tkwin, hl->highlightColorObj);
Tcl_GetIntFromObj(NULL,hl->highlightThicknessObj,&highlightThickness);
if (highlightColor && highlightThickness > 0) {
GC gc = Tk_GCForColor(highlightColor, d);
Tk_DrawFocusHighlight(tkwin, gc, highlightThickness, d);
}
}
static void MenuIndicatorElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
MenuIndicatorElement *indicator = elementRecord;
XColor *arrowColor = Tk_GetColorFromObj(tkwin, indicator->colorObj);
GC gc = Tk_GCForColor(arrowColor, d);
int size = MENUBUTTON_ARROW_SIZE;
int width, height;
Tk_GetPixelsFromObj(NULL, tkwin, indicator->sizeObj, &size);
TtkArrowSize(size, ARROW_DOWN, &width, &height);
b = Ttk_StickBox(b, width, height, 0);
TtkFillArrow(Tk_Display(tkwin), d, gc, b, ARROW_DOWN);
}
static void SliderElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
SliderElement *slider = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, slider->borderObj);
XColor *borderColor = Tk_GetColorFromObj(tkwin, slider->borderColorObj);
int relief = TK_RELIEF_RAISED, borderWidth = 2;
Tk_GetPixelsFromObj(NULL, tkwin, slider->borderWidthObj, &borderWidth);
Tk_GetReliefFromObj(NULL, slider->reliefObj, &relief);
Tk_Fill3DRectangle(tkwin, d, border,
b.x, b.y, b.width, b.height,
borderWidth, TK_RELIEF_FLAT);
DrawBorder(tkwin, d, border, borderColor, b, borderWidth, relief);
}
/* @@@ FIX THIS */
static void FillFocusElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
FillFocusElement *focus = elementRecord;
if (state & TTK_STATE_FOCUS) {
RECT rc = BoxToRect(b);
TkWinDCState dcState;
XColor *fillColor = Tk_GetColorFromObj(tkwin, focus->fillColorObj);
GC gc = Tk_GCForColor(fillColor, d);
HDC hdc;
XFillRectangle(Tk_Display(tkwin),d,gc, b.x,b.y,b.width,b.height);
hdc = TkWinGetDrawableDC(Tk_Display(tkwin), d, &dcState);
DrawFocusRect(hdc, &rc);
TkWinReleaseDrawableDC(d, hdc, &dcState);
}
}
/*
* DrawFocusRing --
* Draw a dotted rectangle to indicate focus.
*/
static void DrawFocusRing(
Tk_Window tkwin, Drawable d, Tcl_Obj *colorObj, Ttk_Box b)
{
XColor *color = Tk_GetColorFromObj(tkwin, colorObj);
unsigned long mask = 0UL;
XGCValues gcvalues;
GC gc;
gcvalues.foreground = color->pixel;
gcvalues.line_style = LineOnOffDash;
gcvalues.line_width = 1;
gcvalues.dashes = 1;
gcvalues.dash_offset = 1;
mask = GCForeground | GCLineStyle | GCDashList | GCDashOffset | GCLineWidth;
gc = Tk_GetGC(tkwin, mask, &gcvalues);
XDrawRectangle(Tk_Display(tkwin), d, gc, b.x, b.y, b.width-1, b.height-1);
Tk_FreeGC(Tk_Display(tkwin), gc);
}
/*
* StippleOver --
* Draw a stipple over the image area, to make it look "grayed-out"
* when TTK_STATE_DISABLED is set.
*/
static void StippleOver(
ImageElement *image, Tk_Window tkwin, Drawable d, int x, int y)
{
Pixmap stipple = Tk_AllocBitmapFromObj(NULL, tkwin, image->stippleObj);
XColor *color = Tk_GetColorFromObj(tkwin, image->backgroundObj);
if (stipple != None) {
unsigned long mask = GCFillStyle | GCStipple | GCForeground;
XGCValues gcvalues;
GC gc;
gcvalues.foreground = color->pixel;
gcvalues.fill_style = FillStippled;
gcvalues.stipple = stipple;
gc = Tk_GetGC(tkwin, mask, &gcvalues);
XFillRectangle(Tk_Display(tkwin),d,gc,x,y,image->width,image->height);
Tk_FreeGC(Tk_Display(tkwin), gc);
Tk_FreeBitmapFromObj(tkwin, image->stippleObj);
}
}
static GC Ttk_GCForColor(Tk_Window tkwin, Tcl_Obj* colorObj, Drawable d)
{
GC gc = Tk_GCForColor(Tk_GetColorFromObj(tkwin, colorObj), d);
#ifdef MAC_OSX_TK
/*
* Workaround for Tk bug under Aqua where the default line width is 0.
*/
Display *display = Tk_Display(tkwin);
unsigned long mask = 0ul;
XGCValues gcValues;
gcValues.line_width = 1;
mask = GCLineWidth;
XChangeGC(display, gc, mask, &gcValues);
#endif
return gc;
}
static void ButtonBorderElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
ButtonBorderElement *bd = elementRecord;
int relief = TK_RELIEF_FLAT;
int defaultState = TTK_BUTTON_DEFAULT_DISABLED;
TkWinDCState dcState;
HDC hdc;
RECT rc;
Tk_GetReliefFromObj(NULL, bd->reliefObj, &relief);
Ttk_GetButtonDefaultStateFromObj(NULL, bd->defaultStateObj, &defaultState);
if (defaultState == TTK_BUTTON_DEFAULT_ACTIVE) {
XColor *highlightColor =
Tk_GetColorFromObj(tkwin, bd->highlightColorObj);
GC gc = Tk_GCForColor(highlightColor, d);
XDrawRectangle(Tk_Display(tkwin), d, gc, b.x,b.y,b.width-1,b.height-1);
}
if (defaultState != TTK_BUTTON_DEFAULT_DISABLED) {
++b.x; ++b.y; b.width -= 2; b.height -= 2;
}
hdc = TkWinGetDrawableDC(Tk_Display(tkwin), d, &dcState);
rc = BoxToRect(b);
DrawFrameControl(hdc, &rc,
DFC_BUTTON, /* classId */
DFCS_BUTTONPUSH | Ttk_StateTableLookup(pushbutton_statemap, state));
/* Draw focus ring:
*/
if (state & TTK_STATE_FOCUS) {
short int borderWidth = 3; /* @@@ Use GetSystemMetrics?*/
rc = BoxToRect(Ttk_PadBox(b, Ttk_UniformPadding(borderWidth)));
DrawFocusRect(hdc, &rc);
}
TkWinReleaseDrawableDC(d, hdc, &dcState);
}
static void ThumbElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
ThumbElement *thumb = elementRecord;
Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, thumb->borderObj);
XColor *borderColor = Tk_GetColorFromObj(tkwin, thumb->borderColorObj);
int relief = TK_RELIEF_RAISED;
int borderWidth = 2;
/*
* Don't draw the thumb if we are disabled.
* This makes it behave like Windows ... if that's what we want.
if (state & TTK_STATE_DISABLED)
return;
*/
Tk_GetReliefFromObj(NULL, thumb->reliefObj, &relief);
Tk_Fill3DRectangle(
tkwin, d, border, b.x,b.y,b.width,b.height, 0, TK_RELIEF_FLAT);
DrawBorder(tkwin, d, border, borderColor, b, borderWidth, relief);
}
void
TkpDrawMenuEntry(
TkMenuEntry *mePtr, /* The entry to draw */
Drawable d, /* What to draw into */
Tk_Font tkfont, /* Precalculated font for menu */
const Tk_FontMetrics *menuMetricsPtr,
/* Precalculated metrics for menu */
int x, /* X-coordinate of topleft of entry */
int y, /* Y-coordinate of topleft of entry */
int width, /* Width of the entry rectangle */
int height, /* Height of the current rectangle */
int strictMotif, /* Boolean flag */
int drawArrow) /* Whether or not to draw the cascade arrow
* for cascade items. Only applies to
* Windows. */
{
GC gc, indicatorGC;
XColor *indicatorColor, *disableColor = NULL;
TkMenu *menuPtr = mePtr->menuPtr;
Tk_3DBorder bgBorder, activeBorder;
const Tk_FontMetrics *fmPtr;
Tk_FontMetrics entryMetrics;
int padY = (menuPtr->menuType == MENUBAR) ? 3 : 0;
int adjustedY = y + padY;
int adjustedHeight = height - 2 * padY;
/*
* Choose the gc for drawing the foreground part of the entry.
*/
if ((mePtr->state == ENTRY_ACTIVE) && !strictMotif) {
gc = mePtr->activeGC;
if (gc == NULL) {
gc = menuPtr->activeGC;
}
} else {
TkMenuEntry *cascadeEntryPtr;
int parentDisabled = 0;
for (cascadeEntryPtr = menuPtr->menuRefPtr->parentEntryPtr;
cascadeEntryPtr != NULL;
cascadeEntryPtr = cascadeEntryPtr->nextCascadePtr) {
if (cascadeEntryPtr->namePtr != NULL) {
const char *name = Tcl_GetString(cascadeEntryPtr->namePtr);
if (strcmp(name, Tk_PathName(menuPtr->tkwin)) == 0) {
if (cascadeEntryPtr->state == ENTRY_DISABLED) {
parentDisabled = 1;
}
break;
}
}
}
if (((parentDisabled || (mePtr->state == ENTRY_DISABLED)))
&& (menuPtr->disabledFgPtr != NULL)) {
gc = mePtr->disabledGC;
if (gc == NULL) {
gc = menuPtr->disabledGC;
}
} else {
gc = mePtr->textGC;
if (gc == NULL) {
gc = menuPtr->textGC;
}
}
}
indicatorGC = mePtr->indicatorGC;
if (indicatorGC == NULL) {
indicatorGC = menuPtr->indicatorGC;
}
if (mePtr->indicatorFgPtr) {
indicatorColor = Tk_GetColorFromObj(menuPtr->tkwin,
mePtr->indicatorFgPtr);
} else {
indicatorColor = Tk_GetColorFromObj(menuPtr->tkwin,
menuPtr->indicatorFgPtr);
}
if (menuPtr->disabledFgPtr != NULL) {
disableColor = Tk_GetColorFromObj(menuPtr->tkwin,
menuPtr->disabledFgPtr);
}
bgBorder = Tk_Get3DBorderFromObj(menuPtr->tkwin,
(mePtr->borderPtr == NULL)
? menuPtr->borderPtr : mePtr->borderPtr);
if (strictMotif) {
activeBorder = bgBorder;
} else {
activeBorder = Tk_Get3DBorderFromObj(menuPtr->tkwin,
(mePtr->activeBorderPtr == NULL)
? menuPtr->activeBorderPtr : mePtr->activeBorderPtr);
}
if (mePtr->fontPtr == NULL) {
fmPtr = menuMetricsPtr;
} else {
tkfont = Tk_GetFontFromObj(menuPtr->tkwin, mePtr->fontPtr);
Tk_GetFontMetrics(tkfont, &entryMetrics);
fmPtr = &entryMetrics;
}
/*
* Need to draw the entire background, including padding. On Unix, for
* menubars, we have to draw the rest of the entry taking into account the
* padding.
*/
DrawMenuEntryBackground(menuPtr, mePtr, d, activeBorder,
bgBorder, x, y, width, height);
if (mePtr->type == SEPARATOR_ENTRY) {
DrawMenuSeparator(menuPtr, mePtr, d, gc, tkfont,
fmPtr, x, adjustedY, width, adjustedHeight);
} else if (mePtr->type == TEAROFF_ENTRY) {
DrawTearoffEntry(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, adjustedY,
width, adjustedHeight);
} else {
DrawMenuEntryLabel(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, adjustedY,
width, adjustedHeight);
DrawMenuEntryAccelerator(menuPtr, mePtr, d, gc, tkfont, fmPtr,
activeBorder, x, adjustedY, width, adjustedHeight, drawArrow);
if (!mePtr->hideMargin) {
if (mePtr->state == ENTRY_ACTIVE) {
bgBorder = activeBorder;
}
DrawMenuEntryIndicator(menuPtr, mePtr, d, bgBorder, indicatorColor,
disableColor, tkfont, fmPtr, x, adjustedY, width,
adjustedHeight);
}
}
}
/*
* TextDraw --
* Draw a text element.
* Called by TextElementDraw() and LabelElementDraw().
*/
static void TextDraw(TextElement *text, Tk_Window tkwin, Drawable d, Ttk_Box b)
{
XColor *color = Tk_GetColorFromObj(tkwin, text->foregroundObj);
int underline = -1;
XGCValues gcValues;
GC gc1, gc2;
Tk_Anchor anchor = TK_ANCHOR_CENTER;
TkRegion clipRegion = NULL;
gcValues.font = Tk_FontId(text->tkfont);
gcValues.foreground = color->pixel;
gc1 = Tk_GetGC(tkwin, GCFont | GCForeground, &gcValues);
gcValues.foreground = WhitePixelOfScreen(Tk_Screen(tkwin));
gc2 = Tk_GetGC(tkwin, GCFont | GCForeground, &gcValues);
/*
* Place text according to -anchor:
*/
Tk_GetAnchorFromObj(NULL, text->anchorObj, &anchor);
b = Ttk_AnchorBox(b, text->width, text->height, anchor);
/*
* Clip text if it's too wide:
*/
if (b.width < text->width) {
XRectangle rect;
clipRegion = TkCreateRegion();
rect.x = b.x;
rect.y = b.y;
rect.width = b.width + (text->embossed ? 1 : 0);
rect.height = b.height + (text->embossed ? 1 : 0);
TkUnionRectWithRegion(&rect, clipRegion, clipRegion);
TkSetRegion(Tk_Display(tkwin), gc1, clipRegion);
TkSetRegion(Tk_Display(tkwin), gc2, clipRegion);
#ifdef HAVE_XFT
TkUnixSetXftClipRegion(clipRegion);
#endif
}
if (text->embossed) {
Tk_DrawTextLayout(Tk_Display(tkwin), d, gc2,
text->textLayout, b.x+1, b.y+1, 0/*firstChar*/, -1/*lastChar*/);
}
Tk_DrawTextLayout(Tk_Display(tkwin), d, gc1,
text->textLayout, b.x, b.y, 0/*firstChar*/, -1/*lastChar*/);
Tcl_GetIntFromObj(NULL, text->underlineObj, &underline);
if (underline >= 0) {
if (text->embossed) {
Tk_UnderlineTextLayout(Tk_Display(tkwin), d, gc2,
text->textLayout, b.x+1, b.y+1, underline);
}
Tk_UnderlineTextLayout(Tk_Display(tkwin), d, gc1,
text->textLayout, b.x, b.y, underline);
}
if (clipRegion != NULL) {
#ifdef HAVE_XFT
TkUnixSetXftClipRegion(None);
#endif
XSetClipMask(Tk_Display(tkwin), gc1, None);
XSetClipMask(Tk_Display(tkwin), gc2, None);
TkDestroyRegion(clipRegion);
}
Tk_FreeGC(Tk_Display(tkwin), gc1);
Tk_FreeGC(Tk_Display(tkwin), gc2);
}
static void IndicatorElementDraw(
void *clientData, void *elementRecord, Tk_Window tkwin,
Drawable d, Ttk_Box b, unsigned int state)
{
IndicatorSpec *spec = clientData;
IndicatorElement *indicator = elementRecord;
Display *display = Tk_Display(tkwin);
Ttk_Padding padding;
XColor *fgColor, *frameColor, *shadeColor, *indicatorColor, *borderColor;
int index, ix, iy;
XGCValues gcValues;
GC copyGC;
unsigned long imgColors[8];
XImage *img;
Ttk_GetPaddingFromObj(NULL, tkwin, indicator->marginObj, &padding);
b = Ttk_PadBox(b, padding);
if ( b.x < 0
|| b.y < 0
|| Tk_Width(tkwin) < b.x + spec->width
|| Tk_Height(tkwin) < b.y + spec->height)
{
/* Oops! not enough room to display the image.
* Don't draw anything.
*/
return;
}
/*
* Fill in imgColors palette:
*
* (SHOULD: take light and shade colors from the border object,
* but Tk doesn't provide easy access to these in the public API.)
*/
fgColor = Tk_GetColorFromObj(tkwin, indicator->foregroundObj);
frameColor = Tk_GetColorFromObj(tkwin, indicator->backgroundObj);
shadeColor = Tk_GetColorFromObj(tkwin, indicator->shadeColorObj);
indicatorColor = Tk_GetColorFromObj(tkwin, indicator->colorObj);
borderColor = Tk_GetColorFromObj(tkwin, indicator->borderColorObj);
imgColors[0 /*A*/] = shadeColor->pixel;
imgColors[1 /*B*/] = indicatorColor->pixel;
imgColors[2 /*C*/] = frameColor->pixel;
imgColors[3 /*D*/] = indicatorColor->pixel;
imgColors[4 /*E*/] = borderColor->pixel;
imgColors[5 /*F*/] = frameColor->pixel;
imgColors[6 /*G*/] = fgColor->pixel;
imgColors[7 /*H*/] = fgColor->pixel;
/*
* Create a scratch buffer to store the image:
*/
img = XGetImage(display,d, 0, 0,
(unsigned int)spec->width, (unsigned int)spec->height,
AllPlanes, ZPixmap);
if (img == NULL)
return;
/*
* Create the image, painting it into an XImage one pixel at a time.
*/
index = Ttk_StateTableLookup(spec->map, state);
for (iy=0 ; iy<spec->height ; iy++) {
for (ix=0 ; ix<spec->width ; ix++) {
XPutPixel(img, ix, iy,
imgColors[spec->pixels[iy][index*spec->width+ix] - 'A'] );
}
}
/*
* Copy onto our target drawable surface.
*/
memset(&gcValues, 0, sizeof(gcValues));
copyGC = Tk_GetGC(tkwin, 0, &gcValues);
TkPutImage(NULL, 0, display, d, copyGC, img, 0, 0, b.x, b.y,
spec->width, spec->height);
/*
* Tidy up.
*/
Tk_FreeGC(display, copyGC);
XDestroyImage(img);
}
