static PyObject *
tkwin_GetGC(TkWinObject * self, PyObject* args, PyObject * kwargs)
{
Display * display;
GC gc;
unsigned long mask = 0;
XGCValues values;
PyObject * dict;
if (PySequence_Length(args) > 0)
{
if (!PyArg_ParseTuple(args, "O", &dict))
return NULL;
}
else
dict = kwargs;
display = Tk_Display(self->tkwin);
if (dict)
{
if (!PaxGC_MakeValues(dict, &mask, &values))
return NULL;
}
gc = Tk_GetGC(self->tkwin, mask, &values);
return PaxGC_FromGC(display, Tk_WindowId(self->tkwin), gc, PAXGC_SHARED,
NULL);
}
static void
ScaleWorldChanged(
ClientData instanceData) /* Information about widget. */
{
XGCValues gcValues;
GC gc;
TkScale *scalePtr = instanceData;
gcValues.foreground = scalePtr->troughColorPtr->pixel;
gc = Tk_GetGC(scalePtr->tkwin, GCForeground, &gcValues);
if (scalePtr->troughGC != None) {
Tk_FreeGC(scalePtr->display, scalePtr->troughGC);
}
scalePtr->troughGC = gc;
gcValues.font = Tk_FontId(scalePtr->tkfont);
gcValues.foreground = scalePtr->textColorPtr->pixel;
gc = Tk_GetGC(scalePtr->tkwin, GCForeground | GCFont, &gcValues);
if (scalePtr->textGC != None) {
Tk_FreeGC(scalePtr->display, scalePtr->textGC);
}
scalePtr->textGC = gc;
if (scalePtr->copyGC == None) {
gcValues.graphics_exposures = False;
scalePtr->copyGC = Tk_GetGC(scalePtr->tkwin, GCGraphicsExposures,
&gcValues);
}
scalePtr->inset = scalePtr->highlightWidth + scalePtr->borderWidth;
/*
* Recompute display-related information, and let the geometry manager
* know how much space is needed now.
*/
ComputeScaleGeometry(scalePtr);
TkEventuallyRedrawScale(scalePtr, REDRAW_ALL);
}
Pixmap
HtmlImageTilePixmap(
HtmlImage2* pImage,
int *pW,
int *pH
)
{
if (HtmlImagePixmap(pImage)) {
Tk_Window win;
XGCValues gc_values;
GC gc;
int i, j;
if( pImage->tilepixmap ){
goto return_tile;
}
if (!tilesize(pImage, &pImage->iTileWidth, &pImage->iTileHeight)) {
goto return_original;
}
win = pImage->pImageServer->pTree->tkwin;
pImage->tilepixmap = Tk_GetPixmap(Tk_Display(win), Tk_WindowId(win),
pImage->iTileWidth, pImage->iTileHeight, Tk_Depth(win)
);
memset(&gc_values, 0, sizeof(XGCValues));
gc = Tk_GetGC(win, 0, &gc_values);
for (i = 0; i < pImage->iTileWidth; i += pImage->width){
for (j = 0; j < pImage->iTileHeight; j += pImage->height){
XCopyArea(Tk_Display(win),
pImage->pixmap, pImage->tilepixmap, gc, 0, 0,
pImage->width, pImage->height,
i, j
);
}
}
Tk_FreeGC(Tk_Display(win), gc);
}
return_tile:
*pW = pImage->iTileWidth;
*pH = pImage->iTileHeight;
return pImage->tilepixmap;
return_original:
*pW = pImage->width;
*pH = pImage->height;
return pImage->pixmap;
}
int draw_image (ClientData cd, Tcl_Interp *interp, int argc, char **argv) {
Tk_Window tkwin;
Display *display;
Window window;
GC gc;
Tk_Window interpWin;
interpWin=(Tk_Window) cd;
tkwin=Tk_NameToWindow (interp,".c",interpWin);
display=Tk_Display (tkwin);
window=Tk_WindowId (tkwin);
gc=Tk_GetGC (tkwin,0,NULL);
if (ximage!=NULL) {
XPutImage (display,window,gc,ximage,0,0,0,0,RESX,RESY);
}
return 0;
}
/*
* 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 ClientData
ImageGet(
Tk_Window tkwin, /* Token for window in which image will be
* used. */
ClientData clientData) /* Pointer to TImageMaster for image. */
{
TImageMaster *timPtr = clientData;
TImageInstance *instPtr;
char buffer[100];
XGCValues gcValues;
sprintf(buffer, "%s get", timPtr->imageName);
Tcl_SetVar(timPtr->interp, timPtr->varName, buffer,
TCL_GLOBAL_ONLY|TCL_APPEND_VALUE|TCL_LIST_ELEMENT);
instPtr = (TImageInstance *) ckalloc(sizeof(TImageInstance));
instPtr->masterPtr = timPtr;
instPtr->fg = Tk_GetColor(timPtr->interp, tkwin, "#ff0000");
gcValues.foreground = instPtr->fg->pixel;
instPtr->gc = Tk_GetGC(tkwin, GCForeground, &gcValues);
return instPtr;
}
void expose_handler (ClientData cd, XEvent *ev) {
Display *display;
Window window;
Visual *visual;
GC gc;
int screen;
int depth;
Tk_Window tkwin;
tkwin=(Tk_Window) cd;
display=Tk_Display (tkwin);
window=Tk_WindowId (tkwin);
gc=Tk_GetGC (tkwin,0,NULL);
visual=Tk_Visual (tkwin);
if (ximage==NULL) {
screen=DefaultScreen (display);
depth=DisplayPlanes (display,screen);
image_data=(char *) malloc (RESX*RESY);
ximage=XCreateImage
(display,visual,depth,ZPixmap,0,image_data,RESX,RESY,8,0);
gen_image ();
}
}
/*
* 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);
}
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 */
}
Tk_3DBorder
Tk_Get3DBorder(
Tcl_Interp *interp, /* Place to store an error message. */
Tk_Window tkwin, /* Token for window in which border will be
* drawn. */
Tk_Uid colorName) /* String giving name of color for window
* background. */
{
Tcl_HashEntry *hashPtr;
TkBorder *borderPtr, *existingBorderPtr;
int isNew;
XGCValues gcValues;
XColor *bgColorPtr;
TkDisplay *dispPtr;
dispPtr = ((TkWindow *) tkwin)->dispPtr;
if (!dispPtr->borderInit) {
BorderInit(dispPtr);
}
hashPtr = Tcl_CreateHashEntry(&dispPtr->borderTable, colorName, &isNew);
if (!isNew) {
existingBorderPtr = (TkBorder *) Tcl_GetHashValue(hashPtr);
for (borderPtr = existingBorderPtr; borderPtr != NULL;
borderPtr = borderPtr->nextPtr) {
if ((Tk_Screen(tkwin) == borderPtr->screen)
&& (Tk_Colormap(tkwin) == borderPtr->colormap)) {
borderPtr->resourceRefCount++;
return (Tk_3DBorder) borderPtr;
}
}
} else {
existingBorderPtr = NULL;
}
/*
* No satisfactory border exists yet. Initialize a new one.
*/
bgColorPtr = Tk_GetColor(interp, tkwin, colorName);
if (bgColorPtr == NULL) {
if (isNew) {
Tcl_DeleteHashEntry(hashPtr);
}
return NULL;
}
borderPtr = TkpGetBorder();
borderPtr->screen = Tk_Screen(tkwin);
borderPtr->visual = Tk_Visual(tkwin);
borderPtr->depth = Tk_Depth(tkwin);
borderPtr->colormap = Tk_Colormap(tkwin);
borderPtr->resourceRefCount = 1;
borderPtr->objRefCount = 0;
borderPtr->bgColorPtr = bgColorPtr;
borderPtr->darkColorPtr = NULL;
borderPtr->lightColorPtr = NULL;
borderPtr->shadow = None;
borderPtr->bgGC = None;
borderPtr->darkGC = None;
borderPtr->lightGC = None;
borderPtr->hashPtr = hashPtr;
borderPtr->nextPtr = existingBorderPtr;
Tcl_SetHashValue(hashPtr, borderPtr);
/*
* Create the information for displaying the background color, but delay
* the allocation of shadows until they are actually needed for drawing.
*/
gcValues.foreground = borderPtr->bgColorPtr->pixel;
borderPtr->bgGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
return (Tk_3DBorder) borderPtr;
}
callGraphConsts::callGraphConsts(Tcl_Interp *interp, Tk_Window theTkWindow) {
display = Tk_Display(theTkWindow); // needed in destructor
textColor = Tk_GetColor(interp, theTkWindow, Tk_GetUid("black"));
assert(textColor);
// Root Item FontStruct's:
Tk_Uid rootItemFontName = Tk_GetOption( theTkWindow,
"listRootItemFont",
"Font" );
assert( rootItemFontName != NULL );
rootItemFontStruct = Tk_GetFont( interp, theTkWindow, rootItemFontName );
Tk_Uid rootItemItalicFontName = Tk_GetOption( theTkWindow,
"listRootItemEmphFont",
"Font" );
assert( rootItemItalicFontName != NULL );
rootItemItalicFontStruct = Tk_GetFont( interp, theTkWindow,
rootItemItalicFontName );
// Root Item Text GCs:
XGCValues values;
values.foreground = textColor->pixel;
values.font = Tk_FontId(rootItemFontStruct);
rootItemTextGC = Tk_GetGC(theTkWindow, GCForeground | GCFont, &values);
assert(rootItemTextGC);
values.font = Tk_FontId(rootItemItalicFontStruct);
values.foreground = textColor->pixel;
rootItemShadowTextGC = Tk_GetGC(theTkWindow, GCForeground | GCFont,
&values);
assert(rootItemShadowTextGC);
// Listbox FontStruct's:
Tk_Uid listboxItemFontName = Tk_GetOption( theTkWindow,
"listItemFont",
"Font" );
assert( listboxItemFontName );
listboxItemFontStruct = Tk_GetFont(interp,
theTkWindow,
listboxItemFontName );
Tk_Uid listboxItemItalicFontName = Tk_GetOption( theTkWindow,
"listItemEmphFont",
"Font" );
assert( listboxItemItalicFontName );
listboxItemItalicFontStruct = Tk_GetFont(interp,
theTkWindow,
listboxItemItalicFontName );
// Listbox Item Text GCs:
values.foreground = textColor->pixel;
values.font = Tk_FontId(listboxItemFontStruct);
listboxItemGC = Tk_GetGC(theTkWindow, GCForeground | GCFont, &values);
assert(listboxItemGC);
values.font = Tk_FontId(listboxItemItalicFontStruct);
values.foreground = textColor->pixel;
listboxItemShadowTextGC = Tk_GetGC(theTkWindow, GCForeground | GCFont,
&values);
assert(listboxItemShadowTextGC);
rootItemTk3DBordersByStyle.resize(2);
//Color for non-recursive nodes
rootItemTk3DBordersByStyle[0] = Tk_Get3DBorder(interp, theTkWindow,
Tk_GetUid("gray"));
assert(rootItemTk3DBordersByStyle[0]);
//Color for recursive nodes
rootItemTk3DBordersByStyle[1] = Tk_Get3DBorder(interp, theTkWindow,
Tk_GetUid("#60c0a0"));
//green
assert(rootItemTk3DBordersByStyle[1]);
listboxItemTk3DBordersByStyle = rootItemTk3DBordersByStyle;
// 3D borders for listbox:
// It seems reasonable to use the exact same colors for shg listbox items:
//listboxScrollbarBorder = rootItemBorder;
}
static int
ConfigureRectOval(
Tcl_Interp *interp, /* Used for error reporting. */
Tk_Canvas canvas, /* Canvas containing itemPtr. */
Tk_Item *itemPtr, /* Rectangle item to reconfigure. */
int objc, /* Number of elements in objv. */
Tcl_Obj *const objv[], /* Arguments describing things to configure. */
int flags) /* Flags to pass to Tk_ConfigureWidget. */
{
RectOvalItem *rectOvalPtr = (RectOvalItem *) itemPtr;
XGCValues gcValues;
GC newGC;
unsigned long mask;
Tk_Window tkwin;
Tk_TSOffset *tsoffset;
XColor *color;
Pixmap stipple;
Tk_State state;
tkwin = Tk_CanvasTkwin(canvas);
if (TCL_OK != Tk_ConfigureWidget(interp, tkwin, configSpecs, objc,
(const char **)objv, (char *) rectOvalPtr, flags|TK_CONFIG_OBJS)) {
return TCL_ERROR;
}
state = itemPtr->state;
/*
* A few of the options require additional processing, such as graphics
* contexts.
*/
if (rectOvalPtr->outline.activeWidth > rectOvalPtr->outline.width ||
rectOvalPtr->outline.activeDash.number != 0 ||
rectOvalPtr->outline.activeColor != NULL ||
rectOvalPtr->outline.activeStipple != None ||
rectOvalPtr->activeFillColor != NULL ||
rectOvalPtr->activeFillStipple != None) {
itemPtr->redraw_flags |= TK_ITEM_STATE_DEPENDANT;
} else {
itemPtr->redraw_flags &= ~TK_ITEM_STATE_DEPENDANT;
}
tsoffset = &rectOvalPtr->outline.tsoffset;
flags = tsoffset->flags;
if (flags & TK_OFFSET_LEFT) {
tsoffset->xoffset = (int) (rectOvalPtr->bbox[0] + 0.5);
} else if (flags & TK_OFFSET_CENTER) {
tsoffset->xoffset = (int)
((rectOvalPtr->bbox[0]+rectOvalPtr->bbox[2]+1)/2);
} else if (flags & TK_OFFSET_RIGHT) {
tsoffset->xoffset = (int) (rectOvalPtr->bbox[2] + 0.5);
}
if (flags & TK_OFFSET_TOP) {
tsoffset->yoffset = (int) (rectOvalPtr->bbox[1] + 0.5);
} else if (flags & TK_OFFSET_MIDDLE) {
tsoffset->yoffset = (int)
((rectOvalPtr->bbox[1]+rectOvalPtr->bbox[3]+1)/2);
} else if (flags & TK_OFFSET_BOTTOM) {
tsoffset->yoffset = (int) (rectOvalPtr->bbox[2] + 0.5);
}
/*
* Configure the outline graphics context. If mask is non-zero, the gc has
* changed and must be reallocated, provided that the new settings specify
* a valid outline (non-zero width and non-NULL color)
*/
mask = Tk_ConfigOutlineGC(&gcValues, canvas, itemPtr,
&(rectOvalPtr->outline));
if (mask && \
rectOvalPtr->outline.width != 0 && \
rectOvalPtr->outline.color != NULL) {
gcValues.cap_style = CapProjecting;
mask |= GCCapStyle;
newGC = Tk_GetGC(tkwin, mask, &gcValues);
} else {
newGC = None;
}
if (rectOvalPtr->outline.gc != None) {
Tk_FreeGC(Tk_Display(tkwin), rectOvalPtr->outline.gc);
}
rectOvalPtr->outline.gc = newGC;
if (state == TK_STATE_NULL) {
state = Canvas(canvas)->canvas_state;
}
if (state == TK_STATE_HIDDEN) {
ComputeRectOvalBbox(canvas, rectOvalPtr);
return TCL_OK;
}
color = rectOvalPtr->fillColor;
stipple = rectOvalPtr->fillStipple;
if (Canvas(canvas)->currentItemPtr == itemPtr) {
if (rectOvalPtr->activeFillColor!=NULL) {
color = rectOvalPtr->activeFillColor;
}
if (rectOvalPtr->activeFillStipple!=None) {
stipple = rectOvalPtr->activeFillStipple;
}
} else if (state == TK_STATE_DISABLED) {
if (rectOvalPtr->disabledFillColor!=NULL) {
color = rectOvalPtr->disabledFillColor;
}
if (rectOvalPtr->disabledFillStipple!=None) {
stipple = rectOvalPtr->disabledFillStipple;
}
}
if (color == NULL) {
newGC = None;
} else {
gcValues.foreground = color->pixel;
if (stipple != None) {
gcValues.stipple = stipple;
gcValues.fill_style = FillStippled;
mask = GCForeground|GCStipple|GCFillStyle;
} else {
mask = GCForeground;
}
#ifdef MAC_OSX_TK
/*
* Mac OS X CG drawing needs access to the outline linewidth even for
* fills (as linewidth controls antialiasing).
*/
gcValues.line_width = rectOvalPtr->outline.gc != None ?
rectOvalPtr->outline.gc->line_width : 0;
mask |= GCLineWidth;
#endif
newGC = Tk_GetGC(tkwin, mask, &gcValues);
}
if (rectOvalPtr->fillGC != None) {
Tk_FreeGC(Tk_Display(tkwin), rectOvalPtr->fillGC);
}
rectOvalPtr->fillGC = newGC;
tsoffset = &rectOvalPtr->tsoffset;
flags = tsoffset->flags;
if (flags & TK_OFFSET_LEFT) {
tsoffset->xoffset = (int) (rectOvalPtr->bbox[0] + 0.5);
} else if (flags & TK_OFFSET_CENTER) {
tsoffset->xoffset = (int)
((rectOvalPtr->bbox[0]+rectOvalPtr->bbox[2]+1)/2);
} else if (flags & TK_OFFSET_RIGHT) {
tsoffset->xoffset = (int) (rectOvalPtr->bbox[2] + 0.5);
}
if (flags & TK_OFFSET_TOP) {
tsoffset->yoffset = (int) (rectOvalPtr->bbox[1] + 0.5);
} else if (flags & TK_OFFSET_MIDDLE) {
tsoffset->yoffset = (int)
((rectOvalPtr->bbox[1]+rectOvalPtr->bbox[3]+1)/2);
} else if (flags & TK_OFFSET_BOTTOM) {
tsoffset->yoffset = (int) (rectOvalPtr->bbox[3] + 0.5);
}
ComputeRectOvalBbox(canvas, rectOvalPtr);
return TCL_OK;
}
static int
ConfigureBitmap(
Tcl_Interp *interp, /* Used for error reporting. */
Tk_Canvas canvas, /* Canvas containing itemPtr. */
Tk_Item *itemPtr, /* Bitmap item to reconfigure. */
int objc, /* Number of elements in objv. */
Tcl_Obj *const objv[], /* Arguments describing things to configure. */
int flags) /* Flags to pass to Tk_ConfigureWidget. */
{
BitmapItem *bmapPtr = (BitmapItem *) itemPtr;
XGCValues gcValues;
GC newGC;
Tk_Window tkwin;
unsigned long mask;
XColor *fgColor;
XColor *bgColor;
Pixmap bitmap;
Tk_State state;
tkwin = Tk_CanvasTkwin(canvas);
if (TCL_OK != Tk_ConfigureWidget(interp, tkwin, configSpecs, objc,
(const char **) objv, (char *) bmapPtr, flags|TK_CONFIG_OBJS)) {
return TCL_ERROR;
}
/*
* A few of the options require additional processing, such as those that
* determine the graphics context.
*/
state = itemPtr->state;
if (bmapPtr->activeFgColor!=NULL ||
bmapPtr->activeBgColor!=NULL ||
bmapPtr->activeBitmap!=None) {
itemPtr->redraw_flags |= TK_ITEM_STATE_DEPENDANT;
} else {
itemPtr->redraw_flags &= ~TK_ITEM_STATE_DEPENDANT;
}
if (state == TK_STATE_NULL) {
state = Canvas(canvas)->canvas_state;
}
if (state == TK_STATE_HIDDEN) {
ComputeBitmapBbox(canvas, bmapPtr);
return TCL_OK;
}
fgColor = bmapPtr->fgColor;
bgColor = bmapPtr->bgColor;
bitmap = bmapPtr->bitmap;
if (Canvas(canvas)->currentItemPtr == itemPtr) {
if (bmapPtr->activeFgColor!=NULL) {
fgColor = bmapPtr->activeFgColor;
}
if (bmapPtr->activeBgColor!=NULL) {
bgColor = bmapPtr->activeBgColor;
}
if (bmapPtr->activeBitmap!=None) {
bitmap = bmapPtr->activeBitmap;
}
} else if (state == TK_STATE_DISABLED) {
if (bmapPtr->disabledFgColor!=NULL) {
fgColor = bmapPtr->disabledFgColor;
}
if (bmapPtr->disabledBgColor!=NULL) {
bgColor = bmapPtr->disabledBgColor;
}
if (bmapPtr->disabledBitmap!=None) {
bitmap = bmapPtr->disabledBitmap;
}
}
if (bitmap == None) {
newGC = None;
} else {
gcValues.foreground = fgColor->pixel;
mask = GCForeground;
if (bgColor != NULL) {
gcValues.background = bgColor->pixel;
mask |= GCBackground;
} else {
gcValues.clip_mask = bitmap;
mask |= GCClipMask;
}
newGC = Tk_GetGC(tkwin, mask, &gcValues);
}
if (bmapPtr->gc != None) {
Tk_FreeGC(Tk_Display(tkwin), bmapPtr->gc);
}
bmapPtr->gc = newGC;
ComputeBitmapBbox(canvas, bmapPtr);
return TCL_OK;
}
int
Tk_PostscriptImage(
Tk_Image image, /* Token for image to redisplay. */
Tcl_Interp *interp,
Tk_Window tkwin,
Tk_PostscriptInfo psinfo, /* postscript info */
int x, int y, /* Upper-left pixel of region in image that
* needs to be redisplayed. */
int width, int height, /* Dimensions of region to redraw. */
int prepass)
{
Image *imagePtr = (Image *) image;
int result;
XImage *ximage;
Pixmap pmap;
GC newGC;
XGCValues gcValues;
if (imagePtr->masterPtr->typePtr == NULL) {
/*
* No master for image, so nothing to display on postscript.
*/
return TCL_OK;
}
/*
* Check if an image specific postscript-generation function exists;
* otherwise go on with generic code.
*/
if (imagePtr->masterPtr->typePtr->postscriptProc != NULL) {
return imagePtr->masterPtr->typePtr->postscriptProc(
imagePtr->masterPtr->masterData, interp, tkwin, psinfo,
x, y, width, height, prepass);
}
if (prepass) {
return TCL_OK;
}
/*
* Create a Pixmap, tell the image to redraw itself there, and then
* generate an XImage from the Pixmap. We can then read pixel values out
* of the XImage.
*/
pmap = Tk_GetPixmap(Tk_Display(tkwin), Tk_WindowId(tkwin), width, height,
Tk_Depth(tkwin));
gcValues.foreground = WhitePixelOfScreen(Tk_Screen(tkwin));
newGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
if (newGC != NULL) {
XFillRectangle(Tk_Display(tkwin), pmap, newGC, 0, 0,
(unsigned) width, (unsigned) height);
Tk_FreeGC(Tk_Display(tkwin), newGC);
}
Tk_RedrawImage(image, x, y, width, height, pmap, 0, 0);
ximage = XGetImage(Tk_Display(tkwin), pmap, 0, 0,
(unsigned) width, (unsigned) height, AllPlanes, ZPixmap);
Tk_FreePixmap(Tk_Display(tkwin), pmap);
if (ximage == NULL) {
/*
* The XGetImage() function is apparently not implemented on this
* system. Just ignore it.
*/
return TCL_OK;
}
result = TkPostscriptImage(interp, tkwin, psinfo, ximage, x, y,
width, height);
XDestroyImage(ximage);
return result;
}
static void
ImgBmapConfigureInstance(
BitmapInstance *instancePtr)/* Instance to reconfigure. */
{
BitmapMaster *masterPtr = instancePtr->masterPtr;
XColor *colorPtr;
XGCValues gcValues;
GC gc;
unsigned int mask;
Pixmap oldBitmap, oldMask;
/*
* 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;
/*
* Careful: We have to allocate new Pixmaps before deleting the old ones.
* Otherwise, The XID allocator will always return the same XID for the
* new Pixmaps as was used for the old Pixmaps. And that will prevent the
* data and/or mask from changing in the GC below.
*/
oldBitmap = instancePtr->bitmap;
instancePtr->bitmap = None;
oldMask = instancePtr->mask;
instancePtr->mask = 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 (masterPtr->maskData != NULL) {
instancePtr->mask = XCreateBitmapFromData(
Tk_Display(instancePtr->tkwin),
RootWindowOfScreen(Tk_Screen(instancePtr->tkwin)),
masterPtr->maskData, (unsigned) masterPtr->width,
(unsigned) masterPtr->height);
}
if (oldMask != None) {
Tk_FreePixmap(Tk_Display(instancePtr->tkwin), oldMask);
}
if (oldBitmap != None) {
Tk_FreePixmap(Tk_Display(instancePtr->tkwin), oldBitmap);
}
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_GetGC(instancePtr->tkwin, mask, &gcValues);
} 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_AppendObjToErrorInfo(masterPtr->interp, Tcl_ObjPrintf(
"\n (while configuring image \"%s\")", Tk_NameOfImage(
masterPtr->tkMaster)));
Tcl_BackgroundError(masterPtr->interp);
}
static int
ConfigureText(
Tcl_Interp *interp, /* Interpreter for error reporting. */
Tk_Canvas canvas, /* Canvas containing itemPtr. */
Tk_Item *itemPtr, /* Rectangle item to reconfigure. */
int objc, /* Number of elements in objv. */
Tcl_Obj *const objv[], /* Arguments describing things to configure. */
int flags) /* Flags to pass to Tk_ConfigureWidget. */
{
TextItem *textPtr = (TextItem *) itemPtr;
XGCValues gcValues;
GC newGC, newSelGC;
unsigned long mask;
Tk_Window tkwin;
Tk_CanvasTextInfo *textInfoPtr = textPtr->textInfoPtr;
XColor *selBgColorPtr;
XColor *color;
Pixmap stipple;
Tk_State state;
tkwin = Tk_CanvasTkwin(canvas);
if (TCL_OK != Tk_ConfigureWidget(interp, tkwin, configSpecs, objc,
(const char **) objv, (char *) textPtr, flags|TK_CONFIG_OBJS)) {
return TCL_ERROR;
}
/*
* A few of the options require additional processing, such as graphics
* contexts.
*/
state = itemPtr->state;
if (textPtr->activeColor != NULL || textPtr->activeStipple != None) {
itemPtr->redraw_flags |= TK_ITEM_STATE_DEPENDANT;
} else {
itemPtr->redraw_flags &= ~TK_ITEM_STATE_DEPENDANT;
}
if (state == TK_STATE_NULL) {
state = Canvas(canvas)->canvas_state;
}
color = textPtr->color;
stipple = textPtr->stipple;
if (Canvas(canvas)->currentItemPtr == itemPtr) {
if (textPtr->activeColor != NULL) {
color = textPtr->activeColor;
}
if (textPtr->activeStipple != None) {
stipple = textPtr->activeStipple;
}
} else if (state == TK_STATE_DISABLED) {
if (textPtr->disabledColor != NULL) {
color = textPtr->disabledColor;
}
if (textPtr->disabledStipple != None) {
stipple = textPtr->disabledStipple;
}
}
newGC = newSelGC = NULL;
if (textPtr->tkfont != NULL) {
gcValues.font = Tk_FontId(textPtr->tkfont);
mask = GCFont;
if (color != NULL) {
gcValues.foreground = color->pixel;
mask |= GCForeground;
if (stipple != None) {
gcValues.stipple = stipple;
gcValues.fill_style = FillStippled;
mask |= GCStipple|GCFillStyle;
}
newGC = Tk_GetGC(tkwin, mask, &gcValues);
}
mask &= ~(GCTile|GCFillStyle|GCStipple);
if (stipple != None) {
gcValues.stipple = stipple;
gcValues.fill_style = FillStippled;
mask |= GCStipple|GCFillStyle;
}
if (textInfoPtr->selFgColorPtr != NULL) {
gcValues.foreground = textInfoPtr->selFgColorPtr->pixel;
}
newSelGC = Tk_GetGC(tkwin, mask|GCForeground, &gcValues);
}
if (textPtr->gc != NULL) {
Tk_FreeGC(Tk_Display(tkwin), textPtr->gc);
}
textPtr->gc = newGC;
if (textPtr->selTextGC != NULL) {
Tk_FreeGC(Tk_Display(tkwin), textPtr->selTextGC);
}
textPtr->selTextGC = newSelGC;
selBgColorPtr = Tk_3DBorderColor(textInfoPtr->selBorder);
if (Tk_3DBorderColor(textInfoPtr->insertBorder)->pixel
== selBgColorPtr->pixel) {
if (selBgColorPtr->pixel == BlackPixelOfScreen(Tk_Screen(tkwin))) {
gcValues.foreground = WhitePixelOfScreen(Tk_Screen(tkwin));
} else {
gcValues.foreground = BlackPixelOfScreen(Tk_Screen(tkwin));
}
newGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
} else {
newGC = NULL;
}
if (textPtr->cursorOffGC != NULL) {
Tk_FreeGC(Tk_Display(tkwin), textPtr->cursorOffGC);
}
textPtr->cursorOffGC = newGC;
/*
* If the text was changed, move the selection and insertion indices to
* keep them inside the item.
*/
textPtr->numBytes = strlen(textPtr->text);
textPtr->numChars = Tcl_NumUtfChars(textPtr->text, textPtr->numBytes);
if (textInfoPtr->selItemPtr == itemPtr) {
if (textInfoPtr->selectFirst >= textPtr->numChars) {
textInfoPtr->selItemPtr = NULL;
} else {
if (textInfoPtr->selectLast >= textPtr->numChars) {
textInfoPtr->selectLast = textPtr->numChars - 1;
}
if ((textInfoPtr->anchorItemPtr == itemPtr)
&& (textInfoPtr->selectAnchor >= textPtr->numChars)) {
textInfoPtr->selectAnchor = textPtr->numChars - 1;
}
}
}
if (textPtr->insertPos >= textPtr->numChars) {
textPtr->insertPos = textPtr->numChars;
}
/*
* Restrict so that 0.0 <= angle < 360.0, and then recompute the cached
* sine and cosine of the angle. Note that fmod() can produce negative
* results, and we try to avoid negative zero as well.
*/
textPtr->angle = fmod(textPtr->angle, 360.0);
if (textPtr->angle < 0.0) {
textPtr->angle += 360.0;
}
if (textPtr->angle == 0.0) {
textPtr->angle = 0.0;
}
textPtr->sine = sin(textPtr->angle * PI/180.0);
textPtr->cosine = cos(textPtr->angle * PI/180.0);
ComputeTextBbox(canvas, textPtr);
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
TkpDrawCheckIndicator(
Tk_Window tkwin, /* handle for resource alloc */
Display *display,
Drawable d, /* what to draw on */
int x, int y, /* where to draw */
Tk_3DBorder bgBorder, /* colors of the border */
XColor *indicatorColor, /* color of the indicator */
XColor *selectColor, /* color when selected */
XColor *disableColor, /* color when disabled */
int on, /* are we on? */
int disabled, /* are we disabled? */
int mode) /* kind of indicator to draw */
{
int ix, iy;
int dim;
int imgsel, imgstart;
TkBorder *bg_brdr = (TkBorder*)bgBorder;
XGCValues gcValues;
GC copyGC;
unsigned long imgColors[8];
XImage *img;
Pixmap pixmap;
int depth;
/*
* Sanity check.
*/
if (tkwin == NULL || display == None || d == None || bgBorder == NULL
|| indicatorColor == NULL) {
return;
}
if (disableColor == NULL) {
disableColor = bg_brdr->bgColorPtr;
}
if (selectColor == NULL) {
selectColor = bg_brdr->bgColorPtr;
}
depth = Tk_Depth(tkwin);
/*
* Compute starting point and dimensions of image inside button_images to
* be used.
*/
switch (mode) {
default:
case CHECK_BUTTON:
imgsel = on == 2 ? CHECK_DISON_OFFSET :
on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
imgsel += disabled && on != 2 ? CHECK_DISOFF_OFFSET : 0;
imgstart = CHECK_START;
dim = CHECK_BUTTON_DIM;
break;
case CHECK_MENU:
imgsel = on == 2 ? CHECK_DISOFF_OFFSET :
on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
imgsel += disabled && on != 2 ? CHECK_DISOFF_OFFSET : 0;
imgstart = CHECK_START + 2;
imgsel += 2;
dim = CHECK_MENU_DIM;
break;
case RADIO_BUTTON:
imgsel = on == 2 ? RADIO_DISON_OFFSET :
on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
imgsel += disabled && on != 2 ? RADIO_DISOFF_OFFSET : 0;
imgstart = RADIO_START;
dim = RADIO_BUTTON_DIM;
break;
case RADIO_MENU:
imgsel = on == 2 ? RADIO_DISOFF_OFFSET :
on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
imgsel += disabled && on != 2 ? RADIO_DISOFF_OFFSET : 0;
imgstart = RADIO_START + 3;
imgsel += 3;
dim = RADIO_MENU_DIM;
break;
}
/*
* Allocate the drawing areas to use. Note that we use double-buffering
* here because not all code paths leading to this function do so.
*/
pixmap = Tk_GetPixmap(display, d, dim, dim, depth);
if (pixmap == None) {
return;
}
x -= dim/2;
y -= dim/2;
img = XGetImage(display, pixmap, 0, 0,
(unsigned int)dim, (unsigned int)dim, AllPlanes, ZPixmap);
if (img == NULL) {
return;
}
/*
* Set up the color mapping table.
*/
TkpGetShadows(bg_brdr, tkwin);
imgColors[0 /*A*/] =
Tk_GetColorByValue(tkwin, bg_brdr->bgColorPtr)->pixel;
imgColors[1 /*B*/] =
Tk_GetColorByValue(tkwin, bg_brdr->bgColorPtr)->pixel;
imgColors[2 /*C*/] = (bg_brdr->lightColorPtr != NULL) ?
Tk_GetColorByValue(tkwin, bg_brdr->lightColorPtr)->pixel :
WhitePixelOfScreen(bg_brdr->screen);
imgColors[3 /*D*/] =
Tk_GetColorByValue(tkwin, selectColor)->pixel;
imgColors[4 /*E*/] = (bg_brdr->darkColorPtr != NULL) ?
Tk_GetColorByValue(tkwin, bg_brdr->darkColorPtr)->pixel :
BlackPixelOfScreen(bg_brdr->screen);
imgColors[5 /*F*/] =
Tk_GetColorByValue(tkwin, bg_brdr->bgColorPtr)->pixel;
imgColors[6 /*G*/] =
Tk_GetColorByValue(tkwin, indicatorColor)->pixel;
imgColors[7 /*H*/] =
Tk_GetColorByValue(tkwin, disableColor)->pixel;
/*
* Create the image, painting it into an XImage one pixel at a time.
*/
for (iy=0 ; iy<dim ; iy++) {
for (ix=0 ; ix<dim ; ix++) {
XPutPixel(img, ix, iy,
imgColors[button_images[imgstart+iy][imgsel+ix] - 'A'] );
}
}
/*
* Copy onto our target drawable surface.
*/
memset(&gcValues, 0, sizeof(gcValues));
gcValues.background = bg_brdr->bgColorPtr->pixel;
gcValues.graphics_exposures = False;
copyGC = Tk_GetGC(tkwin, 0, &gcValues);
XPutImage(display, pixmap, copyGC, img, 0, 0, 0, 0,
(unsigned int)dim, (unsigned int)dim);
XCopyArea(display, pixmap, d, copyGC, 0, 0,
(unsigned int)dim, (unsigned int)dim, x, y);
/*
* Tidy up.
*/
Tk_FreeGC(display, copyGC);
XDestroyImage(img);
Tk_FreePixmap(display, pixmap);
}
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);
}
