int ColorModel::command(int argc, const char*const* argv) { Tcl& tcl = Tcl::instance(); if (argc == 2) { if (strcmp(argv[1], "alloc-colors") == 0) { tcl.result(allocate() < 0 ? "0" : "1"); return (TCL_OK); } if (strcmp(argv[1], "free-colors") == 0) { free_colors(); return (TCL_OK); } } else if (argc == 3) { if (strcmp(argv[1], "visual") == 0) { Tk_Window tk = Tk_NameToWindow(tcl.interp(), (char*)argv[2], tcl.tkmain()); setvisual(Tk_Visual(tk), Tk_Colormap(tk), Tk_Depth(tk)); return (TCL_OK); } if (strcmp(argv[1], "gamma") == 0) { double v = atof(argv[2]); if (v < 0) tcl.result("0"); gamma_ = v; tcl.result("1"); return (TCL_OK); } } return (TclObject::command(argc, argv)); }
XColor * Tk_GetColorByValue( Tk_Window tkwin, /* Window where color will be used. */ XColor *colorPtr) /* Red, green, and blue fields indicate * desired color. */ { ValueKey valueKey; Tcl_HashEntry *valueHashPtr; int isNew; TkColor *tkColPtr; Display *display = Tk_Display(tkwin); TkDisplay *dispPtr = TkGetDisplay(display); if (!dispPtr->colorInit) { ColorInit(dispPtr); } /* * First, check to see if there's already a mapping for this color name. * Must clear the structure first; it's not tightly packed on 64-bit * systems. [Bug 2911570] */ memset(&valueKey, 0, sizeof(ValueKey)); valueKey.red = colorPtr->red; valueKey.green = colorPtr->green; valueKey.blue = colorPtr->blue; valueKey.colormap = Tk_Colormap(tkwin); valueKey.display = display; valueHashPtr = Tcl_CreateHashEntry(&dispPtr->colorValueTable, (char *) &valueKey, &isNew); if (!isNew) { tkColPtr = Tcl_GetHashValue(valueHashPtr); tkColPtr->resourceRefCount++; return &tkColPtr->color; } /* * The name isn't currently known. Find a pixel value for this color and * add a new structure to colorValueTable (in TkDisplay). */ tkColPtr = TkpGetColorByValue(tkwin, colorPtr); tkColPtr->magic = COLOR_MAGIC; tkColPtr->gc = None; tkColPtr->screen = Tk_Screen(tkwin); tkColPtr->colormap = valueKey.colormap; tkColPtr->visual = Tk_Visual(tkwin); tkColPtr->resourceRefCount = 1; tkColPtr->objRefCount = 0; tkColPtr->type = TK_COLOR_BY_VALUE; tkColPtr->hashPtr = valueHashPtr; tkColPtr->nextPtr = NULL; Tcl_SetHashValue(valueHashPtr, tkColPtr); return &tkColPtr->color; }
/* * constructor: create the zoom GC and XImage. * * Args: * * tkwin - the Tk window for displaying the zoomed image * * copyGC - X GC used to copy image to zoom window * * width, height - dimensions of tkwin (should be square and a multiple * of the zoom factor) * * zoomFactor - the zoom magnification factor * * usingXShm - flag: true if using X shared memory * * verbose - flag: if true, print diagnostic messages * */ ImageZoom::ImageZoom(Tk_Window tkwin, GC gc, int width, int height, int zoomFactor, int usingXShm, int verbose) : tkwin_(tkwin), gc_(gc), width_(width), height_(height), zoomFactor_(zoomFactor), zoomStep_(width/zoomFactor), status_(TCL_OK) { // make a graphics context using XOR to draw a box marking the pointer hotspot XGCValues gcValues; gcValues.function = GXcopy; gcValues.graphics_exposures = False; Tk_MakeWindowExist(tkwin_); rect_gc_ = XCreateGC(Tk_Display(tkwin_), Tk_WindowId(tkwin_), GCFunction|GCGraphicsExposures, &gcValues); // create a class object to manage the XImage xImage_ = new ImageDisplay(Tk_Display(tkwin_), Tk_Visual(tkwin_), gc, Tk_Depth(tkwin_), usingXShm, verbose); status_ = xImage_->update(width, height); }
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 (); } }
XColor * Tk_GetColor( Tcl_Interp *interp, /* Place to leave error message if color can't * be found. */ Tk_Window tkwin, /* Window in which color will be used. */ Tk_Uid name) /* Name of color to be allocated (in form * suitable for passing to XParseColor). */ { Tcl_HashEntry *nameHashPtr; int isNew; TkColor *tkColPtr; TkColor *existingColPtr; TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr; if (!dispPtr->colorInit) { ColorInit(dispPtr); } /* * First, check to see if there's already a mapping for this color name. */ nameHashPtr = Tcl_CreateHashEntry(&dispPtr->colorNameTable, name, &isNew); if (!isNew) { existingColPtr = Tcl_GetHashValue(nameHashPtr); for (tkColPtr = existingColPtr; tkColPtr != NULL; tkColPtr = tkColPtr->nextPtr) { if ((tkColPtr->screen == Tk_Screen(tkwin)) && (Tk_Colormap(tkwin) == tkColPtr->colormap)) { tkColPtr->resourceRefCount++; return &tkColPtr->color; } } } else { existingColPtr = NULL; } /* * The name isn't currently known. Map from the name to a pixel value. */ tkColPtr = TkpGetColor(tkwin, name); if (tkColPtr == NULL) { if (interp != NULL) { if (*name == '#') { Tcl_AppendResult(interp, "invalid color name \"", name, "\"", NULL); } else { Tcl_AppendResult(interp, "unknown color name \"", name, "\"", NULL); } } if (isNew) { Tcl_DeleteHashEntry(nameHashPtr); } return NULL; } /* * Now create a new TkColor structure and add it to colorNameTable (in * TkDisplay). */ tkColPtr->magic = COLOR_MAGIC; tkColPtr->gc = None; tkColPtr->screen = Tk_Screen(tkwin); tkColPtr->colormap = Tk_Colormap(tkwin); tkColPtr->visual = Tk_Visual(tkwin); tkColPtr->resourceRefCount = 1; tkColPtr->objRefCount = 0; tkColPtr->type = TK_COLOR_BY_NAME; tkColPtr->hashPtr = nameHashPtr; tkColPtr->nextPtr = existingColPtr; Tcl_SetHashValue(nameHashPtr, tkColPtr); return &tkColPtr->color; }
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; }
Tcl_Obj *HtmlXImageToImage( HtmlTree *pTree, XImage *pXImage, int w, int h ) { Tcl_Interp *interp = pTree->interp; Tcl_Obj *pImage; Tk_PhotoHandle photo; Tk_PhotoImageBlock block; int x; int y; unsigned long redmask, redshift; unsigned long greenmask, greenshift; unsigned long bluemask, blueshift; Visual *pVisual; Tcl_Eval(interp, "image create photo"); pImage = Tcl_GetObjResult(interp); Tcl_IncrRefCount(pImage); block.pixelPtr = (unsigned char *)HtmlAlloc("temp", w * h * 4); block.width = w; block.height = h; block.pitch = w*4; block.pixelSize = 4; block.offset[0] = 0; block.offset[1] = 1; block.offset[2] = 2; block.offset[3] = 3; pVisual = Tk_Visual(pTree->tkwin); redmask = pVisual->red_mask; bluemask = pVisual->blue_mask; greenmask = pVisual->green_mask; for (redshift=0; !((redmask>>redshift)&0x000000001); redshift++); for (greenshift=0; !((greenmask>>greenshift)&0x00000001); greenshift++); for (blueshift=0; !((bluemask>>blueshift)&0x00000001); blueshift++); for (x=0; x<w; x++) { for (y=0; y<h; y++) { unsigned char *pOut; unsigned long pixel = XGetPixel(pXImage, x, y); pOut = &block.pixelPtr[x*block.pixelSize + y*block.pitch]; pOut[0] = (pixel&redmask)>>redshift; pOut[1] = (pixel&greenmask)>>greenshift; pOut[2] = (pixel&bluemask)>>blueshift; pOut[3] = 0xFF; } } photo = Tk_FindPhoto(interp, Tcl_GetString(pImage)); photoputblock(interp, photo, &block, 0, 0, w, h, 0); HtmlFree(block.pixelPtr); return pImage; }
void *jl_tkwin_visual(Tk_Window tkwin) { return Tk_Visual(tkwin); }