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