Tk Source Code

    gchar *cached_name;
    gchar *cached_description;
    gchar *cached_value;
    AtkRole cached_role;
    gint x, y, width, height;
    gboolean is_mapped;
    gboolean has_focus;
    GList *children;  /* Track child accessible objects */
} TkAtkAccessible;

typedef struct _TkAtkAccessibleClass {
    AtkObjectClass parent_class;
} TkAtkAccessibleClass;


/* Structs for passing data to main thread. */
typedef struct {
    gpointer (*func)(gpointer);
    gpointer user_data;
    gpointer result;
    gboolean done;
    GMutex mutex;
    GCond cond;
} TkMainThreadCall;

typedef struct {
    Tk_Window tkwin;
    Tcl_Interp *interp;
    gpointer result;
    const char *windowName;

} MainThreadData;



/* Structs to map Tk roles into Atk roles. */

typedef struct AtkRoleMap {
    const char *tkrole;
    AtkRole atkrole;

static gpointer find_hash_entry_main(gpointer data);
static gpointer get_hash_value_main(gpointer data);
static gpointer find_hash_entry_by_key_main(gpointer data);
static gpointer get_hash_string_value_main(gpointer data);
static gpointer name_to_window_main(gpointer data);
static gpointer get_main_window_main(gpointer data);
static gpointer get_window_handle_main(gpointer data);

static gpointer get_root_coords_main(gpointer data);

/* Signal emission helpers. */
static gpointer emit_children_changed_add(gpointer data);
static gpointer emit_children_changed_remove(gpointer data);
static gboolean emit_value_changed(gpointer data);
static gboolean emit_text_selection_changed(gpointer data);

/* Cache update functions. */
static void UpdateGeometryCache(TkAtkAccessible *acc);
static void UpdateNameCache(TkAtkAccessible *acc);
static void UpdateDescriptionCache(TkAtkAccessible *acc);
static void UpdateValueCache(TkAtkAccessible *acc);
static void UpdateRoleCache(TkAtkAccessible *acc);
static void UpdateStateCache(TkAtkAccessible *acc);


/* Event handlers. */
void TkAtkAccessible_RegisterEventHandlers(Tk_Window tkwin, void *tkAccessible);
static void TkAtkAccessible_DestroyHandler(ClientData clientData, XEvent *eventPtr);
static void TkAtkAccessible_ConfigureHandler(ClientData clientData, XEvent *eventPtr);
static void TkAtkAccessible_MapHandler(ClientData clientData, XEvent *eventPtr);
static void TkAtkAccessible_UnmapHandler(ClientData clientData, XEvent *eventPtr);
static void TkAtkAccessible_FocusHandler(ClientData clientData, XEvent *eventPtr);


/* Tcl command implementations. */
static int EmitSelectionChanged(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
static int EmitFocusChanged(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
static int IsScreenReaderRunning(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
int TkAtkAccessibleObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
int TkAtkAccessibility_Init(Tcl_Interp *interp);

/* GLib-Tcl event loop integration */
static void SetupGlibIntegration(void);
static void ProcessPendingEvents(ClientData clientData);

/* Child management functions */
static void AddChildToParent(TkAtkAccessible *parent, AtkObject *child);
static void RemoveChildFromParent(TkAtkAccessible *parent, AtkObject *child);


/* Define custom Atk object bridged to Tcl/Tk. */
#define TK_ATK_TYPE_ACCESSIBLE (tk_atk_accessible_get_type())
G_DEFINE_TYPE_WITH_CODE(TkAtkAccessible, tk_atk_accessible, ATK_TYPE_OBJECT,

    if (glib_context) {
        while (g_main_context_iteration(glib_context, FALSE)) {
        }
    }

    in_process_pending = FALSE;

    /* Re-schedule. */
    Tcl_CreateTimerHandler(10, ProcessPendingEvents, NULL);
}


/*
 *----------------------------------------------------------------------
 *
 * Child management functions.
 *
 *----------------------------------------------------------------------
 */

static void AddChildToParent(TkAtkAccessible *parent, AtkObject *child) 
{
    if (!parent || !child) return;

}

/* Find hash entry by key. */
static gpointer find_hash_entry_by_key_main(gpointer data)
{
    MainThreadData *mt_data = (MainThreadData *)data;
    Tcl_HashTable *table = (Tcl_HashTable *)mt_data->result;

    return (gpointer)Tcl_FindHashEntry(table, "role");
}

/* Obtain the string value for a hash entry. */ 
static gpointer get_hash_string_value_main(gpointer data)
{
    MainThreadData *mt_data = (MainThreadData *)data;
    Tcl_HashEntry *hPtr = (Tcl_HashEntry *)mt_data->result;

/* Get the main Tk window.  */
static gpointer get_main_window_main(gpointer data)
{
    MainThreadData *mt_data = (MainThreadData *)data;
    return (gpointer)Tk_MainWindow(mt_data->interp);
}

/* Get root/screen coordinates for correct extents in ATK_XY_SCREEN. */
static gpointer get_root_coords_main(gpointer data)
{
    MainThreadData *mt_data = (MainThreadData *)data;
    gint *coords = g_new(gint, 4);
    Tk_GetRootCoords(mt_data->tkwin, &coords[0], &coords[1]);
    coords[2] = Tk_Width(mt_data->tkwin);
    coords[3] = Tk_Height(mt_data->tkwin);

 * lifting of implementing the Tk-ATK interface. 
 *
 *----------------------------------------------------------------------
 */


/*
 * Map Atk component interface to Tk.
 */
 
static void tk_get_extents(AtkComponent *component, gint *x, gint *y, gint *width, gint *height, AtkCoordType coord_type)
{
    TkAtkAccessible *acc = (TkAtkAccessible *)component;

    if (!acc) {
	*x = *y = *width = *height = 0;
	return;
    }

    MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};

    /*
     * Use correct coordinates based on coord_type.
     * - ATK_XY_WINDOW: Cached relative to toplevel window (sum of Tk_X/Tk_Y).
     * - ATK_XY_SCREEN: Absolute screen via Tk_GetRootCoords (fixes navigation issues).
     */
    
    if (coord_type == ATK_XY_SCREEN) {
        gint *coords = (gint *)RunOnMainThread(get_root_coords_main, &data);
        if (coords) {
            *x = coords[0];
            *y = coords[1];
            *width = coords[2];
            *height = coords[3];

        g_object_ref(child->data);
        return ATK_OBJECT(child->data);
    }
    return NULL;
}

/*
 * Functions to map accessible role to Atk.
 */

static AtkRole GetAtkRoleForWidget(Tk_Window win)
{
    if (!win) return ATK_ROLE_UNKNOWN;

    MainThreadData data = {win, NULL, NULL, NULL};
    Tcl_HashEntry *hPtr = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_main, &data);
   
    /* Check if we have accessibility attributes. */ 
    if (hPtr) {
	Tcl_HashTable *AccessibleAttributes = (Tcl_HashTable *)RunOnMainThread(get_hash_value_main, &data);
	if (AccessibleAttributes) {
	    Tcl_HashEntry *hPtr2 = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_by_key_main, &data);
	    if (hPtr2) {
		char *result = (char *)RunOnMainThread(get_hash_string_value_main, &data);
		if (result) {
		    for (int i = 0; roleMap[i].tkrole != NULL; i++) {
			if (strcmp(roleMap[i].tkrole, result) == 0) {
			    return roleMap[i].atkrole;
			}
		    }
		}
	    }
	}
    }

    /* Fallback to widget class if no role attribute set (fixes missing roles like "button"). */
    const char *widgetClass = Tk_Class(win);
    if (widgetClass) {
        for (int i = 0; roleMap[i].tkrole != NULL; i++) {
            if (strcasecmp(roleMap[i].tkrole, widgetClass) == 0) {  /* Case-insensitive for robustness */
                return roleMap[i].atkrole;
            }
        }

 * Name and description getters
 * for Tk-ATK objects.
 */

static const gchar *tk_get_name(AtkObject *obj)
{
    TkAtkAccessible *acc = (TkAtkAccessible *)obj;
    /* 
     * Orca already says "push button" as the role,
     * so return the description to avoid redundancy. 
     */
    return acc->cached_description;
}

static void tk_set_name(AtkObject *obj, const gchar *name)
{
    TkAtkAccessible *acc = (TkAtkAccessible *)obj;

    if (!acc) return; 

	}
    }
    return set;
}

/*
 * Functions that implement actions (i.e. button press)
 * from Tk to Atk.
 */

static gboolean tk_action_do_action(AtkAction *action, gint i)
{
    TkAtkAccessible *acc = (TkAtkAccessible *)action;

    if (!acc || !acc->tkwin || !acc->interp) {
	return FALSE;
    }

    if (i == 0) {
	/* Retrieve the command string.  */
	MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};
	Tcl_HashEntry *hPtr = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_main, &data);
	if (!hPtr) {
	    return FALSE;
	}
        
	Tcl_HashTable *AccessibleAttributes = (Tcl_HashTable *)RunOnMainThread(get_hash_value_main, &data);
	if (!AccessibleAttributes) {

{
    iface->do_action = tk_action_do_action;
    iface->get_n_actions = tk_action_get_n_actions;
    iface->get_name = tk_action_get_name;
}

/*
 * Functions to initialize and manage the parent Atk class and object instances.
 */

static void tk_atk_accessible_init(TkAtkAccessible *self)
{
    self->tkwin = NULL;
    self->interp = NULL;
    self->path = NULL;

}

static void tk_atk_accessible_finalize(GObject *gobject)
{
    TkAtkAccessible *self = (TkAtkAccessible*)gobject;

    if (self->tkwin) {
        if (RunOnMainThread(is_toplevel_main, &(MainThreadData){self->tkwin, NULL, NULL, NULL})) {
            toplevel_accessible_objects = g_list_remove(toplevel_accessible_objects, self);
            /* Remove from root's children. */
            gint index = g_list_index(((TkAtkAccessible *)tk_root_accessible)->children, self);
            if (index >= 0) {
                RemoveChildFromParent((TkAtkAccessible *)tk_root_accessible, ATK_OBJECT(self));
                ChildrenChangedRemoveData *crd = g_new0(ChildrenChangedRemoveData, 1);
                crd->parent = tk_root_accessible;

        }
    }
    
    /* Check for existing registration. */
    AtkObject *existing = GetAtkObjectForTkWindow(tkwin);
    if (existing && existing != accessible) {
        g_warning("RegisterToplevelWindow: Toplevel %s already registered with different AtkObject",
                  (const char *)RunOnMainThread(get_window_name_main, &(MainThreadData){tkwin, NULL, NULL, NULL}));
        return;
    }

    /* Hold a reference to the accessible object. */
    g_object_ref(accessible);

    /* Set parent and add to root's children. */

    }

    /* Set name, role, and description. */
    const gchar *name = tk_get_name(accessible);
    if (name) {
        tk_set_name(accessible, name);
    } else {
        tk_set_name(accessible, (const char *)RunOnMainThread(get_window_name_main, &(MainThreadData){tkwin, NULL, NULL, NULL}));
    }
    atk_object_set_role(accessible, ATK_ROLE_WINDOW);
    atk_object_set_description(accessible, name ? name : ((TkAtkAccessible *)accessible)->path);

    /* Set states and notify. */
    AtkStateSet *state_set = atk_object_ref_state_set(accessible);
    if (state_set != NULL) {

        crd->index = index;
        crd->child = accessible;
        RunOnMainThread(emit_children_changed_remove, crd);
        
        toplevel_accessible_objects = g_list_remove(toplevel_accessible_objects, accessible);
    }
}


/* 
* Register child widgets of a given window 
* as accessible objects. 
*/

static void RegisterChildWidgets(Tcl_Interp *interp, Tk_Window tkwin, AtkObject *parent_obj)
{
    /* Validate inputs. */
    if (!tkwin || !parent_obj || !G_IS_OBJECT(parent_obj)) {
        g_warning("RegisterChildWidgets: Invalid tkwin or parent_obj");
        return;
    }
    
    MainThreadData data = {tkwin, interp, NULL, NULL};
    TkWindow *winPtr = (TkWindow *)RunOnMainThread(get_window_handle_main, &data);
    TkWindow *childPtr;
    
    for (childPtr = winPtr->childList; childPtr != NULL; childPtr = childPtr->nextPtr) {
        Tk_Window child = (Tk_Window)childPtr;
        MainThreadData child_data = {child, interp, NULL, NULL};
        
        AtkObject *child_obj = GetAtkObjectForTkWindow(child);
        if (!child_obj) {
            const char *child_path = (const char *)RunOnMainThread(get_window_name_main, &child_data);
            child_obj = TkCreateAccessibleAtkObject(interp, child, child_path);
            if (!child_obj) {
                g_warning("RegisterChildWidgets: Failed to create accessible object for %s", child_path);
                continue;
            }
            RegisterAtkObjectForTkWindow(child, child_obj);
            TkAtkAccessible_RegisterEventHandlers(child, (TkAtkAccessible *)child_obj);
            
            /* Register children recursively. */
            RegisterChildWidgets(interp, child, child_obj);
        }
    }
}

/*
 * Root window setup. These are the foundation of the
 * accessibility object system in ATK. atk_get_root() is the
 * critical link to at-spi - it is called by the ATK system
 * and at-spi bridge initialization will silently fail if this
 * function is not implemented. This API is confusing because
 * atk_get_root cannot be called directly in our functions, but
 * it still must be implemented if we are using a custom setup,
 * as we are here.
 */
 
static AtkObject *tk_util_get_root(void)
{
    if (!tk_root_accessible) {
	TkAtkAccessible *acc = g_object_new(TK_ATK_TYPE_ACCESSIBLE, NULL);
	tk_root_accessible = ATK_OBJECT(acc);
	atk_object_initialize(tk_root_accessible, NULL);
	/* Set proper name and role.  */
	atk_object_set_role(tk_root_accessible, ATK_ROLE_APPLICATION);
	tk_set_name(tk_root_accessible, "Tk Application");
    }

    return tk_root_accessible;
}

/* Core function linking Tk objects to the ATK root object and at-spi. */
AtkObject *atk_get_root(void) {
    return tk_util_get_root();
}

/* ATK-Tk object creation with proper parent relationship. */
AtkObject *TkCreateAccessibleAtkObject(Tcl_Interp *interp, Tk_Window tkwin, const char *path)
{
    /* Validate inputs. */
    if (!interp || !tkwin || !path) {
        g_warning("TkCreateAccessibleAtkObject: Invalid parameters");
        return NULL;
    }
    
    /* Create new TkAtkAccessible object. */
    TkAtkAccessible *acc = g_object_new(TK_ATK_TYPE_ACCESSIBLE, NULL);
    acc->interp = interp;
    acc->tkwin = tkwin;
    acc->path = sanitize_utf8(path);
    /* Ensure toplevel windows exist and are mapped. */
    MainThreadData data = {tkwin, interp, NULL, NULL};
    if ((gboolean)(uintptr_t)RunOnMainThread(is_toplevel_main, &data) &&
	tkwin != (Tk_Window)RunOnMainThread(get_main_window_main,
					    &(MainThreadData){NULL, interp, NULL, NULL})) {
	RunOnMainThread(make_window_exist_main, &data);
	RunOnMainThread(map_window_main, &data);
    }

    /* Update cached properties. */
    UpdateGeometryCache(acc);
    UpdateNameCache(acc);         /* now fixed with correct thread handoff */
    UpdateDescriptionCache(acc);  /* now fixed with correct thread handoff */
    UpdateValueCache(acc);
    UpdateRoleCache(acc);
    UpdateStateCache(acc);


    /* Initialize AtkObject. */
    AtkObject *obj = ATK_OBJECT(acc);
    AtkRole role = acc->cached_role;
    if (role == ATK_ROLE_UNKNOWN &&
	((gboolean)(uintptr_t)RunOnMainThread(is_toplevel_main, &data) ||
	 tkwin == (Tk_Window)RunOnMainThread(get_main_window_main,
					     &(MainThreadData){NULL, interp, NULL, NULL}))) {
	role = ATK_ROLE_WINDOW;
    }
    atk_object_set_role(obj, role);


    /* Set ATK name from description if available.*/



    if (acc->cached_description && *acc->cached_description) {
	atk_object_set_name(obj, acc->cached_description);
    } else if (acc->cached_name && *acc->cached_name) {
	atk_object_set_name(obj, acc->cached_name);
    } else {
	atk_object_set_name(obj, path);
    }

    /* Always set description property separately. */
    if (acc->cached_description && *acc->cached_description) {
	atk_object_set_description(obj, acc->cached_description);
    } else {
	atk_object_set_description(obj, path);
    }
  
    /* Set states: VISIBLE, SHOWING, ENABLED, and FOCUSABLE where applicable. */
    AtkStateSet *state_set = atk_object_ref_state_set(obj);
    if (state_set != NULL) {
	atk_state_set_add_state(state_set, ATK_STATE_VISIBLE);
	atk_state_set_add_state(state_set, ATK_STATE_SHOWING);
	atk_state_set_add_state(state_set, ATK_STATE_ENABLED);
	if (role == ATK_ROLE_PUSH_BUTTON || role == ATK_ROLE_ENTRY ||
	    role == ATK_ROLE_COMBO_BOX || role == ATK_ROLE_CHECK_BOX ||
	    role == ATK_ROLE_RADIO_BUTTON || role == ATK_ROLE_SLIDER ||
	    role == ATK_ROLE_SPIN_BUTTON) {
	    atk_state_set_add_state(state_set, ATK_STATE_FOCUSABLE);
	}

	/* Notify state changes to ensure Orca receives them. */
	atk_object_notify_state_change(obj, ATK_STATE_VISIBLE, TRUE);
	atk_object_notify_state_change(obj, ATK_STATE_SHOWING, TRUE);
	atk_object_notify_state_change(obj, ATK_STATE_ENABLED, TRUE);
	if (atk_state_set_contains_state(state_set, ATK_STATE_FOCUSABLE)) {
	    atk_object_notify_state_change(obj, ATK_STATE_FOCUSABLE, TRUE);
	}
	g_object_unref(state_set);
    }
    
    /* Get parent window. */
    Tk_Window parent_tkwin = (Tk_Window)RunOnMainThread(get_window_parent_main, &data);
    AtkObject *parent_obj = NULL;
    
    if (parent_tkwin) {
        parent_obj = GetAtkObjectForTkWindow(parent_tkwin);
        if (!parent_obj) {
            /* Create parent object without recursive full registration. */
            TkAtkAccessible *parent_acc = g_object_new(TK_ATK_TYPE_ACCESSIBLE, NULL);
            parent_acc->interp = interp;
            parent_acc->tkwin = parent_tkwin;
            parent_acc->path = sanitize_utf8((const char *)RunOnMainThread(get_window_name_main, &(MainThreadData){parent_tkwin, interp, NULL, NULL}));
            UpdateGeometryCache(parent_acc);
            UpdateNameCache(parent_acc);
            UpdateDescriptionCache(parent_acc);
            UpdateValueCache(parent_acc);
            UpdateRoleCache(parent_acc);
            UpdateStateCache(parent_acc);

            parent_obj = ATK_OBJECT(parent_acc);
            atk_object_set_role(parent_obj, ATK_ROLE_WINDOW);
            if (parent_acc->cached_name) {
                atk_object_set_name(parent_obj, parent_acc->cached_name);
            } else {
                atk_object_set_name(parent_obj, parent_acc->path);
            }
            if (parent_acc->cached_description) {
                atk_object_set_description(parent_obj, parent_acc->cached_description);
            } else {
                atk_object_set_description(parent_obj, parent_acc->path);
            }
            /* Set parent states. */
            state_set = atk_object_ref_state_set(parent_obj);
            if (state_set !=NULL) {
		atk_state_set_add_state(state_set, ATK_STATE_VISIBLE);
		atk_state_set_add_state(state_set, ATK_STATE_SHOWING);
		atk_state_set_add_state(state_set, ATK_STATE_ENABLED);
		
		atk_object_notify_state_change(parent_obj, ATK_STATE_VISIBLE, TRUE);
		atk_object_notify_state_change(parent_obj, ATK_STATE_SHOWING, TRUE);
		atk_object_notify_state_change(parent_obj, ATK_STATE_ENABLED, TRUE);
            
		g_object_unref(state_set);
	    }
            
            RegisterAtkObjectForTkWindow(parent_tkwin, parent_obj);
            TkAtkAccessible_RegisterEventHandlers(parent_tkwin, parent_acc);
            
            /* Set parent of parent_obj. */
            Tk_Window grandparent_tkwin = (Tk_Window)RunOnMainThread(get_window_parent_main, &(MainThreadData){parent_tkwin, interp, NULL, NULL});
            AtkObject *grandparent_obj = grandparent_tkwin ? GetAtkObjectForTkWindow(grandparent_tkwin) : tk_root_accessible;
            if (grandparent_obj && G_IS_OBJECT(grandparent_obj)) {
                atk_object_set_parent(parent_obj, grandparent_obj);
                AddChildToParent((TkAtkAccessible *)grandparent_obj, parent_obj);
                ChildrenChangedAddData *cad = g_new0(ChildrenChangedAddData, 1);
                cad->parent = grandparent_obj;
                cad->index = g_list_length(((TkAtkAccessible *)grandparent_obj)->children) - 1;
                cad->child = parent_obj;
                if (cad->parent) g_object_ref(cad->parent);
                if (cad->child) g_object_ref(cad->child);
                g_debug("TkCreateAccessibleAtkObject: Emitting children-changed::add for parent %s, grandparent=%p, index=%d",
                        parent_acc->path, grandparent_obj, cad->index);
                RunOnMainThread(emit_children_changed_add, cad);
            }
            
            if ((gboolean)(uintptr_t)RunOnMainThread(is_toplevel_main, &(MainThreadData){parent_tkwin, interp, NULL, NULL})) {
                if (!g_list_find(toplevel_accessible_objects, parent_obj)) {
                    toplevel_accessible_objects = g_list_append(toplevel_accessible_objects, parent_obj);
                }
            }
        }
    } else {
        parent_obj = tk_root_accessible;
    }
    
    if (parent_obj && G_IS_OBJECT(parent_obj)) {
        atk_object_set_parent(obj, parent_obj);
        g_debug("TkCreateAccessibleAtkObject: Adding %s to parent %p (path=%s)", 
                path, parent_obj, ((TkAtkAccessible *)parent_obj)->path);
        AddChildToParent((TkAtkAccessible *)parent_obj, obj);
        ChildrenChangedAddData *cad = g_new0(ChildrenChangedAddData, 1);
        cad->parent = parent_obj;
        cad->index = g_list_length(((TkAtkAccessible *)parent_obj)->children) - 1;
        cad->child = obj;
        if (cad->parent) g_object_ref(cad->parent);
        if (cad->child) g_object_ref(cad->child);
        g_debug("TkCreateAccessibleAtkObject: Emitting children-changed::add for %s, parent=%p, index=%d",
                path, parent_obj, cad->index);
        RunOnMainThread(emit_children_changed_add, cad);
    } else {
        g_warning("TkCreateAccessibleAtkObject: Invalid parent for %s (parent_tkwin=%p, parent_obj=%p, is_gobject=%d)",
                  path, parent_tkwin, parent_obj, parent_obj ? G_IS_OBJECT(parent_obj) : 0);
        g_object_unref(obj);
        return NULL;
    }
    
    if ((gboolean)(uintptr_t)RunOnMainThread(is_toplevel_main, &data)) {
        RegisterToplevelWindow(interp, tkwin, obj);
    }
    
    return obj;
}

/*
 * Functions to map Tk window to its corresponding Atk object.
 */

void InitAtkTkMapping(void)
{
    if (!tk_to_atk_map) {

 *----------------------------------------------------------------------
 */
 
static void UpdateGeometryCache(TkAtkAccessible *acc) 
{
    if (!acc || !acc->tkwin) return;
    
    MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};
    gint *geometry = RunOnMainThread(get_window_geometry_main, &data);
    if (geometry) {
        acc->x = geometry[0];
        acc->y = geometry[1];
        acc->width = geometry[2];
        acc->height = geometry[3];
        

static void UpdateNameCache(TkAtkAccessible *acc)
{
    if (!acc || !acc->tkwin || !acc->interp) return;

    g_free(acc->cached_name);
    acc->cached_name = NULL;

    MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};

    /* Get the top-level hash entry for this Tk window. */
    Tcl_HashEntry *hPtr = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_main, &data);
    if (hPtr) {
        data.result = hPtr;  /* Pass to get_hash_value_main() */
        Tcl_HashTable *AccessibleAttributes =
            (Tcl_HashTable *)RunOnMainThread(get_hash_value_main, &data);
        if (AccessibleAttributes) {
            /* Lookup the "name" attribute key inside this table. */
            data.result = AccessibleAttributes; /* Pass table to find_hash_entry_by_key_main() */
            Tcl_HashEntry *hPtr2 =
                (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_by_key_main, &data);
            if (hPtr2) {
                data.result = hPtr2; /* Pass entry to get_hash_string_value_main() */
                const char *result =
                    (const char *)RunOnMainThread(get_hash_string_value_main, &data);
                if (result) {
                    acc->cached_name = sanitize_utf8(result);
                }
            }
        }
    }

    /* Fallback to the Tk widget name/path */
    if (!acc->cached_name) {
        acc->cached_name =
            sanitize_utf8((const char *)RunOnMainThread(get_window_name_main, &data));
    }
}

static void UpdateDescriptionCache(TkAtkAccessible *acc)
{
    if (!acc || !acc->tkwin || !acc->interp) return;

    g_free(acc->cached_description);
    acc->cached_description = NULL;

    MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};

    /* Get the top-level hash entry for this Tk window. */
    Tcl_HashEntry *hPtr = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_main, &data);
    if (hPtr) {
        data.result = hPtr;  /* Pass to get_hash_value_main() */
        Tcl_HashTable *AccessibleAttributes =
            (Tcl_HashTable *)RunOnMainThread(get_hash_value_main, &data);
        if (AccessibleAttributes) {
            /* Step 2: Lookup the "description" attribute key inside this table. */
            data.result = AccessibleAttributes; /* Pass table to find_hash_entry_by_key_main() */
            Tcl_HashEntry *hPtr2 =
                (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_by_key_main, &data);
            if (hPtr2) {
                data.result = hPtr2; /* Pass entry to get_hash_string_value_main() */
                const char *result =
                    (const char *)RunOnMainThread(get_hash_string_value_main, &data);
                    g_warning("result is %s\n", result);
                if (result) {
                    acc->cached_description = sanitize_utf8(result);
                } 
            }
        }
    }
}


static void UpdateValueCache(TkAtkAccessible *acc)
{
    if (!acc || !acc->tkwin) return;

    g_free(acc->cached_value);
    acc->cached_value = NULL;

    MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};
    Tcl_HashEntry *hPtr = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_main, &data);
    if (hPtr) {
	Tcl_HashTable *AccessibleAttributes = (Tcl_HashTable *)RunOnMainThread(get_hash_value_main, &data);
	if (AccessibleAttributes) {
	    Tcl_HashEntry *hPtr2 = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_by_key_main, &data);
	    if (hPtr2) {
		const char *result = (const char *)RunOnMainThread(get_hash_string_value_main, &data);

	acc->cached_value = sanitize_utf8("");
    }
}

static void UpdateRoleCache(TkAtkAccessible *acc)
{
    if (!acc || !acc->tkwin) return;
    MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};
    acc->cached_role = (AtkRole)(uintptr_t)RunOnMainThread(get_atk_role_for_widget_main, &data);
}

static void UpdateStateCache(TkAtkAccessible *acc) 
{
    if (!acc || !acc->tkwin) return;
    
    MainThreadData data = {acc->tkwin, acc->interp, NULL, NULL};
    acc->is_mapped = (gboolean)(uintptr_t)RunOnMainThread(is_window_mapped_main, &data);
    
    TkWindow *focuswin = (TkWindow *)RunOnMainThread(get_focus_window_main, &data);
    Tk_Window focus_win = (Tk_Window)focuswin;
    acc->has_focus = (focus_win == acc->tkwin);
    
    if (!acc->has_focus && focus_win) {
	Tk_Window parent = (Tk_Window)RunOnMainThread(get_window_parent_main, &(MainThreadData){focus_win, NULL, NULL, NULL});
	while (parent) {
	    if (parent == acc->tkwin) {
		acc->has_focus = TRUE;
		break;
	    }
	    parent = (Tk_Window)RunOnMainThread(get_window_parent_main, &(MainThreadData){parent, NULL, NULL, NULL});
	}
    }
}

























































/*
 *----------------------------------------------------------------------
 *
 * Event handlers - update Tk and ATK in response to various X events. 
 *
 *----------------------------------------------------------------------

			  TkAtkAccessible_ConfigureHandler, tkAccessible);
    Tk_CreateEventHandler(tkwin, MapNotify,
			  TkAtkAccessible_MapHandler, tkAccessible);
    Tk_CreateEventHandler(tkwin, UnmapNotify,
			  TkAtkAccessible_UnmapHandler, tkAccessible);
    Tk_CreateEventHandler(tkwin, FocusChangeMask,
			  TkAtkAccessible_FocusHandler, tkAccessible);


}


static void TkAtkAccessible_DestroyHandler(ClientData clientData, XEvent *eventPtr)
{
    if (eventPtr->type == DestroyNotify) {
        TkAtkAccessible *tkAccessible = (TkAtkAccessible *)clientData;




        if (tkAccessible && tkAccessible->tkwin) {
            AtkObject *parent = atk_object_get_parent(ATK_OBJECT(tkAccessible));
            if (parent && G_IS_OBJECT(parent)) {
                /* Compute index before removal. */
                gint index = g_list_index(((TkAtkAccessible *)parent)->children, ATK_OBJECT(tkAccessible));
                if (index >= 0) {
                    /* Remove from parent's children list. */
                    RemoveChildFromParent((TkAtkAccessible*)parent, ATK_OBJECT(tkAccessible));
                    
                    /* Emit children-changed::remove signal. */
                    ChildrenChangedRemoveData *crd = g_new0(ChildrenChangedRemoveData, 1);
                    crd->parent = parent;
                    crd->index = index;
                    crd->child = ATK_OBJECT(tkAccessible);
                    if (crd->parent) g_object_ref(crd->parent);
                    if (crd->child) g_object_ref(crd->child);  
                    RunOnMainThread(emit_children_changed_remove, crd);
                } else {
                    g_warning("TkAtkAccessible_DestroyHandler: Object not found in parent's children list");
                }
            } else {
                g_warning("TkAtkAccessible_DestroyHandler: Invalid or null parent object");
            }
            
            /* Unregister from tk_to_atk_map. */
            UnregisterAtkObjectForTkWindow(tkAccessible->tkwin);
            
            /* Unref the accessible object. */
            g_object_unref(tkAccessible);
        } else {
            g_warning("TkAtkAccessible_DestroyHandler: Invalid or null tkAccessible/tkwin");
        }
    }
}

