diff options
Diffstat (limited to 'generic/tkCursor.c')
| -rw-r--r-- | generic/tkCursor.c | 495 |
1 files changed, 247 insertions, 248 deletions
diff --git a/generic/tkCursor.c b/generic/tkCursor.c index f599083..410aea9 100644 --- a/generic/tkCursor.c +++ b/generic/tkCursor.c @@ -1,52 +1,50 @@ -/* +/* * tkCursor.c -- * * This file maintains a database of read-only cursors for the Tk - * toolkit. This allows cursors to be shared between widgets and - * also avoids round-trips to the X server. + * toolkit. This allows cursors to be shared between widgets and also + * avoids round-trips to the X server. * * Copyright (c) 1990-1994 The Regents of the University of California. * Copyright (c) 1994-1997 Sun Microsystems, Inc. * - * See the file "license.terms" for information on usage and redistribution - * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * See the file "license.terms" for information on usage and redistribution of + * this file, and for a DISCLAIMER OF ALL WARRANTIES. */ -#include "tkPort.h" #include "tkInt.h" /* - * A TkCursor structure exists for each cursor that is currently - * active. Each structure is indexed with two hash tables defined - * below. One of the tables is cursorIdTable, and the other is either - * cursorNameTable or cursorDataTable, each of which are stored in the - * TkDisplay structure for the current thread. + * A TkCursor structure exists for each cursor that is currently active. Each + * structure is indexed with two hash tables defined below. One of the tables + * is cursorIdTable, and the other is either cursorNameTable or + * cursorDataTable, each of which are stored in the TkDisplay structure for + * the current thread. */ typedef struct { CONST char *source; /* Cursor bits. */ CONST char *mask; /* Mask bits. */ - int width, height; /* Dimensions of cursor (and data - * and mask). */ + int width, height; /* Dimensions of cursor (and data and + * mask). */ int xHot, yHot; /* Location of cursor hot-spot. */ Tk_Uid fg, bg; /* Colors for cursor. */ Display *display; /* Display on which cursor will be used. */ } DataKey; /* - * Forward declarations for procedures defined in this file: + * Forward declarations for functions defined in this file: */ -static void CursorInit _ANSI_ARGS_((TkDisplay *dispPtr)); -static void DupCursorObjProc _ANSI_ARGS_((Tcl_Obj *srcObjPtr, - Tcl_Obj *dupObjPtr)); -static void FreeCursor _ANSI_ARGS_((TkCursor *cursorPtr)); -static void FreeCursorObjProc _ANSI_ARGS_((Tcl_Obj *objPtr)); -static TkCursor * TkcGetCursor _ANSI_ARGS_((Tcl_Interp *interp, - Tk_Window tkwin, CONST char *name)); -static TkCursor * GetCursorFromObj _ANSI_ARGS_((Tk_Window tkwin, - Tcl_Obj *objPtr)); -static void InitCursorObj _ANSI_ARGS_((Tcl_Obj *objPtr)); +static void CursorInit(TkDisplay *dispPtr); +static void DupCursorObjProc(Tcl_Obj *srcObjPtr, + Tcl_Obj *dupObjPtr); +static void FreeCursor(TkCursor *cursorPtr); +static void FreeCursorObjProc(Tcl_Obj *objPtr); +static TkCursor * TkcGetCursor(Tcl_Interp *interp, + Tk_Window tkwin, CONST char *name); +static TkCursor * GetCursorFromObj(Tk_Window tkwin, Tcl_Obj *objPtr); +static void InitCursorObj(Tcl_Obj *objPtr); /* * The following structure defines the implementation of the "cursor" Tcl @@ -69,33 +67,32 @@ Tcl_ObjType tkCursorObjType = { * * Tk_AllocCursorFromObj -- * - * Given a Tcl_Obj *, map the value to a corresponding - * Tk_Cursor structure based on the tkwin given. + * Given a Tcl_Obj *, map the value to a corresponding Tk_Cursor + * structure based on the tkwin given. * * Results: - * The return value is the X identifer for the desired cursor, - * unless objPtr couldn't be parsed correctly. In this case, - * None is returned and an error message is left in the interp's result. - * The caller should never modify the cursor that is returned, and - * should eventually call Tk_FreeCursorFromObj when the cursor is no - * longer needed. + * The return value is the X identifer for the desired cursor, unless + * objPtr couldn't be parsed correctly. In this case, None is returned + * and an error message is left in the interp's result. The caller should + * never modify the cursor that is returned, and should eventually call + * Tk_FreeCursorFromObj when the cursor is no longer needed. * * Side effects: * The cursor is added to an internal database with a reference count. - * For each call to this procedure, there should eventually be a call - * to Tk_FreeCursorFromObj, so that the database can be cleaned up - * when cursors aren't needed anymore. + * For each call to this function, there should eventually be a call to + * Tk_FreeCursorFromObj, so that the database can be cleaned up when + * cursors aren't needed anymore. * *---------------------------------------------------------------------- */ Tk_Cursor -Tk_AllocCursorFromObj(interp, tkwin, objPtr) - Tcl_Interp *interp; /* Interp for error results. */ - Tk_Window tkwin; /* Window in which the cursor will be used.*/ - Tcl_Obj *objPtr; /* Object describing cursor; see manual - * entry for description of legal - * syntax of this obj's string rep. */ +Tk_AllocCursorFromObj( + Tcl_Interp *interp, /* Interp for error results. */ + Tk_Window tkwin, /* Window in which the cursor will be used.*/ + Tcl_Obj *objPtr) /* Object describing cursor; see manual entry + * for description of legal syntax of this + * obj's string rep. */ { TkCursor *cursorPtr; @@ -105,16 +102,17 @@ Tk_AllocCursorFromObj(interp, tkwin, objPtr) cursorPtr = (TkCursor *) objPtr->internalRep.twoPtrValue.ptr1; /* - * If the object currently points to a TkCursor, see if it's the - * one we want. If so, increment its reference count and return. + * If the object currently points to a TkCursor, see if it's the one we + * want. If so, increment its reference count and return. */ if (cursorPtr != NULL) { if (cursorPtr->resourceRefCount == 0) { /* - * This is a stale reference: it refers to a TkCursor that's - * no longer in use. Clear the reference. + * This is a stale reference: it refers to a TkCursor that's no + * longer in use. Clear the reference. */ + FreeCursorObjProc(objPtr); cursorPtr = NULL; } else if (Tk_Display(tkwin) == cursorPtr->display) { @@ -124,38 +122,37 @@ Tk_AllocCursorFromObj(interp, tkwin, objPtr) } /* - * The object didn't point to the TkCursor that we wanted. Search - * the list of TkCursors with the same name to see if one of the - * other TkCursors is the right one. + * The object didn't point to the TkCursor that we wanted. Search the list + * of TkCursors with the same name to see if one of the other TkCursors is + * the right one. */ if (cursorPtr != NULL) { - TkCursor *firstCursorPtr = - (TkCursor *) Tcl_GetHashValue(cursorPtr->hashPtr); + TkCursor *firstCursorPtr = (TkCursor *) + Tcl_GetHashValue(cursorPtr->hashPtr); FreeCursorObjProc(objPtr); for (cursorPtr = firstCursorPtr; cursorPtr != NULL; cursorPtr = cursorPtr->nextPtr) { if (Tk_Display(tkwin) == cursorPtr->display) { cursorPtr->resourceRefCount++; cursorPtr->objRefCount++; - objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr; + objPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr; return cursorPtr->cursor; } } } /* - * Still no luck. Call TkcGetCursor to allocate a new TkCursor object. + * Still no luck. Call TkcGetCursor to allocate a new TkCursor object. */ cursorPtr = TkcGetCursor(interp, tkwin, Tcl_GetString(objPtr)); - objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr; + objPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr; if (cursorPtr == NULL) { return None; - } else { - cursorPtr->objRefCount++; - return cursorPtr->cursor; } + cursorPtr->objRefCount++; + return cursorPtr->cursor; } /* @@ -163,32 +160,31 @@ Tk_AllocCursorFromObj(interp, tkwin, objPtr) * * Tk_GetCursor -- * - * Given a string describing a cursor, locate (or create if necessary) - * a cursor that fits the description. + * Given a string describing a cursor, locate (or create if necessary) a + * cursor that fits the description. * * Results: - * The return value is the X identifer for the desired cursor, - * unless string couldn't be parsed correctly. In this case, - * None is returned and an error message is left in the interp's result. - * The caller should never modify the cursor that is returned, and - * should eventually call Tk_FreeCursor when the cursor is no longer - * needed. + * The return value is the X identifer for the desired cursor, unless + * string couldn't be parsed correctly. In this case, None is returned + * and an error message is left in the interp's result. The caller should + * never modify the cursor that is returned, and should eventually call + * Tk_FreeCursor when the cursor is no longer needed. * * Side effects: * The cursor is added to an internal database with a reference count. - * For each call to this procedure, there should eventually be a call - * to Tk_FreeCursor, so that the database can be cleaned up when cursors + * For each call to this function, there should eventually be a call to + * Tk_FreeCursor, so that the database can be cleaned up when cursors * aren't needed anymore. * *---------------------------------------------------------------------- */ Tk_Cursor -Tk_GetCursor(interp, tkwin, string) - Tcl_Interp *interp; /* Interpreter to use for error reporting. */ - Tk_Window tkwin; /* Window in which cursor will be used. */ - Tk_Uid string; /* Description of cursor. See manual entry - * for details on legal syntax. */ +Tk_GetCursor( + Tcl_Interp *interp, /* Interpreter to use for error reporting. */ + Tk_Window tkwin, /* Window in which cursor will be used. */ + Tk_Uid string) /* Description of cursor. See manual entry for + * details on legal syntax. */ { TkCursor *cursorPtr = TkcGetCursor(interp, tkwin, string); if (cursorPtr == NULL) { @@ -202,48 +198,47 @@ Tk_GetCursor(interp, tkwin, string) * * TkcGetCursor -- * - * Given a string describing a cursor, locate (or create if necessary) - * a cursor that fits the description. This routine returns the - * internal data structure for the cursor, which avoids extra - * hash table lookups in Tk_AllocCursorFromObj. + * Given a string describing a cursor, locate (or create if necessary) a + * cursor that fits the description. This routine returns the internal + * data structure for the cursor, which avoids extra hash table lookups + * in Tk_AllocCursorFromObj. * * Results: - * The return value is a pointer to the TkCursor for the desired - * cursor, unless string couldn't be parsed correctly. In this - * case, NULL is returned and an error message is left in the - * interp's result. The caller should never modify the cursor that - * is returned, and should eventually call Tk_FreeCursor when the - * cursor is no longer needed. + * The return value is a pointer to the TkCursor for the desired cursor, + * unless string couldn't be parsed correctly. In this case, NULL is + * returned and an error message is left in the interp's result. The + * caller should never modify the cursor that is returned, and should + * eventually call Tk_FreeCursor when the cursor is no longer needed. * * Side effects: * The cursor is added to an internal database with a reference count. - * For each call to this procedure, there should eventually be a call - * to Tk_FreeCursor, so that the database can be cleaned up when cursors + * For each call to this function, there should eventually be a call to + * Tk_FreeCursor, so that the database can be cleaned up when cursors * aren't needed anymore. * *---------------------------------------------------------------------- */ static TkCursor * -TkcGetCursor(interp, tkwin, string) - Tcl_Interp *interp; /* Interpreter to use for error reporting. */ - Tk_Window tkwin; /* Window in which cursor will be used. */ - CONST char *string; /* Description of cursor. See manual entry - * for details on legal syntax. */ +TkcGetCursor( + Tcl_Interp *interp, /* Interpreter to use for error reporting. */ + Tk_Window tkwin, /* Window in which cursor will be used. */ + CONST char *string) /* Description of cursor. See manual entry for + * details on legal syntax. */ { Tcl_HashEntry *nameHashPtr; register TkCursor *cursorPtr; TkCursor *existingCursorPtr = NULL; - int new; + int isNew; TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr; if (!dispPtr->cursorInit) { CursorInit(dispPtr); } - nameHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorNameTable, - string, &new); - if (!new) { + nameHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorNameTable, + string, &isNew); + if (!isNew) { existingCursorPtr = (TkCursor *) Tcl_GetHashValue(nameHashPtr); for (cursorPtr = existingCursorPtr; cursorPtr != NULL; cursorPtr = cursorPtr->nextPtr) { @@ -259,7 +254,7 @@ TkcGetCursor(interp, tkwin, string) cursorPtr = TkGetCursorByName(interp, tkwin, string); if (cursorPtr == NULL) { - if (new) { + if (isNew) { Tcl_DeleteHashEntry(nameHashPtr); } return NULL; @@ -275,10 +270,10 @@ TkcGetCursor(interp, tkwin, string) cursorPtr->otherTable = &dispPtr->cursorNameTable; cursorPtr->hashPtr = nameHashPtr; cursorPtr->nextPtr = existingCursorPtr; - cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable, - (char *) cursorPtr->cursor, &new); - if (!new) { - panic("cursor already registered in Tk_GetCursor"); + cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable, + (char *) cursorPtr->cursor, &isNew); + if (!isNew) { + Tcl_Panic("cursor already registered in Tk_GetCursor"); } Tcl_SetHashValue(nameHashPtr, cursorPtr); Tcl_SetHashValue(cursorPtr->idHashPtr, cursorPtr); @@ -291,46 +286,43 @@ TkcGetCursor(interp, tkwin, string) * * Tk_GetCursorFromData -- * - * Given a description of the bits and colors for a cursor, - * make a cursor that has the given properties. + * Given a description of the bits and colors for a cursor, make a cursor + * that has the given properties. * * Results: - * The return value is the X identifer for the desired cursor, - * unless it couldn't be created properly. In this case, None is - * returned and an error message is left in the interp's result. The - * caller should never modify the cursor that is returned, and - * should eventually call Tk_FreeCursor when the cursor is no - * longer needed. + * The return value is the X identifer for the desired cursor, unless it + * couldn't be created properly. In this case, None is returned and an + * error message is left in the interp's result. The caller should never + * modify the cursor that is returned, and should eventually call + * Tk_FreeCursor when the cursor is no longer needed. * * Side effects: * The cursor is added to an internal database with a reference count. - * For each call to this procedure, there should eventually be a call - * to Tk_FreeCursor, so that the database can be cleaned up when cursors + * For each call to this function, there should eventually be a call to + * Tk_FreeCursor, so that the database can be cleaned up when cursors * aren't needed anymore. * *---------------------------------------------------------------------- */ Tk_Cursor -Tk_GetCursorFromData(interp, tkwin, source, mask, width, height, - xHot, yHot, fg, bg) - Tcl_Interp *interp; /* Interpreter to use for error reporting. */ - Tk_Window tkwin; /* Window in which cursor will be used. */ - CONST char *source; /* Bitmap data for cursor shape. */ - CONST char *mask; /* Bitmap data for cursor mask. */ - int width, height; /* Dimensions of cursor. */ - int xHot, yHot; /* Location of hot-spot in cursor. */ - Tk_Uid fg; /* Foreground color for cursor. */ - Tk_Uid bg; /* Background color for cursor. */ +Tk_GetCursorFromData( + Tcl_Interp *interp, /* Interpreter to use for error reporting. */ + Tk_Window tkwin, /* Window in which cursor will be used. */ + CONST char *source, /* Bitmap data for cursor shape. */ + CONST char *mask, /* Bitmap data for cursor mask. */ + int width, int height, /* Dimensions of cursor. */ + int xHot, int yHot, /* Location of hot-spot in cursor. */ + Tk_Uid fg, /* Foreground color for cursor. */ + Tk_Uid bg) /* Background color for cursor. */ { DataKey dataKey; Tcl_HashEntry *dataHashPtr; register TkCursor *cursorPtr; - int new; + int isNew; XColor fgColor, bgColor; TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr; - if (!dispPtr->cursorInit) { CursorInit(dispPtr); } @@ -344,27 +336,25 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height, dataKey.fg = fg; dataKey.bg = bg; dataKey.display = Tk_Display(tkwin); - dataHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorDataTable, - (char *) &dataKey, &new); - if (!new) { + dataHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorDataTable, + (char *) &dataKey, &isNew); + if (!isNew) { cursorPtr = (TkCursor *) Tcl_GetHashValue(dataHashPtr); cursorPtr->resourceRefCount++; return cursorPtr->cursor; } /* - * No suitable cursor exists yet. Make one using the data - * available and add it to the database. + * No suitable cursor exists yet. Make one using the data available and + * add it to the database. */ if (TkParseColor(dataKey.display, Tk_Colormap(tkwin), fg, &fgColor) == 0) { - Tcl_AppendResult(interp, "invalid color name \"", fg, "\"", - (char *) NULL); + Tcl_AppendResult(interp, "invalid color name \"", fg, "\"", NULL); goto error; } if (TkParseColor(dataKey.display, Tk_Colormap(tkwin), bg, &bgColor) == 0) { - Tcl_AppendResult(interp, "invalid color name \"", bg, "\"", - (char *) NULL); + Tcl_AppendResult(interp, "invalid color name \"", bg, "\"", NULL); goto error; } @@ -379,18 +369,18 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height, cursorPtr->otherTable = &dispPtr->cursorDataTable; cursorPtr->hashPtr = dataHashPtr; cursorPtr->objRefCount = 0; - cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable, - (char *) cursorPtr->cursor, &new); + cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable, + (char *) cursorPtr->cursor, &isNew); cursorPtr->nextPtr = NULL; - if (!new) { - panic("cursor already registered in Tk_GetCursorFromData"); + if (!isNew) { + Tcl_Panic("cursor already registered in Tk_GetCursorFromData"); } Tcl_SetHashValue(dataHashPtr, cursorPtr); Tcl_SetHashValue(cursorPtr->idHashPtr, cursorPtr); return cursorPtr->cursor; - error: + error: Tcl_DeleteHashEntry(dataHashPtr); return None; } @@ -403,12 +393,11 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height, * Given a cursor, return a textual string identifying it. * * Results: - * If cursor was created by Tk_GetCursor, then the return - * value is the "string" that was used to create it. - * Otherwise the return value is a string giving the X - * identifier for the cursor. The storage for the returned - * string is only guaranteed to persist up until the next - * call to this procedure. + * If cursor was created by Tk_GetCursor, then the return value is the + * "string" that was used to create it. Otherwise the return value is a + * string giving the X identifier for the cursor. The storage for the + * returned string is only guaranteed to persist up until the next call + * to this function. * * Side effects: * None. @@ -417,9 +406,9 @@ Tk_GetCursorFromData(interp, tkwin, source, mask, width, height, */ CONST char * -Tk_NameOfCursor(display, cursor) - Display *display; /* Display for which cursor was allocated. */ - Tk_Cursor cursor; /* Identifier for cursor whose name is +Tk_NameOfCursor( + Display *display, /* Display for which cursor was allocated. */ + Tk_Cursor cursor) /* Identifier for cursor whose name is * wanted. */ { Tcl_HashEntry *idHashPtr; @@ -429,9 +418,8 @@ Tk_NameOfCursor(display, cursor) dispPtr = TkGetDisplay(display); if (!dispPtr->cursorInit) { - printid: - sprintf(dispPtr->cursorString, "cursor id 0x%x", - (unsigned int) cursor); + printid: + sprintf(dispPtr->cursorString, "cursor id %p", cursor); return dispPtr->cursorString; } idHashPtr = Tcl_FindHashEntry(&dispPtr->cursorIdTable, (char *) cursor); @@ -450,23 +438,22 @@ Tk_NameOfCursor(display, cursor) * * FreeCursor -- * - * This procedure is invoked by both Tk_FreeCursor and - * Tk_FreeCursorFromObj; it does all the real work of deallocating - * a cursor. + * This function is invoked by both Tk_FreeCursorFromObj and + * Tk_FreeCursor; it does all the real work of deallocating a cursor. * * Results: * None. * * Side effects: - * The reference count associated with cursor is decremented, and - * it is officially deallocated if no-one is using it anymore. + * The reference count associated with cursor is decremented, and it is + * officially deallocated if no-one is using it anymore. * *---------------------------------------------------------------------- */ static void -FreeCursor(cursorPtr) - TkCursor *cursorPtr; /* Cursor to be released. */ +FreeCursor( + TkCursor *cursorPtr) /* Cursor to be released. */ { TkCursor *prevPtr; @@ -500,34 +487,34 @@ FreeCursor(cursorPtr) * * Tk_FreeCursor -- * - * This procedure is called to release a cursor allocated by - * Tk_GetCursor or TkGetCursorFromData. + * This function is called to release a cursor allocated by Tk_GetCursor + * or TkGetCursorFromData. * * Results: * None. * * Side effects: - * The reference count associated with cursor is decremented, and - * it is officially deallocated if no-one is using it anymore. + * The reference count associated with cursor is decremented, and it is + * officially deallocated if no-one is using it anymore. * *---------------------------------------------------------------------- */ void -Tk_FreeCursor(display, cursor) - Display *display; /* Display for which cursor was allocated. */ - Tk_Cursor cursor; /* Identifier for cursor to be released. */ +Tk_FreeCursor( + Display *display, /* Display for which cursor was allocated. */ + Tk_Cursor cursor) /* Identifier for cursor to be released. */ { Tcl_HashEntry *idHashPtr; TkDisplay *dispPtr = TkGetDisplay(display); if (!dispPtr->cursorInit) { - panic("Tk_FreeCursor called before Tk_GetCursor"); + Tcl_Panic("Tk_FreeCursor called before Tk_GetCursor"); } idHashPtr = Tcl_FindHashEntry(&dispPtr->cursorIdTable, (char *) cursor); if (idHashPtr == NULL) { - panic("Tk_FreeCursor received unknown cursor argument"); + Tcl_Panic("Tk_FreeCursor received unknown cursor argument"); } FreeCursor((TkCursor *) Tcl_GetHashValue(idHashPtr)); } @@ -537,27 +524,27 @@ Tk_FreeCursor(display, cursor) * * Tk_FreeCursorFromObj -- * - * This procedure is called to release a cursor allocated by - * Tk_AllocCursorFromObj. It does not throw away the Tcl_Obj *; - * it only gets rid of the hash table entry for this cursor - * and clears the cached value that is normally stored in the object. + * This function is called to release a cursor allocated by + * Tk_AllocCursorFromObj. It does not throw away the Tcl_Obj *; it only + * gets rid of the hash table entry for this cursor and clears the cached + * value that is normally stored in the object. * * Results: * None. * * Side effects: - * The reference count associated with the cursor represented by - * objPtr is decremented, and the cursor is released to X if there are - * no remaining uses for it. + * The reference count associated with the cursor represented by objPtr + * is decremented, and the cursor is released to X if there are no + * remaining uses for it. * *---------------------------------------------------------------------- */ void -Tk_FreeCursorFromObj(tkwin, objPtr) - Tk_Window tkwin; /* The window this cursor lives in. Needed - * for the display value. */ - Tcl_Obj *objPtr; /* The Tcl_Obj * to be freed. */ +Tk_FreeCursorFromObj( + Tk_Window tkwin, /* The window this cursor lives in. Needed for + * the display value. */ + Tcl_Obj *objPtr) /* The Tcl_Obj * to be freed. */ { FreeCursor(GetCursorFromObj(tkwin, objPtr)); FreeCursorObjProc(objPtr); @@ -566,66 +553,65 @@ Tk_FreeCursorFromObj(tkwin, objPtr) /* *--------------------------------------------------------------------------- * - * FreeCursorFromObjProc -- + * FreeCursorFromObjProc -- * * This proc is called to release an object reference to a cursor. - * Called when the object's internal rep is released or when - * the cached tkColPtr needs to be changed. + * Called when the object's internal rep is released or when the cached + * tkColPtr needs to be changed. * * Results: * None. * * Side effects: - * The object reference count is decremented. When both it - * and the hash ref count go to zero, the color's resources - * are released. + * The object reference count is decremented. When both it and the hash + * ref count go to zero, the color's resources are released. * *--------------------------------------------------------------------------- */ static void -FreeCursorObjProc(objPtr) - Tcl_Obj *objPtr; /* The object we are releasing. */ +FreeCursorObjProc( + Tcl_Obj *objPtr) /* The object we are releasing. */ { TkCursor *cursorPtr = (TkCursor *) objPtr->internalRep.twoPtrValue.ptr1; if (cursorPtr != NULL) { cursorPtr->objRefCount--; - if ((cursorPtr->objRefCount == 0) + if ((cursorPtr->objRefCount == 0) && (cursorPtr->resourceRefCount == 0)) { ckfree((char *) cursorPtr); } - objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL; + objPtr->internalRep.twoPtrValue.ptr1 = NULL; } } /* *--------------------------------------------------------------------------- * - * DupCursorObjProc -- + * DupCursorObjProc -- * - * When a cached cursor object is duplicated, this is called to - * update the internal reps. + * When a cached cursor object is duplicated, this is called to update + * the internal reps. * * Results: * None. * * Side effects: - * The color's objRefCount is incremented and the internal rep - * of the copy is set to point to it. + * The color's objRefCount is incremented and the internal rep of the + * copy is set to point to it. * *--------------------------------------------------------------------------- */ static void -DupCursorObjProc(srcObjPtr, dupObjPtr) - Tcl_Obj *srcObjPtr; /* The object we are copying from. */ - Tcl_Obj *dupObjPtr; /* The object we are copying to. */ +DupCursorObjProc( + Tcl_Obj *srcObjPtr, /* The object we are copying from. */ + Tcl_Obj *dupObjPtr) /* The object we are copying to. */ { TkCursor *cursorPtr = (TkCursor *) srcObjPtr->internalRep.twoPtrValue.ptr1; - + dupObjPtr->typePtr = srcObjPtr->typePtr; - dupObjPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr; + dupObjPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr; if (cursorPtr != NULL) { cursorPtr->objRefCount++; @@ -638,27 +624,31 @@ DupCursorObjProc(srcObjPtr, dupObjPtr) * Tk_GetCursorFromObj -- * * Returns the cursor referred to buy a Tcl object. The cursor must - * already have been allocated via a call to Tk_AllocCursorFromObj or + * already have been allocated via a call to Tk_AllocCursorFromObj or * Tk_GetCursor. * * Results: - * Returns the Tk_Cursor that matches the tkwin and the string rep - * of the name of the cursor given in objPtr. + * Returns the Tk_Cursor that matches the tkwin and the string rep of the + * name of the cursor given in objPtr. * * Side effects: - * If the object is not already a cursor, the conversion will free - * any old internal representation. + * If the object is not already a cursor, the conversion will free any + * old internal representation. * *---------------------------------------------------------------------- */ Tk_Cursor -Tk_GetCursorFromObj(tkwin, objPtr) - Tk_Window tkwin; - Tcl_Obj *objPtr; /* The object from which to get pixels. */ +Tk_GetCursorFromObj( + Tk_Window tkwin, + Tcl_Obj *objPtr) /* The object from which to get pixels. */ { TkCursor *cursorPtr = GetCursorFromObj(tkwin, objPtr); - /* GetCursorFromObj should never return NULL */ + + /* + * GetCursorFromObj should never return NULL + */ + return cursorPtr->cursor; } @@ -667,25 +657,25 @@ Tk_GetCursorFromObj(tkwin, objPtr) * * GetCursorFromObj -- * - * Returns the cursor referred to by a Tcl object. The cursor must - * already have been allocated via a call to Tk_AllocCursorFromObj - * or Tk_GetCursor. + * Returns the cursor referred to by a Tcl object. The cursor must + * already have been allocated via a call to Tk_AllocCursorFromObj or + * Tk_GetCursor. * * Results: - * Returns the TkCursor * that matches the tkwin and the string rep - * of the name of the cursor given in objPtr. + * Returns the TkCursor * that matches the tkwin and the string rep of + * the name of the cursor given in objPtr. * * Side effects: - * If the object is not already a cursor, the conversion will free - * any old internal representation. + * If the object is not already a cursor, the conversion will free any + * old internal representation. * *---------------------------------------------------------------------- */ static TkCursor * -GetCursorFromObj(tkwin, objPtr) - Tk_Window tkwin; /* Window in which the cursor will be used. */ - Tcl_Obj *objPtr; /* The object that describes the desired +GetCursorFromObj( + Tk_Window tkwin, /* Window in which the cursor will be used. */ + Tcl_Obj *objPtr) /* The object that describes the desired * cursor. */ { TkCursor *cursorPtr; @@ -697,11 +687,12 @@ GetCursorFromObj(tkwin, objPtr) } /* - * The internal representation is a cache of the last cursor used - * with the given name. But there can be lots different cursors - * for each cursor name; one cursor for each display. Check to - * see if the cursor we have cached is the one that is needed. + * The internal representation is a cache of the last cursor used with the + * given name. But there can be lots different cursors for each cursor + * name; one cursor for each display. Check to see if the cursor we have + * cached is the one that is needed. */ + cursorPtr = (TkCursor *) objPtr->internalRep.twoPtrValue.ptr1; if ((cursorPtr != NULL) && (Tk_Display(tkwin) == cursorPtr->display)) { return cursorPtr; @@ -721,14 +712,14 @@ GetCursorFromObj(tkwin, objPtr) cursorPtr != NULL; cursorPtr = cursorPtr->nextPtr) { if (Tk_Display(tkwin) == cursorPtr->display) { FreeCursorObjProc(objPtr); - objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) cursorPtr; + objPtr->internalRep.twoPtrValue.ptr1 = (void *) cursorPtr; cursorPtr->objRefCount++; return cursorPtr; } } - error: - panic("GetCursorFromObj called with non-existent cursor!"); + error: + Tcl_Panic("GetCursorFromObj called with non-existent cursor!"); /* * The following code isn't reached; it's just there to please compilers. */ @@ -740,27 +731,27 @@ GetCursorFromObj(tkwin, objPtr) * * InitCursorObj -- * - * Bookeeping procedure to change an objPtr to a cursor type. + * Bookeeping function to change an objPtr to a cursor type. * * Results: * None. * * Side effects: - * The old internal rep of the object is freed. The internal - * rep is cleared. The final form of the object is set - * by either Tk_AllocCursorFromObj or GetCursorFromObj. + * The old internal rep of the object is freed. The internal rep is + * cleared. The final form of the object is set by either + * Tk_AllocCursorFromObj or GetCursorFromObj. * *---------------------------------------------------------------------- */ static void -InitCursorObj(objPtr) - Tcl_Obj *objPtr; /* The object to convert. */ +InitCursorObj( + Tcl_Obj *objPtr) /* The object to convert. */ { - Tcl_ObjType *typePtr; + const Tcl_ObjType *typePtr; /* - * Free the old internalRep before setting the new one. + * Free the old internalRep before setting the new one. */ Tcl_GetString(objPtr); @@ -769,7 +760,7 @@ InitCursorObj(objPtr) (*typePtr->freeIntRepProc)(objPtr); } objPtr->typePtr = &tkCursorObjType; - objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) NULL; + objPtr->internalRep.twoPtrValue.ptr1 = NULL; } /* @@ -789,26 +780,26 @@ InitCursorObj(objPtr) */ static void -CursorInit(dispPtr) - TkDisplay *dispPtr; /* Display used to store thread-specific data. */ +CursorInit( + TkDisplay *dispPtr) /* Display used to store thread-specific + * data. */ { Tcl_InitHashTable(&dispPtr->cursorNameTable, TCL_STRING_KEYS); Tcl_InitHashTable(&dispPtr->cursorDataTable, sizeof(DataKey)/sizeof(int)); /* - * The call below is tricky: can't use sizeof(IdKey) because it - * gets padded with extra unpredictable bytes on some 64-bit - * machines. + * The call below is tricky: can't use sizeof(IdKey) because it gets + * padded with extra unpredictable bytes on some 64-bit machines. */ - /* - * Old code.... - * Tcl_InitHashTable(&dispPtr->cursorIdTable, sizeof(Display *) + /* + * Old code.... + * Tcl_InitHashTable(&dispPtr->cursorIdTable, sizeof(Display *) * /sizeof(int)); * - * The comment above doesn't make sense. - * However, XIDs should only be 32 bits, by the definition of X, - * so the code above causes Tk to crash. Here is the real code: + * The comment above doesn't make sense. However, XIDs should only be 32 + * bits, by the definition of X, so the code above causes Tk to crash. + * Here is the real code: */ Tcl_InitHashTable(&dispPtr->cursorIdTable, TCL_ONE_WORD_KEYS); @@ -821,13 +812,13 @@ CursorInit(dispPtr) * * TkDebugCursor -- * - * This procedure returns debugging information about a cursor. + * This function returns debugging information about a cursor. * * Results: * The return value is a list with one sublist for each TkCursor - * corresponding to "name". Each sublist has two elements that - * contain the resourceRefCount and objRefCount fields from the - * TkCursor structure. + * corresponding to "name". Each sublist has two elements that contain + * the resourceRefCount and objRefCount fields from the TkCursor + * structure. * * Side effects: * None. @@ -836,10 +827,10 @@ CursorInit(dispPtr) */ Tcl_Obj * -TkDebugCursor(tkwin, name) - Tk_Window tkwin; /* The window in which the cursor will be - * used (not currently used). */ - char *name; /* Name of the desired color. */ +TkDebugCursor( + Tk_Window tkwin, /* The window in which the cursor will be used + * (not currently used). */ + char *name) /* Name of the desired color. */ { TkCursor *cursorPtr; Tcl_HashEntry *hashPtr; @@ -854,16 +845,24 @@ TkDebugCursor(tkwin, name) if (hashPtr != NULL) { cursorPtr = (TkCursor *) Tcl_GetHashValue(hashPtr); if (cursorPtr == NULL) { - panic("TkDebugCursor found empty hash table entry"); + Tcl_Panic("TkDebugCursor found empty hash table entry"); } for ( ; (cursorPtr != NULL); cursorPtr = cursorPtr->nextPtr) { objPtr = Tcl_NewObj(); Tcl_ListObjAppendElement(NULL, objPtr, Tcl_NewIntObj(cursorPtr->resourceRefCount)); Tcl_ListObjAppendElement(NULL, objPtr, - Tcl_NewIntObj(cursorPtr->objRefCount)); + Tcl_NewIntObj(cursorPtr->objRefCount)); Tcl_ListObjAppendElement(NULL, resultPtr, objPtr); } } return resultPtr; } + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ |