static void
DeleteImage(
Tk_Canvas canvas, /* Info about overall canvas widget. */
Tk_Item *itemPtr, /* Item that is being deleted. */
Display *display) /* Display containing window for canvas. */
{
ImageItem *imgPtr = (ImageItem *) itemPtr;
if (imgPtr->imageString != NULL) {
ckfree(imgPtr->imageString);
}
if (imgPtr->activeImageString != NULL) {
ckfree(imgPtr->activeImageString);
}
if (imgPtr->disabledImageString != NULL) {
ckfree(imgPtr->disabledImageString);
}
if (imgPtr->image != NULL) {
Tk_FreeImage(imgPtr->image);
}
if (imgPtr->activeImage != NULL) {
Tk_FreeImage(imgPtr->activeImage);
}
if (imgPtr->disabledImage != NULL) {
Tk_FreeImage(imgPtr->disabledImage);
}
}
static void
DragImage_UpdateStylePixmap(
TreeDragImage dragImage) /* Drag image record. */
{
TreeCtrl *tree = dragImage->tree;
int w, h, state = 0;
XColor *colorPtr;
GC gc;
StyleDrawArgs drawArgs;
w = dragImage->styleW = TreeStyle_NeededWidth(tree, dragImage->instanceStyle, state);
h = dragImage->styleH = TreeStyle_NeededHeight(tree, dragImage->instanceStyle, state);
if (w > dragImage->pixmapW || h > dragImage->pixmapH)
{
if (dragImage->pixmap != None)
Tk_FreePixmap(tree->display, dragImage->pixmap);
dragImage->pixmap = Tk_GetPixmap(tree->display,
Tk_WindowId(tree->tkwin),
w, h, Tk_Depth(tree->tkwin));
dragImage->pixmapW = w;
dragImage->pixmapH = h;
}
colorPtr = Tk_GetColor(tree->interp, tree->tkwin, "pink");
gc = Tk_GCForColor(colorPtr, Tk_WindowId(tree->tkwin));
XFillRectangle(tree->display, dragImage->pixmap, gc,
0, 0, w, h);
drawArgs.tree = tree;
drawArgs.td.drawable = dragImage->pixmap;
drawArgs.td.width = w; drawArgs.td.height = h;
drawArgs.bounds[0] = drawArgs.bounds[1] = 0;
drawArgs.bounds[2] = w; drawArgs.bounds[3] = h;
drawArgs.state = state;
drawArgs.style = dragImage->instanceStyle;
drawArgs.indent = 0;
drawArgs.x = drawArgs.y = 0;
drawArgs.width = w; drawArgs.height = h;
drawArgs.justify = TK_JUSTIFY_LEFT;
TreeStyle_Draw(&drawArgs);
if (dragImage->tkimage != NULL) {
Tk_FreeImage(dragImage->tkimage);
dragImage->tkimage = NULL;
}
}
/* TtkFreeImageSpec --
* Dispose of an image specification.
*/
void TtkFreeImageSpec(Ttk_ImageSpec *imageSpec)
{
int i;
for (i=0; i < imageSpec->mapCount; ++i) {
Tk_FreeImage(imageSpec->images[i]);
}
if (imageSpec->baseImage) {
Tk_FreeImage(imageSpec->baseImage);
}
if (imageSpec->states) {
ckfree((ClientData)imageSpec->states);
}
if (imageSpec->images) {
ckfree((ClientData)imageSpec->images);
}
ckfree((ClientData)imageSpec);
}
static void
UpdatePixmap(
TreeDragImage dragImage /* Drag image record. */
)
{
TreeCtrl *tree = dragImage->tree;
int w, h;
XColor *colorPtr;
GC gc;
DragElem *elem;
unsigned long trans;
w = dragImage->bounds[2] - dragImage->bounds[0];
h = dragImage->bounds[3] - dragImage->bounds[1];
if (w > dragImage->pixmapW || h > dragImage->pixmapH)
{
if (dragImage->pixmap != None)
Tk_FreePixmap(tree->display, dragImage->pixmap);
dragImage->pixmap = Tk_GetPixmap(tree->display,
Tk_WindowId(tree->tkwin),
w, h, Tk_Depth(tree->tkwin));
dragImage->pixmapW = w;
dragImage->pixmapH = h;
}
colorPtr = Tk_GetColor(tree->interp, tree->tkwin, "pink");
gc = Tk_GCForColor(colorPtr, Tk_WindowId(tree->tkwin));
XFillRectangle(tree->display, dragImage->pixmap, gc,
0, 0, w, h);
trans = colorPtr->pixel;
colorPtr = Tk_GetColor(tree->interp, tree->tkwin, "gray50");
gc = Tk_GCForColor(colorPtr, Tk_WindowId(tree->tkwin));
for (elem = dragImage->elem; elem != NULL; elem = elem->next) {
XFillRectangle(tree->display, dragImage->pixmap, gc,
elem->x - dragImage->bounds[0],
elem->y - dragImage->bounds[1],
elem->width, elem->height);
}
if (dragImage->image != NULL) {
Tk_FreeImage(dragImage->image);
dragImage->image = NULL;
}
}
static void
DestroyMenuButton(
char *memPtr) /* Info about button widget. */
{
register TkMenuButton *mbPtr = (TkMenuButton *) memPtr;
TkpDestroyMenuButton(mbPtr);
if (mbPtr->flags & REDRAW_PENDING) {
Tcl_CancelIdleCall(TkpDisplayMenuButton, mbPtr);
}
/*
* Free up all the stuff that requires special handling, then let
* Tk_FreeOptions handle all the standard option-related stuff.
*/
Tcl_DeleteCommandFromToken(mbPtr->interp, mbPtr->widgetCmd);
if (mbPtr->textVarName != NULL) {
Tcl_UntraceVar(mbPtr->interp, mbPtr->textVarName,
TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
MenuButtonTextVarProc, mbPtr);
}
if (mbPtr->image != NULL) {
Tk_FreeImage(mbPtr->image);
}
if (mbPtr->normalTextGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->normalTextGC);
}
if (mbPtr->activeTextGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->activeTextGC);
}
if (mbPtr->disabledGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->disabledGC);
}
if (mbPtr->stippleGC != None) {
Tk_FreeGC(mbPtr->display, mbPtr->stippleGC);
}
if (mbPtr->gray != None) {
Tk_FreeBitmap(mbPtr->display, mbPtr->gray);
}
if (mbPtr->textLayout != NULL) {
Tk_FreeTextLayout(mbPtr->textLayout);
}
Tk_FreeConfigOptions((char *) mbPtr, mbPtr->optionTable, mbPtr->tkwin);
mbPtr->tkwin = NULL;
Tcl_EventuallyFree(mbPtr, TCL_DYNAMIC);
}
void
TreeDragImage_Free(
TreeDragImage dragImage /* Drag image token. */
)
{
DragElem *elem = dragImage->elem;
while (elem != NULL)
elem = DragElem_Free(dragImage, elem);
#ifdef DRAG_PIXMAP
if (dragImage->image != NULL)
Tk_FreeImage(dragImage->image);
if (dragImage->pixmap != None)
Tk_FreePixmap(dragImage->tree->display, dragImage->pixmap);
#endif /* DRAG_PIXMAP */
Tk_FreeConfigOptions((char *) dragImage, dragImage->optionTable,
dragImage->tree->tkwin);
WFREE(dragImage, TreeDragImage_);
}
static void
UpdateImage(
TreeDragImage dragImage /* Drag image record. */
)
{
TreeCtrl *tree = dragImage->tree;
Tk_PhotoHandle photoH;
XImage *ximage;
int width = dragImage->bounds[2] - dragImage->bounds[0];
int height = dragImage->bounds[3] - dragImage->bounds[1];
int alpha = 128;
XColor *colorPtr;
if (dragImage->image != NULL) {
Tk_FreeImage(dragImage->image);
dragImage->image = NULL;
}
photoH = Tk_FindPhoto(tree->interp, "::TreeCtrl::ImageDrag");
if (photoH == NULL) {
Tcl_GlobalEval(tree->interp, "image create photo ::TreeCtrl::ImageDrag");
photoH = Tk_FindPhoto(tree->interp, "::TreeCtrl::ImageDrag");
if (photoH == NULL)
return;
}
/* Pixmap -> XImage */
ximage = XGetImage(tree->display, dragImage->pixmap, 0, 0,
(unsigned int)width, (unsigned int)height, AllPlanes, ZPixmap);
if (ximage == NULL)
panic("tkTreeDrag.c:UpdateImage() ximage is NULL");
/* XImage -> Tk_Image */
colorPtr = Tk_GetColor(tree->interp, tree->tkwin, "pink");
Tree_XImage2Photo(tree->interp, photoH, ximage, colorPtr->pixel, alpha);
XDestroyImage(ximage);
dragImage->image = Tk_GetImage(tree->interp, tree->tkwin,
"::TreeCtrl::ImageDrag", NULL, (ClientData) NULL);
}
/*
* Ttk_ClearCache --
* Release references to all cached resources.
*/
static void Ttk_ClearCache(Ttk_ResourceCache cache)
{
Tcl_HashSearch search;
Tcl_HashEntry *entryPtr;
/*
* Free fonts:
*/
entryPtr = Tcl_FirstHashEntry(&cache->fontTable, &search);
while (entryPtr != NULL) {
Tcl_Obj *fontObj = Tcl_GetHashValue(entryPtr);
if (fontObj) {
Tk_FreeFontFromObj(cache->tkwin, fontObj);
Tcl_DecrRefCount(fontObj);
}
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&cache->fontTable);
Tcl_InitHashTable(&cache->fontTable, TCL_STRING_KEYS);
/*
* Free colors:
*/
entryPtr = Tcl_FirstHashEntry(&cache->colorTable, &search);
while (entryPtr != NULL) {
Tcl_Obj *colorObj = Tcl_GetHashValue(entryPtr);
if (colorObj) {
Tk_FreeColorFromObj(cache->tkwin, colorObj);
Tcl_DecrRefCount(colorObj);
}
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&cache->colorTable);
Tcl_InitHashTable(&cache->colorTable, TCL_STRING_KEYS);
/*
* Free borders:
*/
entryPtr = Tcl_FirstHashEntry(&cache->borderTable, &search);
while (entryPtr != NULL) {
Tcl_Obj *borderObj = Tcl_GetHashValue(entryPtr);
if (borderObj) {
Tk_Free3DBorderFromObj(cache->tkwin, borderObj);
Tcl_DecrRefCount(borderObj);
}
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&cache->borderTable);
Tcl_InitHashTable(&cache->borderTable, TCL_STRING_KEYS);
/*
* Free images:
*/
entryPtr = Tcl_FirstHashEntry(&cache->imageTable, &search);
while (entryPtr != NULL) {
Tk_Image image = Tcl_GetHashValue(entryPtr);
if (image) {
Tk_FreeImage(image);
}
entryPtr = Tcl_NextHashEntry(&search);
}
Tcl_DeleteHashTable(&cache->imageTable);
Tcl_InitHashTable(&cache->imageTable, TCL_STRING_KEYS);
return;
}
static int
ConfigureImage(
Tcl_Interp *interp, /* Used for error reporting. */
Tk_Canvas canvas, /* Canvas containing itemPtr. */
Tk_Item *itemPtr, /* Image 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. */
{
ImageItem *imgPtr = (ImageItem *) itemPtr;
Tk_Window tkwin;
Tk_Image image;
tkwin = Tk_CanvasTkwin(canvas);
if (TCL_OK != Tk_ConfigureWidget(interp, tkwin, configSpecs, objc,
(const char **) objv, (char *) imgPtr, flags|TK_CONFIG_OBJS)) {
return TCL_ERROR;
}
/*
* Create the image. Save the old image around and don't free it until
* after the new one is allocated. This keeps the reference count from
* going to zero so the image doesn't have to be recreated if it hasn't
* changed.
*/
if (imgPtr->activeImageString != NULL) {
itemPtr->redraw_flags |= TK_ITEM_STATE_DEPENDANT;
} else {
itemPtr->redraw_flags &= ~TK_ITEM_STATE_DEPENDANT;
}
if (imgPtr->imageString != NULL) {
image = Tk_GetImage(interp, tkwin, imgPtr->imageString,
ImageChangedProc, imgPtr);
if (image == NULL) {
return TCL_ERROR;
}
} else {
image = NULL;
}
if (imgPtr->image != NULL) {
Tk_FreeImage(imgPtr->image);
}
imgPtr->image = image;
if (imgPtr->activeImageString != NULL) {
image = Tk_GetImage(interp, tkwin, imgPtr->activeImageString,
ImageChangedProc, imgPtr);
if (image == NULL) {
return TCL_ERROR;
}
} else {
image = NULL;
}
if (imgPtr->activeImage != NULL) {
Tk_FreeImage(imgPtr->activeImage);
}
imgPtr->activeImage = image;
if (imgPtr->disabledImageString != NULL) {
image = Tk_GetImage(interp, tkwin, imgPtr->disabledImageString,
ImageChangedProc, imgPtr);
if (image == NULL) {
return TCL_ERROR;
}
} else {
image = NULL;
}
if (imgPtr->disabledImage != NULL) {
Tk_FreeImage(imgPtr->disabledImage);
}
imgPtr->disabledImage = image;
ComputeImageBbox(canvas, imgPtr);
return TCL_OK;
}
void
HtmlImageFree (HtmlImage2 *pImage)
{
if (!pImage) {
return;
}
assert(pImage->nRef > 0);
pImage->nRef--;
if (
pImage->nRef == 0 &&
(pImage->pUnscaled || !pImage->pImageServer->isSuspendGC)
) {
/* The reference count for this structure has reached zero.
* Really delete it. The assert() says that an original image
* cannot be deleted before all of it's scaled copies.
*/
assert(pImage->pUnscaled || 0 == pImage->pNext);
freeImageCompressed(pImage);
freeTile(pImage);
if (pImage->pixmap) {
HtmlTree *pTree = pImage->pImageServer->pTree;
Tk_FreePixmap(Tk_Display(pTree->tkwin), pImage->pixmap);
pImage->pixmap = 0;
}
if (pImage->image) {
Tk_FreeImage(pImage->image);
}
if (pImage->pImageName) {
Tcl_Interp *interp = pImage->pImageServer->pTree->interp;
Tcl_Obj *pEval;
if (!pImage->pDelete) {
pEval = Tcl_NewStringObj("image delete", -1);
Tcl_IncrRefCount(pEval);
} else {
pEval = pImage->pDelete;
}
Tcl_ListObjAppendElement(interp, pEval, pImage->pImageName);
Tcl_EvalObjEx(interp, pEval, TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);
Tcl_DecrRefCount(pEval);
Tcl_DecrRefCount(pImage->pImageName);
}
if (pImage->pUnscaled) {
HtmlImage2 *pIter;
for (
pIter = pImage->pUnscaled;
pIter->pNext != pImage;
pIter = pIter->pNext
) {
assert(pIter->pNext);
}
pIter->pNext = pIter->pNext->pNext;
HtmlImageFree(pImage->pUnscaled);
} else {
const char *zKey = pImage->zUrl;
Tcl_HashTable *paImage = &pImage->pImageServer->aImage;
Tcl_HashEntry *pEntry = Tcl_FindHashEntry(paImage, zKey);
assert(pEntry);
Tcl_DeleteHashEntry(pEntry);
}
HtmlFree(pImage);
Tcl_CancelIdleCall(asyncPixmapify, (ClientData)pImage);
}
}
static int
ConfigureMenuButton(
Tcl_Interp *interp, /* Used for error reporting. */
register TkMenuButton *mbPtr,
/* Information about widget; may or may not
* already have values for some fields. */
int objc, /* Number of valid entries in objv. */
Tcl_Obj *const objv[]) /* Arguments. */
{
Tk_SavedOptions savedOptions;
Tcl_Obj *errorResult = NULL;
int error;
Tk_Image image;
/*
* Eliminate any existing trace on variables monitored by the menubutton.
*/
if (mbPtr->textVarName != NULL) {
Tcl_UntraceVar(interp, mbPtr->textVarName,
TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
MenuButtonTextVarProc, mbPtr);
}
/*
* The following loop is potentially executed twice. During the first pass
* configuration options get set to their new values. If there is an error
* in this pass, we execute a second pass to restore all the options to
* their previous values.
*/
for (error = 0; error <= 1; error++) {
if (!error) {
/*
* First pass: set options to new values.
*/
if (Tk_SetOptions(interp, (char *) mbPtr,
mbPtr->optionTable, objc, objv,
mbPtr->tkwin, &savedOptions, NULL) != TCL_OK) {
continue;
}
} else {
/*
* Second pass: restore options to old values.
*/
errorResult = Tcl_GetObjResult(interp);
Tcl_IncrRefCount(errorResult);
Tk_RestoreSavedOptions(&savedOptions);
}
/*
* A few options need special processing, such as setting the
* background from a 3-D border, or filling in complicated defaults
* that couldn't be specified to Tk_SetOptions.
*/
if ((mbPtr->state == STATE_ACTIVE)
&& !Tk_StrictMotif(mbPtr->tkwin)) {
Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->activeBorder);
} else {
Tk_SetBackgroundFromBorder(mbPtr->tkwin, mbPtr->normalBorder);
}
if (mbPtr->highlightWidth < 0) {
mbPtr->highlightWidth = 0;
}
if (mbPtr->padX < 0) {
mbPtr->padX = 0;
}
if (mbPtr->padY < 0) {
mbPtr->padY = 0;
}
/*
* Get the image for the widget, if there is one. Allocate the new
* image before freeing the old one, so that the reference count
* doesn't go to zero and cause image data to be discarded.
*/
if (mbPtr->imageString != NULL) {
image = Tk_GetImage(mbPtr->interp, mbPtr->tkwin,
mbPtr->imageString, MenuButtonImageProc, mbPtr);
if (image == NULL) {
return TCL_ERROR;
}
} else {
image = NULL;
}
if (mbPtr->image != NULL) {
Tk_FreeImage(mbPtr->image);
}
mbPtr->image = image;
/*
* Recompute the geometry for the button.
*/
if ((mbPtr->bitmap != None) || (mbPtr->image != NULL)) {
if (Tk_GetPixels(interp, mbPtr->tkwin, mbPtr->widthString,
&mbPtr->width) != TCL_OK) {
widthError:
Tcl_AddErrorInfo(interp, "\n (processing -width option)");
continue;
}
if (Tk_GetPixels(interp, mbPtr->tkwin, mbPtr->heightString,
&mbPtr->height) != TCL_OK) {
heightError:
Tcl_AddErrorInfo(interp, "\n (processing -height option)");
continue;
}
} else {
if (Tcl_GetInt(interp, mbPtr->widthString, &mbPtr->width)
!= TCL_OK) {
goto widthError;
}
if (Tcl_GetInt(interp, mbPtr->heightString, &mbPtr->height)
!= TCL_OK) {
goto heightError;
}
}
break;
}
if (!error) {
Tk_FreeSavedOptions(&savedOptions);
}
if (mbPtr->textVarName != NULL) {
/*
* If no image or -compound is used, display the value of a variable.
* Set up a trace to watch for any changes in it, create the variable
* if it doesn't exist, and fetch its current value.
*/
const char *value;
value = Tcl_GetVar(interp, mbPtr->textVarName, TCL_GLOBAL_ONLY);
if (value == NULL) {
Tcl_SetVar(interp, mbPtr->textVarName, mbPtr->text,
TCL_GLOBAL_ONLY);
} else {
if (mbPtr->text != NULL) {
ckfree(mbPtr->text);
}
mbPtr->text = (char *) ckalloc((unsigned) (strlen(value) + 1));
strcpy(mbPtr->text, value);
}
Tcl_TraceVar(interp, mbPtr->textVarName,
TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
MenuButtonTextVarProc, mbPtr);
}
TkMenuButtonWorldChanged(mbPtr);
if (error) {
Tcl_SetObjResult(interp, errorResult);
Tcl_DecrRefCount(errorResult);
return TCL_ERROR;
}
return TCL_OK;
}