/* Respond to <Confgure> event. */
static void TkAtkAccessible_ConfigureHandler(ClientData clientData, XEvent *eventPtr)
{
    if (eventPtr->type != ConfigureNotify) {
	return;
    }

    
    TkAtkAccessible *acc = (TkAtkAccessible *)clientData;
    if (!acc || !acc->tkwin) {
	g_warning("TkAtkAccessible_ConfigureHandler: Invalid or null acc/tkwin");
	return;
    }
    
    /* Update all caches with additional validation. */
    UpdateGeometryCache(acc);
    UpdateNameCache(acc);
    UpdateDescriptionCache(acc);
    UpdateValueCache(acc);
    UpdateRoleCache(acc);
    UpdateStateCache(acc);

    
    /* Notify ATK of changes only if geometry is valid and non-zero. */
    if (acc->width > 0 && acc->height > 0 && acc->is_mapped) {
        BoundsChangedData *bcd = g_new0(BoundsChangedData, 1);
        bcd->obj = ATK_OBJECT(acc);
        bcd->rect.x = acc->x;
        bcd->rect.y = acc->y;
        bcd->rect.width = acc->width;
        bcd->rect.height = acc->height;
        RunOnMainThreadAsync(emit_bounds_changed, bcd);
    }
    
    if (acc->cached_name) {
	tk_set_name(ATK_OBJECT(acc), acc->cached_name);
    }
    if (acc->cached_description) {
	atk_object_set_description(ATK_OBJECT(acc), acc->cached_description);
    }
    
    StateChangeData *visible_scd = g_new0(StateChangeData, 1);
    visible_scd->obj = ATK_OBJECT(acc);
    visible_scd->name = g_strdup("visible");
    visible_scd->state = acc->is_mapped;
    RunOnMainThreadAsync(emit_state_change, visible_scd);
    
    StateChangeData *showing_scd = g_new0(StateChangeData, 1);
    showing_scd->obj = ATK_OBJECT(acc);
    showing_scd->name = g_strdup("showing");
    showing_scd->state = acc->is_mapped;
    RunOnMainThreadAsync(emit_state_change, showing_scd);
}


