From 9c82b94f7f8be2ebc6cf88f55d08d6e087cff5a5 Mon Sep 17 00:00:00 2001 From: "jan.nijtmans" Date: Wed, 9 Sep 2020 09:55:56 +0000 Subject: TIP #581: More progress --- generic/tkGeometry.c | 302 ++++++++++++++++++++++----------------------- generic/tkImage.c | 265 ++++++++++++++++++++------------------- generic/tkImgBmap.c | 22 ++-- generic/tkStubInit.c | 2 +- generic/ttk/ttkManager.c | 24 ++-- macosx/tkMacOSXMenu.c | 4 +- macosx/tkMacOSXWm.c | 34 ++--- macosx/tkMacOSXWm.h | 2 +- tests/focus.test | 2 +- tests/safe.test | 2 +- tests/ttk/combobox.test | 8 +- tests/ttk/image.test | 2 +- tests/ttk/panedwindow.test | 6 +- tests/ttk/scrollbar.test | 8 +- tests/ttk/treetags.test | 6 +- tests/ttk/treeview.test | 6 +- tests/ttk/ttk.test | 2 +- tests/ttk/validate.test | 2 +- unix/Makefile.in | 2 +- unix/tkUnixWm.c | 106 ++++++++-------- win/Makefile.in | 9 +- win/tkWinWm.c | 108 ++++++++-------- 22 files changed, 461 insertions(+), 463 deletions(-) diff --git a/generic/tkGeometry.c b/generic/tkGeometry.c index b70e66a..5ecac0e 100644 --- a/generic/tkGeometry.c +++ b/generic/tkGeometry.c @@ -20,16 +20,16 @@ */ typedef struct MaintainContent { - Tk_Window slave; /* The slave window being positioned. */ - Tk_Window master; /* The master that determines slave's + Tk_Window content; /* The content window being positioned. */ + Tk_Window container; /* The container that determines content's * position; it must be a descendant of - * slave's parent. */ - int x, y; /* Desired position of slave relative to - * master. */ - int width, height; /* Desired dimensions of slave. */ + * content's parent. */ + int x, y; /* Desired position of content relative to + * container. */ + int width, height; /* Desired dimensions of content. */ struct MaintainContent *nextPtr; /* Next in list of Maintains associated with - * master. */ + * container. */ } MaintainContent; /* @@ -45,7 +45,7 @@ typedef struct MaintainContainer { int checkScheduled; /* Non-zero means that there is already a call * to MaintainCheckProc scheduled as an idle * handler. */ - MaintainContent *slavePtr; /* First in list of all content associated with + MaintainContent *contentPtr; /* First in list of all content associated with * this container. */ } MaintainContainer; @@ -65,7 +65,7 @@ static void MaintainContentProc(ClientData clientData, * Tk_ManageGeometry -- * * Arrange for a particular procedure to manage the geometry of a given - * slave window. + * content window. * * Results: * None. @@ -218,7 +218,7 @@ Tk_SetInternalBorderEx( } /* - * All the slaves for which this is the master window must now be + * All the content for which this is the container window must now be * repositioned to take account of the new internal border width. To * signal all the geometry managers to do this, trigger a ConfigureNotify * event. This will cause geometry managers to recompute everything. @@ -341,7 +341,7 @@ TkSetGeometryContainer( return TCL_ERROR; } - winPtr->geomMgrName = ckalloc(strlen(name) + 1); + winPtr->geomMgrName = (char *)ckalloc(strlen(name) + 1); strcpy(winPtr->geomMgrName, name); return TCL_OK; } @@ -387,12 +387,12 @@ TkFreeGeometryContainer( * * Tk_MaintainGeometry -- * - * This procedure is invoked by geometry managers to handle slaves whose - * master's are not their parents. It translates the desired geometry for - * the slave into the coordinate system of the parent and respositions - * the slave if it isn't already at the right place. Furthermore, it sets - * up event handlers so that if the master (or any of its ancestors up to - * the slave's parent) is mapped, unmapped, or moved, then the slave will + * This procedure is invoked by geometry managers to handle content whose + * container's are not their parents. It translates the desired geometry for + * the content into the coordinate system of the parent and respositions + * the content if it isn't already at the right place. Furthermore, it sets + * up event handlers so that if the container (or any of its ancestors up to + * the content's parent) is mapped, unmapped, or moved, then the content will * be adjusted to match. * * Results: @@ -400,7 +400,7 @@ TkFreeGeometryContainer( * * Side effects: * Event handlers are created and state is allocated to keep track of - * slave. Note: if slave was already managed for master by + * content. Note: if content was already managed for container by * Tk_MaintainGeometry, then the previous information is replaced with * the new information. The caller must eventually call * Tk_UnmaintainGeometry to eliminate the correspondence (or, the state @@ -411,40 +411,40 @@ TkFreeGeometryContainer( void Tk_MaintainGeometry( - Tk_Window slave, /* Slave for geometry management. */ - Tk_Window master, /* Master for slave; must be a descendant of - * slave's parent. */ - int x, int y, /* Desired position of slave within master. */ - int width, int height) /* Desired dimensions for slave. */ + Tk_Window window, /* Window for geometry management. */ + Tk_Window container, /* Container for window; must be a descendant of + * window's parent. */ + int x, int y, /* Desired position of window within container. */ + int width, int height) /* Desired dimensions for window. */ { Tcl_HashEntry *hPtr; - MaintainContainer *masterPtr; - MaintainContent *slavePtr; + MaintainContainer *containerPtr; + MaintainContent *contentPtr; int isNew, map; Tk_Window ancestor, parent; - TkDisplay *dispPtr = ((TkWindow *) master)->dispPtr; + TkDisplay *dispPtr = ((TkWindow *) container)->dispPtr; - ((TkWindow *)slave)->maintainerPtr = (TkWindow *)master; + ((TkWindow *)window)->maintainerPtr = (TkWindow *)container; - ((TkWindow *)slave)->maintainerPtr = (TkWindow *)master; - if (master == Tk_Parent(slave)) { + ((TkWindow *)window)->maintainerPtr = (TkWindow *)container; + if (container == Tk_Parent(window)) { /* - * If the slave is a direct descendant of the master, don't bother + * If the window is a direct descendant of the container, don't bother * setting up the extra infrastructure for management, just make a * call to Tk_MoveResizeWindow; the parent/child relationship will * take care of the rest. */ - Tk_MoveResizeWindow(slave, x, y, width, height); + Tk_MoveResizeWindow(window, x, y, width, height); /* - * Map the slave if the master is already mapped; otherwise, wait - * until the master is mapped later (in which case mapping the slave + * Map the window if the container is already mapped; otherwise, wait + * until the container is mapped later (in which case mapping the window * is taken care of elsewhere). */ - if (Tk_IsMapped(master)) { - Tk_MapWindow(slave); + if (Tk_IsMapped(container)) { + Tk_MapWindow(window); } return; } @@ -455,55 +455,55 @@ Tk_MaintainGeometry( } /* - * See if there is already a MaintainContainer structure for the master; if + * See if there is already a MaintainContainer structure for the container; if * not, then create one. */ - parent = Tk_Parent(slave); + parent = Tk_Parent(window); hPtr = Tcl_CreateHashEntry(&dispPtr->maintainHashTable, - (char *) master, &isNew); + (char *) container, &isNew); if (!isNew) { - masterPtr = Tcl_GetHashValue(hPtr); + containerPtr = (MaintainContainer *)Tcl_GetHashValue(hPtr); } else { - masterPtr = ckalloc(sizeof(MaintainContainer)); - masterPtr->ancestor = master; - masterPtr->checkScheduled = 0; - masterPtr->slavePtr = NULL; - Tcl_SetHashValue(hPtr, masterPtr); + containerPtr = (MaintainContainer *)ckalloc(sizeof(MaintainContainer)); + containerPtr->ancestor = container; + containerPtr->checkScheduled = 0; + containerPtr->contentPtr = NULL; + Tcl_SetHashValue(hPtr, containerPtr); } /* - * Create a MaintainContent structure for the slave if there isn't already + * Create a MaintainContent structure for the window if there isn't already * one. */ - for (slavePtr = masterPtr->slavePtr; slavePtr != NULL; - slavePtr = slavePtr->nextPtr) { - if (slavePtr->slave == slave) { - goto gotSlave; + for (contentPtr = containerPtr->contentPtr; contentPtr != NULL; + contentPtr = contentPtr->nextPtr) { + if (contentPtr->content == window) { + goto gotContent; } } - slavePtr = ckalloc(sizeof(MaintainContent)); - slavePtr->slave = slave; - slavePtr->master = master; - slavePtr->nextPtr = masterPtr->slavePtr; - masterPtr->slavePtr = slavePtr; - Tk_CreateEventHandler(slave, StructureNotifyMask, MaintainContentProc, - slavePtr); + contentPtr = (MaintainContent *)ckalloc(sizeof(MaintainContent)); + contentPtr->content = window; + contentPtr->container = container; + contentPtr->nextPtr = containerPtr->contentPtr; + containerPtr->contentPtr = contentPtr; + Tk_CreateEventHandler(window, StructureNotifyMask, MaintainContentProc, + contentPtr); /* * Make sure that there are event handlers registered for all the windows - * between master and slave's parent (including master but not slave's - * parent). There may already be handlers for master and some of its - * ancestors (masterPtr->ancestor tells how many). + * between container and windows's parent (including container but not window's + * parent). There may already be handlers for container and some of its + * ancestors (containerPtr->ancestor tells how many). */ - for (ancestor = master; ancestor != parent; + for (ancestor = container; ancestor != parent; ancestor = Tk_Parent(ancestor)) { - if (ancestor == masterPtr->ancestor) { + if (ancestor == containerPtr->ancestor) { Tk_CreateEventHandler(ancestor, StructureNotifyMask, - MaintainContainerProc, masterPtr); - masterPtr->ancestor = Tk_Parent(ancestor); + MaintainContainerProc, containerPtr); + containerPtr->ancestor = Tk_Parent(ancestor); } } @@ -512,27 +512,27 @@ Tk_MaintainGeometry( * if it's not currently in the right place or state. */ - gotSlave: - slavePtr->x = x; - slavePtr->y = y; - slavePtr->width = width; - slavePtr->height = height; + gotContent: + contentPtr->x = x; + contentPtr->y = y; + contentPtr->width = width; + contentPtr->height = height; map = 1; - for (ancestor = slavePtr->master; ; ancestor = Tk_Parent(ancestor)) { + for (ancestor = contentPtr->container; ; ancestor = Tk_Parent(ancestor)) { if (!Tk_IsMapped(ancestor) && (ancestor != parent)) { map = 0; } if (ancestor == parent) { - if ((x != Tk_X(slavePtr->slave)) - || (y != Tk_Y(slavePtr->slave)) - || (width != Tk_Width(slavePtr->slave)) - || (height != Tk_Height(slavePtr->slave))) { - Tk_MoveResizeWindow(slavePtr->slave, x, y, width, height); + if ((x != Tk_X(contentPtr->content)) + || (y != Tk_Y(contentPtr->content)) + || (width != Tk_Width(contentPtr->content)) + || (height != Tk_Height(contentPtr->content))) { + Tk_MoveResizeWindow(contentPtr->content, x, y, width, height); } if (map) { - Tk_MapWindow(slavePtr->slave); + Tk_MapWindow(contentPtr->content); } else { - Tk_UnmapWindow(slavePtr->slave); + Tk_UnmapWindow(contentPtr->content); } break; } @@ -547,37 +547,37 @@ Tk_MaintainGeometry( * Tk_UnmaintainGeometry -- * * This procedure cancels a previous Tk_MaintainGeometry call, so that - * the relationship between slave and master is no longer maintained. + * the relationship between window and container is no longer maintained. * * Results: * None. * * Side effects: - * The slave is unmapped and state is released, so that slave won't track - * master any more. If we weren't previously managing slave relative to - * master, then this procedure has no effect. + * The window is unmapped and state is released, so that window won't track + * container any more. If we weren't previously managing window relative to + * container, then this procedure has no effect. * *---------------------------------------------------------------------- */ void Tk_UnmaintainGeometry( - Tk_Window slave, /* Slave for geometry management. */ - Tk_Window master) /* Master for slave; must be a descendant of - * slave's parent. */ + Tk_Window window, /* WIndow for geometry management. */ + Tk_Window container) /* Container for window; must be a descendant of + * window's parent. */ { Tcl_HashEntry *hPtr; - MaintainContainer *masterPtr; - MaintainContent *slavePtr, *prevPtr; + MaintainContainer *containerPtr; + MaintainContent *contentPtr, *prevPtr; Tk_Window ancestor; - TkDisplay *dispPtr = ((TkWindow *) slave)->dispPtr; + TkDisplay *dispPtr = ((TkWindow *) window)->dispPtr; - ((TkWindow *)slave)->maintainerPtr = NULL; + ((TkWindow *)window)->maintainerPtr = NULL; - ((TkWindow *)slave)->maintainerPtr = NULL; - if (master == Tk_Parent(slave)) { + ((TkWindow *)window)->maintainerPtr = NULL; + if (container == Tk_Parent(window)) { /* - * If the slave is a direct descendant of the master, + * If the window is a direct descendant of the container, * Tk_MaintainGeometry will not have set up any of the extra * infrastructure. Don't even bother to look for it, just return. */ @@ -589,47 +589,47 @@ Tk_UnmaintainGeometry( Tcl_InitHashTable(&dispPtr->maintainHashTable, TCL_ONE_WORD_KEYS); } - if (!(((TkWindow *) slave)->flags & TK_ALREADY_DEAD)) { - Tk_UnmapWindow(slave); + if (!(((TkWindow *) window)->flags & TK_ALREADY_DEAD)) { + Tk_UnmapWindow(window); } - hPtr = Tcl_FindHashEntry(&dispPtr->maintainHashTable, (char *) master); + hPtr = Tcl_FindHashEntry(&dispPtr->maintainHashTable, container); if (hPtr == NULL) { return; } - masterPtr = Tcl_GetHashValue(hPtr); - slavePtr = masterPtr->slavePtr; - if (slavePtr->slave == slave) { - masterPtr->slavePtr = slavePtr->nextPtr; + containerPtr = (MaintainContainer *)Tcl_GetHashValue(hPtr); + contentPtr = containerPtr->contentPtr; + if (contentPtr->content == window) { + containerPtr->contentPtr = contentPtr->nextPtr; } else { - for (prevPtr = slavePtr, slavePtr = slavePtr->nextPtr; ; - prevPtr = slavePtr, slavePtr = slavePtr->nextPtr) { - if (slavePtr == NULL) { + for (prevPtr = contentPtr, contentPtr = contentPtr->nextPtr; ; + prevPtr = contentPtr, contentPtr = contentPtr->nextPtr) { + if (contentPtr == NULL) { return; } - if (slavePtr->slave == slave) { - prevPtr->nextPtr = slavePtr->nextPtr; + if (contentPtr->content == window) { + prevPtr->nextPtr = contentPtr->nextPtr; break; } } } - Tk_DeleteEventHandler(slavePtr->slave, StructureNotifyMask, - MaintainContentProc, slavePtr); - ckfree(slavePtr); - if (masterPtr->slavePtr == NULL) { - if (masterPtr->ancestor != NULL) { - for (ancestor = master; ; ancestor = Tk_Parent(ancestor)) { + Tk_DeleteEventHandler(contentPtr->content, StructureNotifyMask, + MaintainContentProc, contentPtr); + ckfree(contentPtr); + if (containerPtr->contentPtr == NULL) { + if (containerPtr->ancestor != NULL) { + for (ancestor = container; ; ancestor = Tk_Parent(ancestor)) { Tk_DeleteEventHandler(ancestor, StructureNotifyMask, - MaintainContainerProc, masterPtr); - if (ancestor == masterPtr->ancestor) { + MaintainContainerProc, containerPtr); + if (ancestor == containerPtr->ancestor) { break; } } } - if (masterPtr->checkScheduled) { - Tcl_CancelIdleCall(MaintainCheckProc, masterPtr); + if (containerPtr->checkScheduled) { + Tcl_CancelIdleCall(MaintainCheckProc, containerPtr); } Tcl_DeleteHashEntry(hPtr); - ckfree(masterPtr); + ckfree(containerPtr); } } @@ -639,7 +639,7 @@ Tk_UnmaintainGeometry( * MaintainContainerProc -- * * This procedure is invoked by the Tk event dispatcher in response to - * StructureNotify events on the master or one of its ancestors, on + * StructureNotify events on the container or one of its ancestors, on * behalf of Tk_MaintainGeometry. * * Results: @@ -648,7 +648,7 @@ Tk_UnmaintainGeometry( * Side effects: * It schedules a call to MaintainCheckProc, which will eventually caused * the postions and mapped states to be recalculated for all the - * maintained slaves of the master. Or, if the master window is being + * maintained windows of the container. Or, if the container window is being * deleted then state is cleaned up. * *---------------------------------------------------------------------- @@ -657,34 +657,34 @@ Tk_UnmaintainGeometry( static void MaintainContainerProc( ClientData clientData, /* Pointer to MaintainContainer structure for the - * master window. */ + * container window. */ XEvent *eventPtr) /* Describes what just happened. */ { - MaintainContainer *masterPtr = clientData; - MaintainContent *slavePtr; + MaintainContainer *containerPtr = (MaintainContainer *)clientData; + MaintainContent *contentPtr; int done; if ((eventPtr->type == ConfigureNotify) || (eventPtr->type == MapNotify) || (eventPtr->type == UnmapNotify)) { - if (!masterPtr->checkScheduled) { - masterPtr->checkScheduled = 1; - Tcl_DoWhenIdle(MaintainCheckProc, masterPtr); + if (!containerPtr->checkScheduled) { + containerPtr->checkScheduled = 1; + Tcl_DoWhenIdle(MaintainCheckProc, containerPtr); } } else if (eventPtr->type == DestroyNotify) { /* - * Delete all of the state associated with this master, but be careful - * not to use masterPtr after the last slave is deleted, since its + * Delete all of the state associated with this container, but be careful + * not to use containerPtr after the last window is deleted, since its * memory will have been freed. */ done = 0; do { - slavePtr = masterPtr->slavePtr; - if (slavePtr->nextPtr == NULL) { + contentPtr = containerPtr->contentPtr; + if (contentPtr->nextPtr == NULL) { done = 1; } - Tk_UnmaintainGeometry(slavePtr->slave, slavePtr->master); + Tk_UnmaintainGeometry(contentPtr->content, contentPtr->container); } while (!done); } } @@ -695,7 +695,7 @@ MaintainContainerProc( * MaintainContentProc -- * * This procedure is invoked by the Tk event dispatcher in response to - * StructureNotify events on a slave being managed by + * StructureNotify events on a window being managed by * Tk_MaintainGeometry. * * Results: @@ -703,7 +703,7 @@ MaintainContainerProc( * * Side effects: * If the event is a DestroyNotify event then the Maintain state and - * event handlers for this slave are deleted. + * event handlers for this window are deleted. * *---------------------------------------------------------------------- */ @@ -711,13 +711,13 @@ MaintainContainerProc( static void MaintainContentProc( ClientData clientData, /* Pointer to MaintainContent structure for - * master-slave pair. */ + * container-window pair. */ XEvent *eventPtr) /* Describes what just happened. */ { - MaintainContent *slavePtr = clientData; + MaintainContent *contentPtr = (MaintainContent *)clientData; if (eventPtr->type == DestroyNotify) { - Tk_UnmaintainGeometry(slavePtr->slave, slavePtr->master); + Tk_UnmaintainGeometry(contentPtr->content, contentPtr->container); } } @@ -727,16 +727,16 @@ MaintainContentProc( * MaintainCheckProc -- * * This procedure is invoked by the Tk event dispatcher as an idle - * handler, when a master or one of its ancestors has been reconfigured, - * mapped, or unmapped. Its job is to scan all of the slaves for the - * master and reposition them, map them, or unmap them as needed to - * maintain their geometry relative to the master. + * handler, when a container or one of its ancestors has been reconfigured, + * mapped, or unmapped. Its job is to scan all of the windows for the + * container and reposition them, map them, or unmap them as needed to + * maintain their geometry relative to the container. * * Results: * None. * * Side effects: - * Slaves can get repositioned, mapped, or unmapped. + * Windows can get repositioned, mapped, or unmapped. * *---------------------------------------------------------------------- */ @@ -744,33 +744,33 @@ MaintainContentProc( static void MaintainCheckProc( ClientData clientData) /* Pointer to MaintainContainer structure for the - * master window. */ + * container window. */ { - MaintainContainer *masterPtr = clientData; - MaintainContent *slavePtr; + MaintainContainer *containerPtr = (MaintainContainer *)clientData; + MaintainContent *contentPtr; Tk_Window ancestor, parent; int x, y, map; - masterPtr->checkScheduled = 0; - for (slavePtr = masterPtr->slavePtr; slavePtr != NULL; - slavePtr = slavePtr->nextPtr) { - parent = Tk_Parent(slavePtr->slave); - x = slavePtr->x; - y = slavePtr->y; + containerPtr->checkScheduled = 0; + for (contentPtr = containerPtr->contentPtr; contentPtr != NULL; + contentPtr = contentPtr->nextPtr) { + parent = Tk_Parent(contentPtr->content); + x = contentPtr->x; + y = contentPtr->y; map = 1; - for (ancestor = slavePtr->master; ; ancestor = Tk_Parent(ancestor)) { + for (ancestor = contentPtr->container; ; ancestor = Tk_Parent(ancestor)) { if (!Tk_IsMapped(ancestor) && (ancestor != parent)) { map = 0; } if (ancestor == parent) { - if ((x != Tk_X(slavePtr->slave)) - || (y != Tk_Y(slavePtr->slave))) { - Tk_MoveWindow(slavePtr->slave, x, y); + if ((x != Tk_X(contentPtr->content)) + || (y != Tk_Y(contentPtr->content))) { + Tk_MoveWindow(contentPtr->content, x, y); } if (map) { - Tk_MapWindow(slavePtr->slave); + Tk_MapWindow(contentPtr->content); } else { - Tk_UnmapWindow(slavePtr->slave); + Tk_UnmapWindow(contentPtr->content); } break; } diff --git a/generic/tkImage.c b/generic/tkImage.c index 8192c23..763c65b 100644 --- a/generic/tkImage.c +++ b/generic/tkImage.c @@ -26,8 +26,8 @@ typedef struct Image { Display *display; /* Display for tkwin. Needed because when the * image is eventually freed tkwin may not * exist anymore. */ - struct ImageModel *masterPtr; - /* Master for this image (identifiers image + struct ImageModel *modelPtr; + /* Model for this image (identifiers image * manager, for example). */ ClientData instanceData; /* One word argument to pass to image manager * when dealing with this image instance. */ @@ -40,7 +40,7 @@ typedef struct Image { } Image; /* - * For each image master there is one of the following structures, which + * For each image model there is one of the following structures, which * represents a name in the image table and all of the images instantiated * from it. Entries in mainPtr->imageTable point to these structures. */ @@ -49,8 +49,8 @@ typedef struct ImageModel { Tk_ImageType *typePtr; /* Information about image type. NULL means * that no image manager owns this image: the * image was deleted. */ - ClientData masterData; /* One-word argument to pass to image mgr when - * dealing with the master, as opposed to + ClientData modelData; /* One-word argument to pass to image mgr when + * dealing with the model, as opposed to * instances. */ int width, height; /* Last known dimensions for image. */ Tcl_HashTable *tablePtr; /* Pointer to hash table containing image (the @@ -82,8 +82,8 @@ static Tcl_ThreadDataKey dataKey; */ static void ImageTypeThreadExitProc(ClientData clientData); -static void DeleteImage(ImageModel *masterPtr); -static void EventuallyDeleteImage(ImageModel *masterPtr, +static void DeleteImage(ImageModel *modelPtr); +static void EventuallyDeleteImage(ImageModel *modelPtr, int forgetImageHashNow); /* @@ -104,10 +104,10 @@ static void EventuallyDeleteImage(ImageModel *masterPtr, static void ImageTypeThreadExitProc( - ClientData clientData) /* not used */ + TCL_UNUSED(void *)) { Tk_ImageType *freePtr; - ThreadSpecificData *tsdPtr = + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); while (tsdPtr->oldImageTypeList != NULL) { @@ -149,14 +149,14 @@ Tk_CreateOldImageType( * by caller. */ { Tk_ImageType *copyPtr; - ThreadSpecificData *tsdPtr = + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); if (!tsdPtr->initialized) { tsdPtr->initialized = 1; Tcl_CreateThreadExitHandler(ImageTypeThreadExitProc, NULL); } - copyPtr = ckalloc(sizeof(Tk_ImageType)); + copyPtr = (Tk_ImageType *)ckalloc(sizeof(Tk_ImageType)); *copyPtr = *typePtr; copyPtr->nextPtr = tsdPtr->oldImageTypeList; tsdPtr->oldImageTypeList = copyPtr; @@ -170,14 +170,14 @@ Tk_CreateImageType( * by caller. */ { Tk_ImageType *copyPtr; - ThreadSpecificData *tsdPtr = + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); if (!tsdPtr->initialized) { tsdPtr->initialized = 1; Tcl_CreateThreadExitHandler(ImageTypeThreadExitProc, NULL); } - copyPtr = ckalloc(sizeof(Tk_ImageType)); + copyPtr = (Tk_ImageType *)ckalloc(sizeof(Tk_ImageType)); *copyPtr = *typePtr; copyPtr->nextPtr = tsdPtr->imageTypeList; tsdPtr->imageTypeList = copyPtr; @@ -215,10 +215,10 @@ Tk_ImageObjCmd( IMAGE_CREATE, IMAGE_DELETE, IMAGE_HEIGHT, IMAGE_INUSE, IMAGE_NAMES, IMAGE_TYPE, IMAGE_TYPES, IMAGE_WIDTH }; - TkWindow *winPtr = clientData; + TkWindow *winPtr = (TkWindow *)clientData; int i, isNew, firstOption, index; Tk_ImageType *typePtr; - ImageModel *masterPtr; + ImageModel *modelPtr; Image *imagePtr; Tcl_HashEntry *hPtr; Tcl_HashSearch search; @@ -226,7 +226,7 @@ Tk_ImageObjCmd( TkDisplay *dispPtr = winPtr->dispPtr; const char *arg, *name; Tcl_Obj *resultObj; - ThreadSpecificData *tsdPtr = + ThreadSpecificData *tsdPtr = (ThreadSpecificData *) Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData)); if (objc < 2) { @@ -297,7 +297,7 @@ Tk_ImageObjCmd( /* * Need to check if the _command_ that we are about to create is - * the name of the current master widget command (normally "." but + * the name of the current model widget command (normally "." but * could have been renamed) and fail in that case before a really * nasty and hard to stop crash happens. */ @@ -318,37 +318,37 @@ Tk_ImageObjCmd( hPtr = Tcl_CreateHashEntry(&winPtr->mainPtr->imageTable, name, &isNew); if (isNew) { - masterPtr = ckalloc(sizeof(ImageModel)); - masterPtr->typePtr = NULL; - masterPtr->masterData = NULL; - masterPtr->width = masterPtr->height = 1; - masterPtr->tablePtr = &winPtr->mainPtr->imageTable; - masterPtr->hPtr = hPtr; - masterPtr->instancePtr = NULL; - masterPtr->deleted = 0; - masterPtr->winPtr = winPtr->mainPtr->winPtr; - Tcl_Preserve(masterPtr->winPtr); - Tcl_SetHashValue(hPtr, masterPtr); + modelPtr = (ImageModel *)ckalloc(sizeof(ImageModel)); + modelPtr->typePtr = NULL; + modelPtr->modelData = NULL; + modelPtr->width = modelPtr->height = 1; + modelPtr->tablePtr = &winPtr->mainPtr->imageTable; + modelPtr->hPtr = hPtr; + modelPtr->instancePtr = NULL; + modelPtr->deleted = 0; + modelPtr->winPtr = winPtr->mainPtr->winPtr; + Tcl_Preserve(modelPtr->winPtr); + Tcl_SetHashValue(hPtr, modelPtr); } else { /* * An image already exists by this name. Disconnect the instances - * from the master. + * from the model. */ - masterPtr = Tcl_GetHashValue(hPtr); - if (masterPtr->typePtr != NULL) { - for (imagePtr = masterPtr->instancePtr; imagePtr != NULL; + modelPtr = (ImageModel *)Tcl_GetHashValue(hPtr); + if (modelPtr->typePtr != NULL) { + for (imagePtr = modelPtr->instancePtr; imagePtr != NULL; imagePtr = imagePtr->nextPtr) { - masterPtr->typePtr->freeProc(imagePtr->instanceData, + modelPtr->typePtr->freeProc(imagePtr->instanceData, imagePtr->display); imagePtr->changeProc(imagePtr->widgetClientData, 0, 0, - masterPtr->width, masterPtr->height, - masterPtr->width, masterPtr->height); + modelPtr->width, modelPtr->height, + modelPtr->width, modelPtr->height); } - masterPtr->typePtr->deleteProc(masterPtr->masterData); - masterPtr->typePtr = NULL; + modelPtr->typePtr->deleteProc(modelPtr->modelData); + modelPtr->typePtr = NULL; } - masterPtr->deleted = 0; + modelPtr->deleted = 0; } /* @@ -363,34 +363,34 @@ Tk_ImageObjCmd( if (oldimage) { int i; - args = ckalloc((objc+1) * sizeof(char *)); + args = (Tcl_Obj **)ckalloc((objc+1) * sizeof(Tcl_Obj *)); for (i = 0; i < objc; i++) { args[i] = (Tcl_Obj *) Tcl_GetString(objv[i]); } args[objc] = NULL; } - Tcl_Preserve(masterPtr); + Tcl_Preserve(modelPtr); if (typePtr->createProc(interp, name, objc, args, typePtr, - (Tk_ImageModel)masterPtr, &masterPtr->masterData) != TCL_OK){ - EventuallyDeleteImage(masterPtr, 0); - Tcl_Release(masterPtr); + (Tk_ImageModel)modelPtr, &modelPtr->modelData) != TCL_OK){ + EventuallyDeleteImage(modelPtr, 0); + Tcl_Release(modelPtr); if (oldimage) { ckfree(args); } return TCL_ERROR; } - Tcl_Release(masterPtr); + Tcl_Release(modelPtr); if (oldimage) { ckfree(args); } - masterPtr->typePtr = typePtr; - for (imagePtr = masterPtr->instancePtr; imagePtr != NULL; + modelPtr->typePtr = typePtr; + for (imagePtr = modelPtr->instancePtr; imagePtr != NULL; imagePtr = imagePtr->nextPtr) { imagePtr->instanceData = typePtr->getProc(imagePtr->tkwin, - masterPtr->masterData); + modelPtr->modelData); } Tcl_SetObjResult(interp, Tcl_NewStringObj( - Tcl_GetHashKey(&winPtr->mainPtr->imageTable, hPtr), -1)); + (const char *)Tcl_GetHashKey(&winPtr->mainPtr->imageTable, hPtr), -1)); break; } case IMAGE_DELETE: @@ -400,11 +400,11 @@ Tk_ImageObjCmd( if (hPtr == NULL) { goto alreadyDeleted; } - masterPtr = Tcl_GetHashValue(hPtr); - if (masterPtr->deleted) { + modelPtr = (ImageModel *)Tcl_GetHashValue(hPtr); + if (modelPtr->deleted) { goto alreadyDeleted; } - DeleteImage(masterPtr); + DeleteImage(modelPtr); } break; case IMAGE_NAMES: @@ -415,12 +415,12 @@ Tk_ImageObjCmd( hPtr = Tcl_FirstHashEntry(&winPtr->mainPtr->imageTable, &search); resultObj = Tcl_NewObj(); for ( ; hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) { - masterPtr = Tcl_GetHashValue(hPtr); - if (masterPtr->deleted) { + modelPtr = (ImageModel *)Tcl_GetHashValue(hPtr); + if (modelPtr->deleted) { continue; } Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj( - Tcl_GetHashKey(&winPtr->mainPtr->imageTable, hPtr), -1)); + (const char *)Tcl_GetHashKey(&winPtr->mainPtr->imageTable, hPtr), -1)); } Tcl_SetObjResult(interp, resultObj); break; @@ -449,7 +449,7 @@ Tk_ImageObjCmd( case IMAGE_WIDTH: /* * These operations all parse virtually identically. First check to - * see if three args are given. Then get a non-deleted master from the + * see if three args are given. Then get a non-deleted model from the * third arg. */ @@ -463,8 +463,8 @@ Tk_ImageObjCmd( if (hPtr == NULL) { goto alreadyDeleted; } - masterPtr = Tcl_GetHashValue(hPtr); - if (masterPtr->deleted) { + modelPtr = (ImageModel *)Tcl_GetHashValue(hPtr); + if (modelPtr->deleted) { goto alreadyDeleted; } @@ -474,20 +474,20 @@ Tk_ImageObjCmd( switch ((enum options) index) { case IMAGE_HEIGHT: - Tcl_SetObjResult(interp, Tcl_NewIntObj(masterPtr->height)); + Tcl_SetObjResult(interp, Tcl_NewIntObj(modelPtr->height)); break; case IMAGE_INUSE: Tcl_SetObjResult(interp, Tcl_NewBooleanObj( - masterPtr->typePtr && masterPtr->instancePtr)); + modelPtr->typePtr && modelPtr->instancePtr)); break; case IMAGE_TYPE: - if (masterPtr->typePtr != NULL) { + if (modelPtr->typePtr != NULL) { Tcl_SetObjResult(interp, - Tcl_NewStringObj(masterPtr->typePtr->name, -1)); + Tcl_NewStringObj(modelPtr->typePtr->name, -1)); } break; case IMAGE_WIDTH: - Tcl_SetObjResult(interp, Tcl_NewIntObj(masterPtr->width)); + Tcl_SetObjResult(interp, Tcl_NewIntObj(modelPtr->width)); break; default: Tcl_Panic("can't happen"); @@ -534,12 +534,12 @@ Tk_ImageChanged( int imageWidth, int imageHeight) /* New dimensions of image. */ { - ImageModel *masterPtr = (ImageModel *) imageModel; + ImageModel *modelPtr = (ImageModel *) imageModel; Image *imagePtr; - masterPtr->width = imageWidth; - masterPtr->height = imageHeight; - for (imagePtr = masterPtr->instancePtr; imagePtr != NULL; + modelPtr->width = imageWidth; + modelPtr->height = imageHeight; + for (imagePtr = modelPtr->instancePtr; imagePtr != NULL; imagePtr = imagePtr->nextPtr) { imagePtr->changeProc(imagePtr->widgetClientData, x, y, width, height, imageWidth, imageHeight); @@ -551,7 +551,7 @@ Tk_ImageChanged( * * Tk_NameOfImage -- * - * Given a token for an image master, this function returns the name of + * Given a token for an image model, this function returns the name of * the image. * * Results: @@ -567,12 +567,12 @@ const char * Tk_NameOfImage( Tk_ImageModel imageModel) /* Token for image. */ { - ImageModel *masterPtr = (ImageModel *) imageModel; + ImageModel *modelPtr = (ImageModel *) imageModel; - if (masterPtr->hPtr == NULL) { + if (modelPtr->hPtr == NULL) { return NULL; } - return Tcl_GetHashKey(masterPtr->tablePtr, masterPtr->hPtr); + return (const char *)Tcl_GetHashKey(modelPtr->tablePtr, modelPtr->hPtr); } /* @@ -610,30 +610,30 @@ Tk_GetImage( ClientData clientData) /* One-word argument to pass to damageProc. */ { Tcl_HashEntry *hPtr; - ImageModel *masterPtr; + ImageModel *modelPtr; Image *imagePtr; hPtr = Tcl_FindHashEntry(&((TkWindow *) tkwin)->mainPtr->imageTable, name); if (hPtr == NULL) { goto noSuchImage; } - masterPtr = Tcl_GetHashValue(hPtr); - if (masterPtr->typePtr == NULL) { + modelPtr = (ImageModel *)Tcl_GetHashValue(hPtr); + if (modelPtr->typePtr == NULL) { goto noSuchImage; } - if (masterPtr->deleted) { + if (modelPtr->deleted) { goto noSuchImage; } - imagePtr = ckalloc(sizeof(Image)); + imagePtr = (Image *)ckalloc(sizeof(Image)); imagePtr->tkwin = tkwin; imagePtr->display = Tk_Display(tkwin); - imagePtr->masterPtr = masterPtr; + imagePtr->modelPtr = modelPtr; imagePtr->instanceData = - masterPtr->typePtr->getProc(tkwin, masterPtr->masterData); + modelPtr->typePtr->getProc(tkwin, modelPtr->modelData); imagePtr->changeProc = changeProc; imagePtr->widgetClientData = clientData; - imagePtr->nextPtr = masterPtr->instancePtr; - masterPtr->instancePtr = imagePtr; + imagePtr->nextPtr = modelPtr->instancePtr; + modelPtr->instancePtr = imagePtr; return (Tk_Image) imagePtr; noSuchImage: @@ -669,20 +669,20 @@ Tk_FreeImage( * a widget. */ { Image *imagePtr = (Image *) image; - ImageModel *masterPtr = imagePtr->masterPtr; + ImageModel *modelPtr = imagePtr->modelPtr; Image *prevPtr; /* * Clean up the particular instance. */ - if (masterPtr->typePtr != NULL) { - masterPtr->typePtr->freeProc(imagePtr->instanceData, + if (modelPtr->typePtr != NULL) { + modelPtr->typePtr->freeProc(imagePtr->instanceData, imagePtr->display); } - prevPtr = masterPtr->instancePtr; + prevPtr = modelPtr->instancePtr; if (prevPtr == imagePtr) { - masterPtr->instancePtr = imagePtr->nextPtr; + modelPtr->instancePtr = imagePtr->nextPtr; } else { while (prevPtr->nextPtr != imagePtr) { prevPtr = prevPtr->nextPtr; @@ -692,16 +692,16 @@ Tk_FreeImage( ckfree(imagePtr); /* - * If there are no more instances left for the master, and if the master - * image has been deleted, then delete the master too. + * If there are no more instances left for the model, and if the model + * image has been deleted, then delete the model too. */ - if ((masterPtr->typePtr == NULL) && (masterPtr->instancePtr == NULL)) { - if (masterPtr->hPtr != NULL) { - Tcl_DeleteHashEntry(masterPtr->hPtr); + if ((modelPtr->typePtr == NULL) && (modelPtr->instancePtr == NULL)) { + if (modelPtr->hPtr != NULL) { + Tcl_DeleteHashEntry(modelPtr->hPtr); } - Tcl_Release(masterPtr->winPtr); - ckfree(masterPtr); + Tcl_Release(modelPtr->winPtr); + ckfree(modelPtr); } } @@ -741,9 +741,9 @@ Tk_PostscriptImage( GC newGC; XGCValues gcValues; - if (imagePtr->masterPtr->typePtr == NULL) { + if (imagePtr->modelPtr->typePtr == NULL) { /* - * No master for image, so nothing to display on postscript. + * No model for image, so nothing to display on postscript. */ return TCL_OK; @@ -754,9 +754,9 @@ Tk_PostscriptImage( * otherwise go on with generic code. */ - if (imagePtr->masterPtr->typePtr->postscriptProc != NULL) { - return imagePtr->masterPtr->typePtr->postscriptProc( - imagePtr->masterPtr->masterData, interp, tkwin, psinfo, + if (imagePtr->modelPtr->typePtr->postscriptProc != NULL) { + return imagePtr->modelPtr->typePtr->postscriptProc( + imagePtr->modelPtr->modelData, interp, tkwin, psinfo, x, y, width, height, prepass); } @@ -837,9 +837,9 @@ Tk_RedrawImage( { Image *imagePtr = (Image *) image; - if (imagePtr->masterPtr->typePtr == NULL) { + if (imagePtr->modelPtr->typePtr == NULL) { /* - * No master for image, so nothing to display. + * No model for image, so nothing to display. */ return; @@ -859,13 +859,13 @@ Tk_RedrawImage( drawableY -= imageY; imageY = 0; } - if ((imageX + width) > imagePtr->masterPtr->width) { - width = imagePtr->masterPtr->width - imageX; + if ((imageX + width) > imagePtr->modelPtr->width) { + width = imagePtr->modelPtr->width - imageX; } - if ((imageY + height) > imagePtr->masterPtr->height) { - height = imagePtr->masterPtr->height - imageY; + if ((imageY + height) > imagePtr->modelPtr->height) { + height = imagePtr->modelPtr->height - imageY; } - imagePtr->masterPtr->typePtr->displayProc(imagePtr->instanceData, + imagePtr->modelPtr->typePtr->displayProc(imagePtr->instanceData, imagePtr->display, drawable, imageX, imageY, width, height, drawableX, drawableY); } @@ -895,8 +895,8 @@ Tk_SizeOfImage( { Image *imagePtr = (Image *) image; - *widthPtr = imagePtr->masterPtr->width; - *heightPtr = imagePtr->masterPtr->height; + *widthPtr = imagePtr->modelPtr->width; + *heightPtr = imagePtr->modelPtr->height; } /* @@ -933,7 +933,7 @@ Tk_DeleteImage( if (hPtr == NULL) { return; } - DeleteImage(Tcl_GetHashValue(hPtr)); + DeleteImage((ImageModel *)Tcl_GetHashValue(hPtr)); } /* @@ -948,7 +948,7 @@ Tk_DeleteImage( * * Side effects: * The connection is dropped between instances of this image and an image - * master. Image instances will redisplay themselves as empty areas, but + * model. Image instances will redisplay themselves as empty areas, but * existing instances will not be deleted. * *---------------------------------------------------------------------- @@ -956,31 +956,31 @@ Tk_DeleteImage( static void DeleteImage( - ImageModel *masterPtr) /* Pointer to main data structure for image. */ + ImageModel *modelPtr) /* Pointer to main data structure for image. */ { Image *imagePtr; Tk_ImageType *typePtr; - typePtr = masterPtr->typePtr; - masterPtr->typePtr = NULL; + typePtr = modelPtr->typePtr; + modelPtr->typePtr = NULL; if (typePtr != NULL) { - for (imagePtr = masterPtr->instancePtr; imagePtr != NULL; + for (imagePtr = modelPtr->instancePtr; imagePtr != NULL; imagePtr = imagePtr->nextPtr) { typePtr->freeProc(imagePtr->instanceData, imagePtr->display); imagePtr->changeProc(imagePtr->widgetClientData, 0, 0, - masterPtr->width, masterPtr->height, masterPtr->width, - masterPtr->height); + modelPtr->width, modelPtr->height, modelPtr->width, + modelPtr->height); } - typePtr->deleteProc(masterPtr->masterData); + typePtr->deleteProc(modelPtr->modelData); } - if (masterPtr->instancePtr == NULL) { - if (masterPtr->hPtr != NULL) { - Tcl_DeleteHashEntry(masterPtr->hPtr); + if (modelPtr->instancePtr == NULL) { + if (modelPtr->hPtr != NULL) { + Tcl_DeleteHashEntry(modelPtr->hPtr); } - Tcl_Release(masterPtr->winPtr); - ckfree(masterPtr); + Tcl_Release(modelPtr->winPtr); + ckfree(modelPtr); } else { - masterPtr->deleted = 1; + modelPtr->deleted = 1; } } @@ -1004,16 +1004,16 @@ DeleteImage( static void EventuallyDeleteImage( - ImageModel *masterPtr, /* Pointer to main data structure for image. */ + ImageModel *modelPtr, /* Pointer to main data structure for image. */ int forgetImageHashNow) /* Flag to say whether the hash table is about * to vanish. */ { if (forgetImageHashNow) { - masterPtr->hPtr = NULL; + modelPtr->hPtr = NULL; } - if (!masterPtr->deleted) { - masterPtr->deleted = 1; - Tcl_EventuallyFree(masterPtr, (Tcl_FreeProc *) DeleteImage); + if (!modelPtr->deleted) { + modelPtr->deleted = 1; + Tcl_EventuallyFree(modelPtr, (Tcl_FreeProc *) DeleteImage); } } @@ -1045,7 +1045,7 @@ TkDeleteAllImages( for (hPtr = Tcl_FirstHashEntry(&mainPtr->imageTable, &search); hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) { - EventuallyDeleteImage(Tcl_GetHashValue(hPtr), 1); + EventuallyDeleteImage((ImageModel *)Tcl_GetHashValue(hPtr), 1); } Tcl_DeleteHashTable(&mainPtr->imageTable); } @@ -1056,7 +1056,7 @@ TkDeleteAllImages( * Tk_GetImageModelData -- * * Given the name of an image, this function returns the type of the - * image and the clientData associated with its master. + * image and the clientData associated with its model. * * Results: * If there is no image by the given name, then NULL is returned and a @@ -1081,20 +1081,20 @@ Tk_GetImageModelData( { TkWindow *winPtr = (TkWindow *) Tk_MainWindow(interp); Tcl_HashEntry *hPtr; - ImageModel *masterPtr; + ImageModel *modelPtr; hPtr = Tcl_FindHashEntry(&winPtr->mainPtr->imageTable, name); if (hPtr == NULL) { *typePtrPtr = NULL; return NULL; } - masterPtr = Tcl_GetHashValue(hPtr); - if (masterPtr->deleted) { + modelPtr = (ImageModel *)Tcl_GetHashValue(hPtr); + if (modelPtr->deleted) { *typePtrPtr = NULL; return NULL; } - *typePtrPtr = masterPtr->typePtr; - return masterPtr->masterData; + *typePtrPtr = modelPtr->typePtr; + return modelPtr->modelData; } /* @@ -1118,7 +1118,6 @@ Tk_GetImageModelData( *---------------------------------------------------------------------- */ -/*ARGSUSED*/ void Tk_SetTSOrigin( Tk_Window tkwin, diff --git a/generic/tkImgBmap.c b/generic/tkImgBmap.c index 8d51671..c6ab05d 100644 --- a/generic/tkImgBmap.c +++ b/generic/tkImgBmap.c @@ -14,7 +14,7 @@ #include "tkInt.h" /* - * The following data structure represents the master for a bitmap + * The following data structure represents the model for a bitmap * image: */ @@ -40,7 +40,7 @@ typedef struct BitmapModel { char *maskDataString; /* Value of -maskdata option (malloc'ed). */ struct BitmapInstance *instancePtr; /* First in list of all instances associated - * with this master. */ + * with this model. */ } BitmapModel; /* @@ -51,7 +51,7 @@ typedef struct BitmapModel { typedef struct BitmapInstance { int refCount; /* Number of instances that share this data * structure. */ - BitmapModel *modelPtr; /* Pointer to master for image. */ + BitmapModel *modelPtr; /* Pointer to model for image. */ Tk_Window tkwin; /* Window in which the instances will be * displayed. */ XColor *fg; /* Foreground color for displaying image. */ @@ -322,8 +322,8 @@ ImgBmapConfigureModel( * ImgBmapConfigureInstance -- * * This procedure is called to create displaying information for a bitmap - * image instance based on the configuration information in the master. - * It is invoked both when new instances are created and when the master + * image instance based on the configuration information in the model. + * It is invoked both when new instances are created and when the model * is reconfigured. * * Results: @@ -751,7 +751,7 @@ NextBitmapWord( static int ImgBmapCmd( - ClientData clientData, /* Information about the image master. */ + ClientData clientData, /* Information about the image model. */ Tcl_Interp *interp, /* Current interpreter. */ int objc, /* Number of arguments. */ Tcl_Obj *const objv[]) /* Argument objects. */ @@ -816,10 +816,10 @@ static ClientData ImgBmapGet( Tk_Window tkwin, /* Window in which the instance will be * used. */ - ClientData masterData) /* Pointer to our master structure for the + ClientData modelData) /* Pointer to our model structure for the * image. */ { - BitmapModel *modelPtr = masterData; + BitmapModel *modelPtr = modelData; BitmapInstance *instancePtr; /* @@ -993,7 +993,7 @@ ImgBmapFree( * * ImgBmapDelete -- * - * This procedure is called by the image code to delete the master + * This procedure is called by the image code to delete the model * structure for an image. * * Results: @@ -1007,10 +1007,10 @@ ImgBmapFree( static void ImgBmapDelete( - ClientData masterData) /* Pointer to BitmapModel structure for + ClientData modelData) /* Pointer to BitmapModel structure for * image. Must not have any more instances. */ { - BitmapModel *modelPtr = masterData; + BitmapModel *modelPtr = modelData; if (modelPtr->instancePtr != NULL) { Tcl_Panic("tried to delete bitmap image when instances still exist"); diff --git a/generic/tkStubInit.c b/generic/tkStubInit.c index cfca9ca..e637f8e 100644 --- a/generic/tkStubInit.c +++ b/generic/tkStubInit.c @@ -59,7 +59,7 @@ MODULE_SCOPE const TkStubs tkStubs; #define TkGenWMConfigureEvent_ TkGenWMConfigureEvent #define TkGenerateActivateEvents_ TkGenerateActivateEvents -#if !defined(MAC_OSX_TK) +#if !defined(MAC_OSX_TK) && defined(MAC_OSX_TCL) # undef TkpWillDrawWidget # undef TkpRedrawWidget static int diff --git a/generic/ttk/ttkManager.c b/generic/ttk/ttkManager.c index 42f1812..8cad58c 100644 --- a/generic/ttk/ttkManager.c +++ b/generic/ttk/ttkManager.c @@ -463,7 +463,7 @@ int Ttk_GetContentIndexFromObj( return TCL_OK; } - /* Try interpreting as a slave window name; + /* Try interpreting as a window name; */ if ((*string == '.') && (tkwin = Tk_NameToWindow(interp, string, mgr->window))) { @@ -505,28 +505,28 @@ void Ttk_ReorderContent(Ttk_Manager *mgr, int fromIndex, int toIndex) /* ASSERT: fromIndex == toIndex */ mgr->content[fromIndex] = moved; - /* Schedule a relayout. In general, rearranging slaves + /* Schedule a relayout. In general, rearranging content * may also change the size: */ ScheduleUpdate(mgr, MGR_RESIZE_REQUIRED); } -/* ++ Ttk_Maintainable(interp, slave, container) -- +/* ++ Ttk_Maintainable(interp, window, container) -- * Utility routine. Verifies that 'container' may be used to maintain - * the geometry of 'slave' via Tk_MaintainGeometry: + * the geometry of 'window' via Tk_MaintainGeometry: * - * + 'container' is either 'slave's parent -OR- - * + 'container is a descendant of 'slave's parent. - * + 'slave' is not a toplevel window - * + 'slave' belongs to the same toplevel as 'container' + * + 'container' is either 'window's parent -OR- + * + 'container is a descendant of 'window's parent. + * + 'window' is not a toplevel window + * + 'window' belongs to the same toplevel as 'container' * * Returns: 1 if OK; otherwise 0, leaving an error message in 'interp'. */ -int Ttk_Maintainable(Tcl_Interp *interp, Tk_Window slave, Tk_Window container) +int Ttk_Maintainable(Tcl_Interp *interp, Tk_Window window, Tk_Window container) { - Tk_Window ancestor = container, parent = Tk_Parent(slave); + Tk_Window ancestor = container, parent = Tk_Parent(window); - if (Tk_IsTopLevel(slave) || slave == container) { + if (Tk_IsTopLevel(window) || window == container) { goto badWindow; } @@ -541,7 +541,7 @@ int Ttk_Maintainable(Tcl_Interp *interp, Tk_Window slave, Tk_Window container) badWindow: Tcl_SetObjResult(interp, Tcl_ObjPrintf("can't add %s as slave of %s", - Tk_PathName(slave), Tk_PathName(container))); + Tk_PathName(window), Tk_PathName(container))); Tcl_SetErrorCode(interp, "TTK", "GEOMETRY", "MAINTAINABLE", NULL); return 0; } diff --git a/macosx/tkMacOSXMenu.c b/macosx/tkMacOSXMenu.c index 9ba7ce8..8005517 100644 --- a/macosx/tkMacOSXMenu.c +++ b/macosx/tkMacOSXMenu.c @@ -1165,12 +1165,12 @@ CheckForSpecialMenu( cascadeEntryPtr = cascadeEntryPtr->nextCascadePtr) { if (cascadeEntryPtr->menuPtr->menuType == MENUBAR && cascadeEntryPtr->menuPtr->masterMenuPtr->tkwin) { - TkMenu *masterMenuPtr = cascadeEntryPtr->menuPtr->masterMenuPtr; + TkMenu *mainMenuPtr = cascadeEntryPtr->menuPtr->masterMenuPtr; int i = 0; Tcl_DString ds; Tcl_DStringInit(&ds); - Tcl_DStringAppend(&ds, Tk_PathName(masterMenuPtr->tkwin), -1); + Tcl_DStringAppend(&ds, Tk_PathName(mainMenuPtr->tkwin), -1); while (specialMenus[i].name) { Tcl_DStringAppend(&ds, specialMenus[i].name, specialMenus[i].len); diff --git a/macosx/tkMacOSXWm.c b/macosx/tkMacOSXWm.c index 3b843b9..6b7871f 100644 --- a/macosx/tkMacOSXWm.c +++ b/macosx/tkMacOSXWm.c @@ -674,7 +674,7 @@ TkWmNewWindow( wmPtr->reparent = None; wmPtr->titleUid = NULL; wmPtr->iconName = NULL; - wmPtr->master = NULL; + wmPtr->container = NULL; wmPtr->hints.flags = InputHint | StateHint; wmPtr->hints.input = True; wmPtr->hints.initial_state = NormalState; @@ -950,7 +950,7 @@ TkWmDeadWindow( if (containerPtr == winPtr) { wmPtr2 = winPtr2->wmInfoPtr; - wmPtr2->master = NULL; + wmPtr2->container = NULL; } } @@ -2353,7 +2353,7 @@ WmIconifyCmd( Tcl_SetErrorCode(interp, "TK", "WM", "ICONIFY", "OVERRIDE_REDIRECT", NULL); return TCL_ERROR; - } else if (wmPtr->master != NULL) { + } else if (wmPtr->container != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "can't iconify \"%s\": it is a transient", winPtr->pathName)); Tcl_SetErrorCode(interp, "TK", "WM", "ICONIFY", "TRANSIENT", NULL); @@ -3493,7 +3493,7 @@ WmStateCmd( "OVERRIDE_REDIRECT", NULL); return TCL_ERROR; } - if (wmPtr->master != NULL) { + if (wmPtr->container != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "can't iconify \"%s\": it is a transient", winPtr->pathName)); @@ -3620,9 +3620,9 @@ WmTransientCmd( return TCL_ERROR; } if (objc == 3) { - if (wmPtr->master != NULL) { + if (wmPtr->container != NULL) { Tcl_SetObjResult(interp, - Tcl_NewStringObj(Tk_PathName(wmPtr->master), -1)); + Tcl_NewStringObj(Tk_PathName(wmPtr->container), -1)); } return TCL_OK; } @@ -3665,7 +3665,7 @@ WmTransientCmd( } for (w = containerPtr; w != NULL && w->wmInfoPtr != NULL; - w = (TkWindow *)w->wmInfoPtr->master) { + w = (TkWindow *)w->wmInfoPtr->container) { if (w == winPtr) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "setting \"%s\" as master creates a transient/master cycle", @@ -3701,7 +3701,7 @@ WmTransientCmd( transient->flags |= WITHDRAWN_BY_CONTAINER; } - wmPtr->master = (Tk_Window)containerPtr; + wmPtr->container = (Tk_Window)containerPtr; } ApplyContainerOverrideChanges(winPtr, NULL); return TCL_OK; @@ -3734,15 +3734,15 @@ RemoveTransient( TkWindow *containerPtr; Transient *transPtr, *temp; - if (wmPtr == NULL || wmPtr->master == NULL) { + if (wmPtr == NULL || wmPtr->container == NULL) { return; } - containerPtr = (TkWindow *)wmPtr->master; + containerPtr = (TkWindow *)wmPtr->container; wmPtr2 = containerPtr->wmInfoPtr; if (wmPtr2 == NULL) { return; } - wmPtr->master= NULL; + wmPtr->container= NULL; transPtr = wmPtr2->transientPtr; while (transPtr != NULL) { if (transPtr->winPtr != winPtr) { @@ -5375,7 +5375,7 @@ TkGetTransientMaster( TkWindow *winPtr) { if (winPtr->wmInfoPtr != NULL) { - return (Tk_Window)winPtr->wmInfoPtr->master; + return (Tk_Window)winPtr->wmInfoPtr->container; } return NULL; } @@ -6647,7 +6647,7 @@ TkMacOSXApplyWindowAttributes( WmInfo *wmPtr = winPtr->wmInfoPtr; ApplyWindowAttributeFlagChanges(winPtr, macWindow, 0, 0, 0, 1); - if (wmPtr->master != NULL || winPtr->atts.override_redirect) { + if (wmPtr->container != NULL || winPtr->atts.override_redirect) { ApplyContainerOverrideChanges(winPtr, macWindow); } } @@ -6781,7 +6781,7 @@ ApplyWindowAttributeFlagChanges( */ if ((winPtr->atts.override_redirect) || - (wmPtr->master != NULL) || + (wmPtr->container != NULL) || (winPtr->wmInfoPtr->macClass == kHelpWindowClass)) { b |= (NSWindowCollectionBehaviorCanJoinAllSpaces | NSWindowCollectionBehaviorFullScreenAuxiliary); @@ -6923,7 +6923,7 @@ ApplyContainerOverrideChanges( if (wmPtr->hints.initial_state == NormalState) { [macWindow orderFront:nil]; } - if (wmPtr->master != NULL) { + if (wmPtr->container != NULL) { wmPtr->flags |= WM_TOPMOST; } else { wmPtr->flags &= ~WM_TOPMOST; @@ -6939,8 +6939,8 @@ ApplyContainerOverrideChanges( [macWindow setExcludedFromWindowsMenu:NO]; wmPtr->flags &= ~WM_TOPMOST; } - if (wmPtr->master != None) { - TkWindow *containerWinPtr = (TkWindow *)wmPtr->master; + if (wmPtr->container != None) { + TkWindow *containerWinPtr = (TkWindow *)wmPtr->container; if (containerWinPtr && (containerWinPtr->window != None) && TkMacOSXHostToplevelExists(containerWinPtr)) { diff --git a/macosx/tkMacOSXWm.h b/macosx/tkMacOSXWm.h index 6696b05..19bf379 100644 --- a/macosx/tkMacOSXWm.h +++ b/macosx/tkMacOSXWm.h @@ -66,7 +66,7 @@ typedef struct TkWmInfo { Tk_Uid titleUid; /* Title to display in window caption. If NULL, * use name of widget. */ char *iconName; /* Name to display in icon. */ - Tk_Window master; /* Container window for TRANSIENT_FOR property, + Tk_Window container; /* Container window for TRANSIENT_FOR property, * or None. */ XWMHints hints; /* Various pieces of information for window * manager. */ diff --git a/tests/focus.test b/tests/focus.test index 3d9d7c3..7ce2df1 100644 --- a/tests/focus.test +++ b/tests/focus.test @@ -624,7 +624,7 @@ fixfocus test focus-6.1 {miscellaneous - embedded application in same process} -constraints { unix testwrapper } -setup { - eval interp delete [interp children] + eval interp delete [interp slaves] } -body { toplevel .t wm geometry .t +0+0 diff --git a/tests/safe.test b/tests/safe.test index a31e029..5a2cd26 100644 --- a/tests/safe.test +++ b/tests/safe.test @@ -199,7 +199,7 @@ test safe-5.1 {loading Tk in safe interps without parent's clearance} -body { interp eval $i {load {} Tk} } -cleanup { safe::interpDelete $i -} -returnCodes error -result {load of binary library for package Tk failed: not allowed} +} -returnCodes error -match glob -result {*not allowed} test safe-5.2 {multi-level Tk loading with clearance} -setup { set safeParent [safe::interpCreate] } -body { diff --git a/tests/ttk/combobox.test b/tests/ttk/combobox.test index 45fe0fc..c14db9b 100644 --- a/tests/ttk/combobox.test +++ b/tests/ttk/combobox.test @@ -38,18 +38,18 @@ test combobox-2.3 "current -- change value" -body { .cb current } -result 1 -test combobox-2.4 "current -- value not in list" -body { +test combobox-2.4 "current -- value not in list" -body { .cb set "z" .cb current } -result -1 -test combobox-2.5 "current -- set to end index" -body { +test combobox-2.5 "current -- set to end index" -body { .cb configure -values [list a b c d e thelastone] .cb current end .cb get } -result thelastone -test combobox-2.6 "current -- set to unknown index" -body { +test combobox-2.6 "current -- set to unknown index" -body { .cb configure -values [list a b c d e] .cb current notanindex } -returnCodes error -result {Incorrect index notanindex} @@ -58,7 +58,7 @@ test combobox-2.end "Cleanup" -body { destroy .cb } test combobox-3 "Read postoffset value dynamically from current style" -body { ttk::combobox .cb -values [list a b c] -style "DerivedStyle.TCombobox" - pack .cb -expand true -fill both + pack .cb -expand true -fill both ttk::style configure DerivedStyle.TCombobox -postoffset [list 25 0 0 0] ttk::combobox::Post .cb expr {[winfo rootx .cb.popdown] - [winfo rootx .cb]} diff --git a/tests/ttk/image.test b/tests/ttk/image.test index a55f7f8..5e48d5c 100644 --- a/tests/ttk/image.test +++ b/tests/ttk/image.test @@ -23,7 +23,7 @@ test image-2.0 "Deletion of displayed image (label)" -setup { } -cleanup { destroy .ttk_image20 } -result {} - + test image-2.1 "Deletion of displayed image (checkbutton)" -setup { image create photo test.image -width 10 -height 10 } -body { diff --git a/tests/ttk/panedwindow.test b/tests/ttk/panedwindow.test index f72ffb8..ad2865c 100644 --- a/tests/ttk/panedwindow.test +++ b/tests/ttk/panedwindow.test @@ -110,8 +110,8 @@ test panedwindow-2.end "Cleanup" -body { destroy .pw } # test panedwindow-3.0 "configure pane" -body { ttk::panedwindow .pw - .pw add [listbox .pw.lb1] - .pw add [listbox .pw.lb2] + .pw add [listbox .pw.lb1] + .pw add [listbox .pw.lb2] .pw pane 1 -weight 2 .pw pane 1 -weight } -result 2 @@ -253,7 +253,7 @@ test paned-propagation-setup "Setup." -body { frame .pw.f2 -width 100 -height 50 list [winfo reqwidth .pw.f1] [winfo reqheight .pw.f1] -} -result [list 100 50] +} -result [list 100 50] test paned-propagation-1 "Initial request size" -body { .pw add .pw.f1 diff --git a/tests/ttk/scrollbar.test b/tests/ttk/scrollbar.test index 903328e..0743def 100644 --- a/tests/ttk/scrollbar.test +++ b/tests/ttk/scrollbar.test @@ -18,8 +18,8 @@ test scrollbar-swapout-1 "Don't use core scrollbars on OSX..." \ } -body { ttk::scrollbar .sb -command "yadda" list [winfo class .sb] [.sb cget -command] -} -result [list TScrollbar yadda] -cleanup { - destroy .sb +} -result [list TScrollbar yadda] -cleanup { + destroy .sb } test scrollbar-swapout-2 "... regardless of whether -style ..." \ @@ -28,7 +28,7 @@ test scrollbar-swapout-2 "... regardless of whether -style ..." \ } -body { ttk::style layout Vertical.Custom.TScrollbar \ [ttk::style layout Vertical.TScrollbar] ; # See #1833339 - ttk::scrollbar .sb -command "yadda" -style Custom.TScrollbar + ttk::scrollbar .sb -command "yadda" -style Custom.TScrollbar list [winfo class .sb] [.sb cget -command] [.sb cget -style] } -result [list TScrollbar yadda Custom.TScrollbar] -cleanup { destroy .sb @@ -37,7 +37,7 @@ test scrollbar-swapout-2 "... regardless of whether -style ..." \ test scrollbar-swapout-3 "... or -class is specified." -constraints { coreScrollbar } -body { - ttk::scrollbar .sb -command "yadda" -class Custom.TScrollbar + ttk::scrollbar .sb -command "yadda" -class Custom.TScrollbar list [winfo class .sb] [.sb cget -command] } -result [list Custom.TScrollbar yadda] -cleanup { destroy .sb diff --git a/tests/ttk/treetags.test b/tests/ttk/treetags.test index 7f26e2f..f91673f 100644 --- a/tests/ttk/treetags.test +++ b/tests/ttk/treetags.test @@ -105,7 +105,7 @@ test treetags-1.8 "tag names" -body { } -result [list tag1 tag2 tag3] test treetags-1.9 "tag names - tag added to item" -body { - $tv item item1 -tags tag4 + $tv item item1 -tags tag4 lsort [$tv tag names] } -result [list tag1 tag2 tag3 tag4] @@ -201,12 +201,12 @@ test treetags-3.4 "stomp tags in tag binding procedure" -body { set result [list] $tv tag bind rm1 <> { lappend ::result rm1 [%W focus] <> } $tv tag bind rm2 <> { - lappend ::result rm2 [%W focus] <> + lappend ::result rm2 [%W focus] <> %W item [%W focus] -tags {tag1} } $tv tag bind rm3 <> { lappend ::result rm3 [%W focus] <> } - $tv item item1 -tags {rm1 rm2 rm3} + $tv item item1 -tags {rm1 rm2 rm3} $tv focus item1 event generate $tv <> set result diff --git a/tests/ttk/treeview.test b/tests/ttk/treeview.test index 0ad0443..f068243 100644 --- a/tests/ttk/treeview.test +++ b/tests/ttk/treeview.test @@ -729,7 +729,7 @@ test treeview-3085489-2 "tag remove, no -tags" -setup { test treeview-368fa4561e "indicators cannot be clicked on leafs" -setup { pack [ttk::treeview .tv] - .tv insert {} end -id foo -text "<-- (1) Click the blank space to my left" + .tv insert {} end -id foo -text "<-- (1) Click the blank space to my left" update } -body { foreach {x y w h} [.tv bbox foo #0] {} @@ -748,7 +748,7 @@ test treeview-368fa4561e "indicators cannot be clicked on leafs" -setup { test treeview-ce470f20fd-1 "dragging further than the right edge of the treeview is allowed" -setup { pack [ttk::treeview .tv] - .tv heading #0 -text "Drag my right edge -->" + .tv heading #0 -text "Drag my right edge -->" update } -body { set res [.tv column #0 -width] @@ -818,7 +818,7 @@ test treeview-ce470f20fd-4 "changing -stretch resizes columns" -setup { update idletasks ; # redisplay treeview } -body { # only some columns are displayed (and in a different order than declared - # in -columns), a non-displayed column becomes stretchable --> nothing + # in -columns), a non-displayed column becomes stretchable --> nothing # happens set origTreeWidth [winfo width .tv] set res [list [.tv column bar -width] [.tv column colA -width]] diff --git a/tests/ttk/ttk.test b/tests/ttk/ttk.test index aba3eba..eb320e9 100644 --- a/tests/ttk/ttk.test +++ b/tests/ttk/ttk.test @@ -207,7 +207,7 @@ test ttk-2.8 "bug 3223850: button state disabled during click" -setup { set ttk28 {} pack [ttk::button .b -command {set ::ttk28 failed}] update -} -body { +} -body { bind .b {after 0 {.b configure -state disabled}} after 1 {event generate .b } after 20 {event generate .b } diff --git a/tests/ttk/validate.test b/tests/ttk/validate.test index 417deac..5755943 100644 --- a/tests/ttk/validate.test +++ b/tests/ttk/validate.test @@ -161,7 +161,7 @@ test validate-1.18 {entry widget validation} -constraints coreEntry -body { list [.e cget -validate] $::vVals } -result {none {.e -1 -1 nextdata newdata {} all forced}} # DIFFERENCE: ttk::entry doesn't validate when setting linked -variable -# DIFFERENCE: ttk::entry doesn't disable validation +# DIFFERENCE: ttk::entry doesn't disable validation proc doval {W d i P s S v V} { set ::vVals [list $W $d $i $P $s $S $v $V] diff --git a/unix/Makefile.in b/unix/Makefile.in index 0fbfb5d..86ea005 100644 --- a/unix/Makefile.in +++ b/unix/Makefile.in @@ -1531,7 +1531,7 @@ rpm: all # # Target to create a proper Tk distribution from information in the -# master source directory. DISTDIR must be defined to indicate where +# source directory. DISTDIR must be defined to indicate where # to put the distribution. DISTDIR must be an absolute path name. # diff --git a/unix/tkUnixWm.c b/unix/tkUnixWm.c index 2c9e9dd..00893f2 100644 --- a/unix/tkUnixWm.c +++ b/unix/tkUnixWm.c @@ -82,7 +82,7 @@ typedef struct TkWmInfo { * (corresponds to hints.window_group). * Malloc-ed. Note: this field doesn't get * updated if leader is destroyed. */ - TkWindow *masterPtr; /* Master window for TRANSIENT_FOR property, + TkWindow *containerPtr; /* Container window for TRANSIENT_FOR property, * or NULL. */ Tk_Window icon; /* Window to use as icon for this window, or * NULL. */ @@ -259,7 +259,7 @@ typedef struct TkWmInfo { * window (controlled by "wm resizable" command). * WM_WITHDRAWN - non-zero means that this window has explicitly * been withdrawn. If it's a transient, it should - * not mirror state changes in the master. + * not mirror state changes in the container. */ #define WM_NEVER_MAPPED 1 @@ -571,7 +571,7 @@ TkWmNewWindow( memset(wmPtr, 0, sizeof(WmInfo)); wmPtr->winPtr = winPtr; wmPtr->reparent = None; - wmPtr->masterPtr = NULL; + wmPtr->containerPtr = NULL; wmPtr->numTransients = 0; wmPtr->hints.flags = InputHint | StateHint; wmPtr->hints.input = True; @@ -684,12 +684,12 @@ TkWmMapWindow( UpdateTitle(winPtr); UpdatePhotoIcon(winPtr); - if (wmPtr->masterPtr != NULL) { + if (wmPtr->containerPtr != NULL) { /* - * Don't map a transient if the master is not mapped. + * Don't map a transient if the container is not mapped. */ - if (!Tk_IsMapped(wmPtr->masterPtr)) { + if (!Tk_IsMapped(wmPtr->containerPtr)) { wmPtr->withdrawn = 1; wmPtr->hints.initial_state = WithdrawnState; } @@ -700,7 +700,7 @@ TkWmMapWindow( */ XSetTransientForHint(winPtr->display, wmPtr->wrapperPtr->window, - wmPtr->masterPtr->wmInfoPtr->wrapperPtr->window); + wmPtr->containerPtr->wmInfoPtr->wrapperPtr->window); } wmPtr->flags |= WM_UPDATE_SIZE_HINTS; @@ -909,16 +909,16 @@ TkWmDeadWindow( } /* - * Reset all transient windows whose master is the dead window. + * Reset all transient windows whose container is the dead window. */ for (wmPtr2 = winPtr->dispPtr->firstWmPtr; wmPtr2 != NULL; wmPtr2 = wmPtr2->nextPtr) { - if (wmPtr2->masterPtr == winPtr) { + if (wmPtr2->containerPtr == winPtr) { wmPtr->numTransients--; - Tk_DeleteEventHandler((Tk_Window) wmPtr2->masterPtr, + Tk_DeleteEventHandler((Tk_Window) wmPtr2->containerPtr, StructureNotifyMask, WmWaitMapProc, wmPtr2->winPtr); - wmPtr2->masterPtr = NULL; + wmPtr2->containerPtr = NULL; if (!(wmPtr2->flags & WM_NEVER_MAPPED)) { XDeleteProperty(winPtr->display, wmPtr2->wrapperPtr->window, Tk_InternAtom((Tk_Window) winPtr, "WM_TRANSIENT_FOR")); @@ -933,19 +933,19 @@ TkWmDeadWindow( } /* ASSERT: numTransients == 0 [Bug 1789819] */ - if (wmPtr->masterPtr != NULL) { - wmPtr2 = wmPtr->masterPtr->wmInfoPtr; + if (wmPtr->containerPtr != NULL) { + wmPtr2 = wmPtr->containerPtr->wmInfoPtr; /* - * If we had a master, tell them that we aren't tied to them anymore + * If we had a container, tell them that we aren't tied to them anymore */ if (wmPtr2 != NULL) { wmPtr2->numTransients--; } - Tk_DeleteEventHandler((Tk_Window) wmPtr->masterPtr, + Tk_DeleteEventHandler((Tk_Window) wmPtr->containerPtr, StructureNotifyMask, WmWaitMapProc, winPtr); - wmPtr->masterPtr = NULL; + wmPtr->containerPtr = NULL; } ckfree(wmPtr); winPtr->wmInfoPtr = NULL; @@ -2220,7 +2220,7 @@ WmIconifyCmd( NULL); return TCL_ERROR; } - if (wmPtr->masterPtr != NULL) { + if (wmPtr->containerPtr != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "can't iconify \"%s\": it is a transient", winPtr->pathName)); @@ -3408,7 +3408,7 @@ WmStateCmd( "OVERRIDE_REDIRECT", NULL); return TCL_ERROR; } - if (wmPtr->masterPtr != NULL) { + if (wmPtr->containerPtr != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "can't iconify \"%s\": it is a transient", winPtr->pathName)); @@ -3532,7 +3532,7 @@ WmTransientCmd( Tcl_Obj *const objv[]) /* Argument objects. */ { register WmInfo *wmPtr = winPtr->wmInfoPtr; - TkWindow *masterPtr = wmPtr->masterPtr, *w; + TkWindow *containerPtr = wmPtr->containerPtr, *w; WmInfo *wmPtr2; if ((objc != 3) && (objc != 4)) { @@ -3540,20 +3540,20 @@ WmTransientCmd( return TCL_ERROR; } if (objc == 3) { - if (masterPtr != NULL) { - Tcl_SetObjResult(interp, TkNewWindowObj((Tk_Window) masterPtr)); + if (containerPtr != NULL) { + Tcl_SetObjResult(interp, TkNewWindowObj((Tk_Window) containerPtr)); } return TCL_OK; } if (Tcl_GetString(objv[3])[0] == '\0') { - if (masterPtr != NULL) { + if (containerPtr != NULL) { /* - * If we had a master, tell them that we aren't tied to them + * If we had a container, tell them that we aren't tied to them * anymore */ - masterPtr->wmInfoPtr->numTransients--; - Tk_DeleteEventHandler((Tk_Window) masterPtr, StructureNotifyMask, + containerPtr->wmInfoPtr->numTransients--; + Tk_DeleteEventHandler((Tk_Window) containerPtr, StructureNotifyMask, WmWaitMapProc, winPtr); /* @@ -3563,22 +3563,22 @@ WmTransientCmd( */ } - wmPtr->masterPtr = NULL; + wmPtr->containerPtr = NULL; } else { - Tk_Window masterWin; + Tk_Window container; - if (TkGetWindowFromObj(interp, tkwin, objv[3], &masterWin)!=TCL_OK) { + if (TkGetWindowFromObj(interp, tkwin, objv[3], &container)!=TCL_OK) { return TCL_ERROR; } - masterPtr = (TkWindow *) masterWin; - while (!Tk_TopWinHierarchy(masterPtr)) { + containerPtr = (TkWindow *) container; + while (!Tk_TopWinHierarchy(containerPtr)) { /* - * Ensure that the master window is actually a Tk toplevel. + * Ensure that the container window is actually a Tk toplevel. */ - masterPtr = masterPtr->parentPtr; + containerPtr = containerPtr->parentPtr; } - Tk_MakeWindowExist((Tk_Window) masterPtr); + Tk_MakeWindowExist((Tk_Window) containerPtr); if (wmPtr->iconFor != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( @@ -3588,7 +3588,7 @@ WmTransientCmd( return TCL_ERROR; } - wmPtr2 = masterPtr->wmInfoPtr; + wmPtr2 = containerPtr->wmInfoPtr; if (wmPtr2->wrapperPtr == NULL) { CreateWrapper(wmPtr2); } @@ -3601,39 +3601,39 @@ WmTransientCmd( return TCL_ERROR; } - for (w = masterPtr; w != NULL && w->wmInfoPtr != NULL; - w = (TkWindow *)w->wmInfoPtr->masterPtr) { + for (w = containerPtr; w != NULL && w->wmInfoPtr != NULL; + w = (TkWindow *)w->wmInfoPtr->containerPtr) { if (w == winPtr) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "setting \"%s\" as master creates a transient/master cycle", - Tk_PathName(masterPtr))); + Tk_PathName(containerPtr))); Tcl_SetErrorCode(interp, "TK", "WM", "TRANSIENT", "SELF", NULL); return TCL_ERROR; } } - if (masterPtr != wmPtr->masterPtr) { + if (containerPtr != wmPtr->containerPtr) { /* - * Remove old master map/unmap binding before setting the new - * master. The event handler will ensure that transient states - * reflect the state of the master. + * Remove old container map/unmap binding before setting the new + * container. The event handler will ensure that transient states + * reflect the state of the container. */ - if (wmPtr->masterPtr != NULL) { - wmPtr->masterPtr->wmInfoPtr->numTransients--; - Tk_DeleteEventHandler((Tk_Window) wmPtr->masterPtr, + if (wmPtr->containerPtr != NULL) { + wmPtr->containerPtr->wmInfoPtr->numTransients--; + Tk_DeleteEventHandler((Tk_Window) wmPtr->containerPtr, StructureNotifyMask, WmWaitMapProc, winPtr); } - masterPtr->wmInfoPtr->numTransients++; - Tk_CreateEventHandler((Tk_Window) masterPtr, + containerPtr->wmInfoPtr->numTransients++; + Tk_CreateEventHandler((Tk_Window) containerPtr, StructureNotifyMask, WmWaitMapProc, winPtr); - wmPtr->masterPtr = masterPtr; + wmPtr->containerPtr = containerPtr; } } if (!(wmPtr->flags & WM_NEVER_MAPPED)) { - if (wmPtr->masterPtr != NULL && !Tk_IsMapped(wmPtr->masterPtr)) { + if (wmPtr->containerPtr != NULL && !Tk_IsMapped(wmPtr->containerPtr)) { if (TkpWmSetState(winPtr, WithdrawnState) == 0) { Tcl_SetObjResult(interp, Tcl_NewStringObj( "couldn't send withdraw message to window manager", @@ -3642,10 +3642,10 @@ WmTransientCmd( return TCL_ERROR; } } else { - if (wmPtr->masterPtr != NULL) { + if (wmPtr->containerPtr != NULL) { XSetTransientForHint(winPtr->display, wmPtr->wrapperPtr->window, - wmPtr->masterPtr->wmInfoPtr->wrapperPtr->window); + wmPtr->containerPtr->wmInfoPtr->wrapperPtr->window); } else { XDeleteProperty(winPtr->display, wmPtr->wrapperPtr->window, Tk_InternAtom((Tk_Window) winPtr,"WM_TRANSIENT_FOR")); @@ -3721,7 +3721,7 @@ WmUpdateGeom( /* * Invoked when a MapNotify or UnmapNotify event is delivered for a toplevel - * that is the master of a transient toplevel. + * that is the container of a transient toplevel. */ static void @@ -3730,9 +3730,9 @@ WmWaitMapProc( XEvent *eventPtr) /* Information about event. */ { TkWindow *winPtr = clientData; - TkWindow *masterPtr = winPtr->wmInfoPtr->masterPtr; + TkWindow *containerPtr = winPtr->wmInfoPtr->containerPtr; - if (masterPtr == NULL) { + if (containerPtr == NULL) { return; } diff --git a/win/Makefile.in b/win/Makefile.in index 43f9c81..c561f61 100644 --- a/win/Makefile.in +++ b/win/Makefile.in @@ -140,9 +140,9 @@ SHARED_LIBRARIES = $(TK_DLL_FILE) $(TK_STUB_LIB_FILE) STATIC_LIBRARIES = $(TK_LIB_FILE) WISH = wish$(VER)${EXESUFFIX} -TKTEST = tktest${EXEEXT} -CAT32 = cat32$(EXEEXT) -MAN2TCL = man2tcl$(EXEEXT) +TKTEST = tktest.exe +CAT32 = cat32.exe +MAN2TCL = man2tcl.exe @SET_MAKE@ @@ -184,7 +184,6 @@ CPPFLAGS = @CPPFLAGS@ LDFLAGS = @LDFLAGS@ @LDFLAGS_DEFAULT@ LDFLAGS_CONSOLE = @LDFLAGS_CONSOLE@ LDFLAGS_WINDOW = @LDFLAGS_WINDOW@ -EXEEXT = @EXEEXT@ OBJEXT = @OBJEXT@ STLIB_LD = @STLIB_LD@ SHLIB_LD = @SHLIB_LD@ @@ -706,7 +705,7 @@ tkWindow.$(OBJEXT): configure Makefile depend: cleanhelp: - $(RM) *.hlp *.cnt *.hpj *.GID *.rtf man2tcl${EXEEXT} + $(RM) *.hlp *.cnt *.hpj *.GID *.rtf man2tcl.exe clean: cleanhelp $(RM) *.lib *.a *.exp *.dll *.res *.${OBJEXT} *~ \#* TAGS a.out diff --git a/win/tkWinWm.c b/win/tkWinWm.c index f7ba611..923a58f 100644 --- a/win/tkWinWm.c +++ b/win/tkWinWm.c @@ -177,7 +177,7 @@ typedef struct TkWmInfo { * (corresponds to hints.window_group). * Malloc-ed. Note: this field doesn't get * updated if leader is destroyed. */ - TkWindow *masterPtr; /* Master window for TRANSIENT_FOR property, + TkWindow *containerPtr; /* Container window for TRANSIENT_FOR property, * or NULL. */ Tk_Window icon; /* Window to use as icon for this window, or * NULL. */ @@ -315,7 +315,7 @@ typedef struct TkWmInfo { * window (controlled by "wm resizable" command). * WM_WITHDRAWN - Non-zero means that this window has explicitly * been withdrawn. If it's a transient, it should - * not mirror state changes in the master. + * not mirror state changes in the container. * WM_FULLSCREEN - Non-zero means that this window has been placed * in the full screen mode. It should be mapped at * 0,0 and be the width and height of the screen. @@ -2054,7 +2054,7 @@ UpdateWrapper( */ parentHWND = GetDesktopWindow(); - if (wmPtr->masterPtr) { + if (wmPtr->containerPtr) { wmPtr->style |= WS_CHILD; } else { wmPtr->style |= WS_POPUP; @@ -2062,10 +2062,10 @@ UpdateWrapper( } else if (wmPtr->flags & WM_FULLSCREEN) { wmPtr->style = WM_FULLSCREEN_STYLE; wmPtr->exStyle = EX_FULLSCREEN_STYLE; - } else if (wmPtr->masterPtr) { + } else if (wmPtr->containerPtr) { wmPtr->style = WM_TRANSIENT_STYLE; wmPtr->exStyle = EX_TRANSIENT_STYLE; - parentHWND = Tk_GetHWND(Tk_WindowId(wmPtr->masterPtr)); + parentHWND = Tk_GetHWND(Tk_WindowId(wmPtr->containerPtr)); if (! ((wmPtr->flags & WM_WIDTH_NOT_RESIZABLE) && (wmPtr->flags & WM_HEIGHT_NOT_RESIZABLE))) { wmPtr->style |= WS_THICKFRAME; @@ -2204,7 +2204,7 @@ UpdateWrapper( if (wmPtr->numTransients > 0) { /* * Unset the current wrapper as the parent for all transient - * children for whom this is the master + * children for whom this is the container */ WmInfo *wmPtr2; @@ -2213,7 +2213,7 @@ UpdateWrapper( state = 0; for (wmPtr2 = winPtr->dispPtr->firstWmPtr; wmPtr2 != NULL; wmPtr2 = wmPtr2->nextPtr) { - if (wmPtr2->masterPtr == winPtr + if (wmPtr2->containerPtr == winPtr && !(wmPtr2->flags & WM_NEVER_MAPPED)) { childStateInfo[state++] = wmPtr2->hints.initial_state; SetParent(TkWinGetHWND(wmPtr2->winPtr->window), NULL); @@ -2292,7 +2292,7 @@ UpdateWrapper( if (childStateInfo) { if (wmPtr->numTransients > 0) { /* - * Reset all transient children for whom this is the master. + * Reset all transient children for whom this is the container. */ WmInfo *wmPtr2; @@ -2300,7 +2300,7 @@ UpdateWrapper( state = 0; for (wmPtr2 = winPtr->dispPtr->firstWmPtr; wmPtr2 != NULL; wmPtr2 = wmPtr2->nextPtr) { - if (wmPtr2->masterPtr == winPtr + if (wmPtr2->containerPtr == winPtr && !(wmPtr2->flags & WM_NEVER_MAPPED)) { UpdateWrapper(wmPtr2->winPtr); TkpWmSetState(wmPtr2->winPtr, childStateInfo[state++]); @@ -2365,10 +2365,10 @@ TkWmMapWindow( if (wmPtr->flags & WM_NEVER_MAPPED) { /* - * Don't map a transient if the master is not mapped. + * Don't map a transient if the container is not mapped. */ - if (wmPtr->masterPtr != NULL && !Tk_IsMapped(wmPtr->masterPtr)) { + if (wmPtr->containerPtr != NULL && !Tk_IsMapped(wmPtr->containerPtr)) { wmPtr->hints.initial_state = WithdrawnState; return; } @@ -2610,17 +2610,17 @@ TkWmDeadWindow( } /* - * Reset all transient windows whose master is the dead window. + * Reset all transient windows whose container is the dead window. */ for (wmPtr2 = winPtr->dispPtr->firstWmPtr; wmPtr2 != NULL; wmPtr2 = wmPtr2->nextPtr) { - if (wmPtr2->masterPtr == winPtr) { + if (wmPtr2->containerPtr == winPtr) { wmPtr->numTransients--; - Tk_DeleteEventHandler((Tk_Window) wmPtr2->masterPtr, + Tk_DeleteEventHandler((Tk_Window) wmPtr2->containerPtr, VisibilityChangeMask|StructureNotifyMask, WmWaitVisibilityOrMapProc, wmPtr2->winPtr); - wmPtr2->masterPtr = NULL; + wmPtr2->containerPtr = NULL; if ((wmPtr2->wrapper != NULL) && !(wmPtr2->flags & (WM_NEVER_MAPPED))) { UpdateWrapper(wmPtr2->winPtr); @@ -2670,20 +2670,20 @@ TkWmDeadWindow( if (wmPtr->flags & WM_UPDATE_PENDING) { Tcl_CancelIdleCall(UpdateGeometryInfo, winPtr); } - if (wmPtr->masterPtr != NULL) { - wmPtr2 = wmPtr->masterPtr->wmInfoPtr; + if (wmPtr->containerPtr != NULL) { + wmPtr2 = wmPtr->containerPtr->wmInfoPtr; /* - * If we had a master, tell them that we aren't tied to them anymore. + * If we had a container, tell them that we aren't tied to them anymore. */ if (wmPtr2 != NULL) { wmPtr2->numTransients--; } - Tk_DeleteEventHandler((Tk_Window) wmPtr->masterPtr, + Tk_DeleteEventHandler((Tk_Window) wmPtr->containerPtr, VisibilityChangeMask|StructureNotifyMask, WmWaitVisibilityOrMapProc, winPtr); - wmPtr->masterPtr = NULL; + wmPtr->containerPtr = NULL; } if (wmPtr->crefObj != NULL) { Tcl_DecrRefCount(wmPtr->crefObj); @@ -4154,7 +4154,7 @@ WmIconifyCmd( NULL); return TCL_ERROR; } - if (wmPtr->masterPtr != NULL) { + if (wmPtr->containerPtr != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "can't iconify \"%s\": it is a transient", winPtr->pathName)); @@ -5403,7 +5403,7 @@ WmStateCmd( "OVERRIDE_REDIRECT", NULL); return TCL_ERROR; } - if (wmPtr->masterPtr != NULL) { + if (wmPtr->containerPtr != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "can't iconify \"%s\": it is a transient", winPtr->pathName)); @@ -5549,7 +5549,7 @@ WmTransientCmd( Tcl_Obj *const objv[]) /* Argument objects. */ { WmInfo *wmPtr = winPtr->wmInfoPtr; - TkWindow *masterPtr = wmPtr->masterPtr, **masterPtrPtr = &masterPtr, *w; + TkWindow *containerPtr = wmPtr->containerPtr, **containerPtrPtr = &containerPtr, *w; WmInfo *wmPtr2; if ((objc != 3) && (objc != 4)) { @@ -5557,38 +5557,38 @@ WmTransientCmd( return TCL_ERROR; } if (objc == 3) { - if (masterPtr != NULL) { - Tcl_SetObjResult(interp, TkNewWindowObj((Tk_Window) masterPtr)); + if (containerPtr != NULL) { + Tcl_SetObjResult(interp, TkNewWindowObj((Tk_Window) containerPtr)); } return TCL_OK; } if (Tcl_GetString(objv[3])[0] == '\0') { - if (masterPtr != NULL) { + if (containerPtr != NULL) { /* - * If we had a master, tell them that we aren't tied to them + * If we had a container, tell them that we aren't tied to them * anymore. */ - masterPtr->wmInfoPtr->numTransients--; - Tk_DeleteEventHandler((Tk_Window) masterPtr, + containerPtr->wmInfoPtr->numTransients--; + Tk_DeleteEventHandler((Tk_Window) containerPtr, VisibilityChangeMask|StructureNotifyMask, WmWaitVisibilityOrMapProc, winPtr); } - wmPtr->masterPtr = NULL; + wmPtr->containerPtr = NULL; } else { if (TkGetWindowFromObj(interp, tkwin, objv[3], - (Tk_Window *) masterPtrPtr) != TCL_OK) { + (Tk_Window *) containerPtrPtr) != TCL_OK) { return TCL_ERROR; } - while (!Tk_TopWinHierarchy(masterPtr)) { + while (!Tk_TopWinHierarchy(containerPtr)) { /* - * Ensure that the master window is actually a Tk toplevel. + * Ensure that the container window is actually a Tk toplevel. */ - masterPtr = masterPtr->parentPtr; + containerPtr = containerPtr->parentPtr; } - Tk_MakeWindowExist((Tk_Window) masterPtr); + Tk_MakeWindowExist((Tk_Window) containerPtr); if (wmPtr->iconFor != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( @@ -5598,7 +5598,7 @@ WmTransientCmd( return TCL_ERROR; } - wmPtr2 = masterPtr->wmInfoPtr; + wmPtr2 = containerPtr->wmInfoPtr; if (wmPtr2->iconFor != NULL) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( @@ -5607,42 +5607,42 @@ WmTransientCmd( Tcl_SetErrorCode(interp, "TK", "WM", "TRANSIENT", "ICON", NULL); return TCL_ERROR; } - for (w = masterPtr; w != NULL && w->wmInfoPtr != NULL; - w = (TkWindow *)w->wmInfoPtr->masterPtr) { + for (w = containerPtr; w != NULL && w->wmInfoPtr != NULL; + w = (TkWindow *)w->wmInfoPtr->containerPtr) { if (w == winPtr) { Tcl_SetObjResult(interp, Tcl_ObjPrintf( "setting \"%s\" as master creates a transient/master cycle", - Tk_PathName(masterPtr))); + Tk_PathName(containerPtr))); Tcl_SetErrorCode(interp, "TK", "WM", "TRANSIENT", "SELF", NULL); return TCL_ERROR; } } - if (masterPtr != wmPtr->masterPtr) { + if (containerPtr != wmPtr->containerPtr) { /* - * Remove old master map/unmap binding before setting the new - * master. The event handler will ensure that transient states - * reflect the state of the master. + * Remove old container map/unmap binding before setting the new + * container. The event handler will ensure that transient states + * reflect the state of the container. */ - if (wmPtr->masterPtr != NULL) { - wmPtr->masterPtr->wmInfoPtr->numTransients--; - Tk_DeleteEventHandler((Tk_Window) wmPtr->masterPtr, + if (wmPtr->containerPtr != NULL) { + wmPtr->containerPtr->wmInfoPtr->numTransients--; + Tk_DeleteEventHandler((Tk_Window) wmPtr->containerPtr, VisibilityChangeMask|StructureNotifyMask, WmWaitVisibilityOrMapProc, winPtr); } - masterPtr->wmInfoPtr->numTransients++; - Tk_CreateEventHandler((Tk_Window) masterPtr, + containerPtr->wmInfoPtr->numTransients++; + Tk_CreateEventHandler((Tk_Window) containerPtr, VisibilityChangeMask|StructureNotifyMask, WmWaitVisibilityOrMapProc, winPtr); - wmPtr->masterPtr = masterPtr; + wmPtr->containerPtr = containerPtr; } } if (!((wmPtr->flags & WM_NEVER_MAPPED) && !(winPtr->flags & TK_EMBEDDED))) { - if (wmPtr->masterPtr != NULL - && !Tk_IsMapped(wmPtr->masterPtr)) { + if (wmPtr->containerPtr != NULL + && !Tk_IsMapped(wmPtr->containerPtr)) { TkpWmSetState(winPtr, WithdrawnState); } else { UpdateWrapper(winPtr); @@ -5728,9 +5728,9 @@ WmWaitVisibilityOrMapProc( XEvent *eventPtr) /* Information about event. */ { TkWindow *winPtr = (TkWindow *)clientData; - TkWindow *masterPtr = winPtr->wmInfoPtr->masterPtr; + TkWindow *containerPtr = winPtr->wmInfoPtr->containerPtr; - if (masterPtr == NULL) + if (containerPtr == NULL) return; if (eventPtr->type == MapNotify) { @@ -5742,7 +5742,7 @@ WmWaitVisibilityOrMapProc( } if (eventPtr->type == VisibilityNotify) { - int state = masterPtr->wmInfoPtr->hints.initial_state; + int state = containerPtr->wmInfoPtr->hints.initial_state; if ((state == NormalState) || (state == ZoomState)) { state = winPtr->wmInfoPtr->hints.initial_state; -- cgit v0.12