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); }