/* Respond to <Map> event. */
static void TkAtkAccessible_MapHandler(ClientData clientData, XEvent *eventPtr)
{
    if (eventPtr->type != MapNotify) return;
    TkAtkAccessible *acc = (TkAtkAccessible *)clientData;
    if (!acc || !acc->tkwin) {

        scd->state = FALSE;
        RunOnMainThreadAsync(emit_state_change, scd);
    }

    g_object_unref(state_set);
}



















/*
 *----------------------------------------------------------------------
 *
 * Tcl command implementations - expose these API's to Tcl scripts and 
 * initialize ATK integration in Tcl/Tk. 

    (void) clientData;

    if (objc < 2) {
	Tcl_WrongNumArgs(ip, 1, objv, "window?");
	return TCL_ERROR;
    }
    
    MainThreadData data = {NULL, ip, NULL, NULL};
    Tk_Window path_tkwin = (Tk_Window)RunOnMainThread(name_to_window_main, &data);
    if (path_tkwin == NULL) {
	return TCL_OK;
    }

    AtkObject *acc = GetAtkObjectForTkWindow(path_tkwin);

{
    (void)clientData;
    if (objc < 2) {
        Tcl_WrongNumArgs(interp, 1, objv, "window");
        return TCL_ERROR;
    }

    MainThreadData data = {NULL, interp, NULL, NULL};
    Tk_Window path_tkwin = (Tk_Window)RunOnMainThread(name_to_window_main, &data);
    if (path_tkwin == NULL) {
	return TCL_OK;
    }

    AtkObject *acc = GetAtkObjectForTkWindow(path_tkwin);
    if (!acc) {
        acc = TkCreateAccessibleAtkObject(interp, path_tkwin, Tcl_GetString(objv[1]));
        if (!acc) {
	    g_warning("Failed to create accessible object\n");
            return TCL_OK;
        }
        
        RegisterAtkObjectForTkWindow(path_tkwin, acc);

        if ((gboolean)(uintptr_t)RunOnMainThread(is_toplevel_main, &(MainThreadData){path_tkwin, interp, NULL, NULL})) {
            RegisterToplevelWindow(interp, path_tkwin, acc);
        } else {
            Tk_Window parent_tkwin = (Tk_Window)RunOnMainThread(get_window_parent_main, &(MainThreadData){path_tkwin, interp, NULL, NULL});
            AtkObject *parent_obj = parent_tkwin ? GetAtkObjectForTkWindow(parent_tkwin) : tk_root_accessible;
            if (parent_obj) {
                atk_object_set_parent(acc, parent_obj);
                RunOnMainThread(emit_children_changed_add, acc);
            }
        }
    }

    char *windowName = Tcl_GetString(objv[1]);
    if (!windowName) {
	Tcl_SetResult(interp, "Window name cannot be null.", TCL_STATIC);
	return TCL_ERROR;
    }

    MainThreadData data = {NULL, interp, NULL, windowName};
    Tk_Window tkwin = (Tk_Window)RunOnMainThread(name_to_window_main, &data);


    if (tkwin == NULL) {
	Tcl_SetResult(interp, "Invalid window name.", TCL_STATIC);
	return TCL_ERROR;
    }

	return TCL_ERROR;
    }

    /* Register for cleanup, mapping and other events. */
    TkAtkAccessible_RegisterEventHandlers(tkwin, accessible);

    /* Handle toplevels. */
    if ((gboolean)(uintptr_t)RunOnMainThread(is_toplevel_main, &(MainThreadData){tkwin, interp, NULL, NULL})) {
	RegisterToplevelWindow(interp, tkwin, (AtkObject*)accessible);
    }

    return TCL_OK;
}
#endif