Tk Source Code

static gpointer get_window_handle_main(gpointer data);
/* Added: New helper for root/screen coordinates to fix extents */
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 gpointer emit_value_changed(gpointer data);
static gpointer emit_text_selection_changed(gpointer data);
static gpointer emit_focus_event(gpointer data);
static gpointer emit_state_change(gpointer data);
static gpointer emit_bounds_changed(gpointer data);

/* ATK interface implementations. */
static void tk_get_extents(AtkComponent *component, gint *x, gint *y, gint *width, gint *height, AtkCoordType coord_type);
static gboolean tk_contains(AtkComponent *component, gint x, gint y, AtkCoordType coord_type);
static void tk_atk_component_interface_init(AtkComponentIface *iface);
static gint tk_get_n_children(AtkObject *obj);
static AtkObject *tk_ref_child(AtkObject *obj, gint i);
static AtkRole GetAtkRoleForWidget(Tk_Window win);
static AtkRole tk_get_role(AtkObject *obj);
static gchar *GetAtkNameForWidget(Tk_Window win);
static const gchar *tk_get_name(AtkObject *obj);
static void tk_set_name(AtkObject *obj, const gchar *name);
static gchar *GetAtkDescriptionForWidget(Tk_Window win);
static const gchar *tk_get_description(AtkObject *obj);
static gchar *GetAtkValueForWidget(Tk_Window win);
static void tk_get_current_value(AtkValue *obj, GValue *value);
static void tk_atk_value_interface_init(AtkValueIface *iface);
static AtkStateSet *tk_ref_state_set(AtkObject *obj);
static gboolean tk_action_do_action(AtkAction *action, gint i);
static gint tk_action_get_n_actions(AtkAction *action);
static const gchar *tk_action_get_name(AtkAction *action, gint i);
static void tk_atk_action_interface_init(AtkActionIface *iface);

/* 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);
static void UpdateChildrenCache(ClientData object);
static gboolean DeferredChildrenUpdate(gpointer user_data);
static void DeferredChildrenUpdateTcl(ClientData clientData);

/* 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);

    return g_utf8_make_valid(str, -1);
}

/* Get accessible value. */
static gpointer get_atk_value_for_widget_main(gpointer data) 
{
    MainThreadData *mt_data = (MainThreadData *)data;
    return (gchar*)GetAtkValueForWidget(mt_data->tkwin);
}

/* Get accessible name. */
static gpointer get_atk_name_for_widget_main(gpointer data) 
{
    MainThreadData *mt_data = (MainThreadData *)data;
    return (gchar*)(GetAtkNameForWidget(mt_data->tkwin));
}

/* Get accessible description. */
static gpointer get_atk_description_for_widget_main(gpointer data) 
{
    MainThreadData *mt_data = (MainThreadData *)data;
    return (gchar*)(GetAtkDescriptionForWidget(mt_data->tkwin));
}

/* Get accessible role. */
static gpointer get_atk_role_for_widget_main(gpointer data) 
{
    MainThreadData *mt_data = (MainThreadData *)data;
    return (gpointer)(uintptr_t)GetAtkRoleForWidget(mt_data->tkwin);
}

    g_free(crd);
    
    return G_SOURCE_REMOVE;
}


/* Emit value-changed signal. */
static gpointer emit_value_changed(gpointer data)
{
    if (data) {
        ValueChangedData *vcd = (ValueChangedData *)data;
        g_signal_emit_by_name(vcd->obj, "value-changed", &vcd->value);
        g_value_unset(&vcd->value);
        g_free(vcd);
    }
    return G_SOURCE_REMOVE;
}

/* Emit text-selection-changed signal. */
static gpointer emit_text_selection_changed(gpointer data)
{
    if (data) {
        g_signal_emit_by_name(data, "text-selection-changed");
    }
    return G_SOURCE_REMOVE;
}

/* Emit focus-event signal. */
static gpointer emit_focus_event(gpointer data)
{
    if (data) {
        FocusEventData *fed = (FocusEventData *)data;
        g_signal_emit_by_name(fed->obj, "focus-event", fed->state);
        g_free(fed);
    }
    return G_SOURCE_REMOVE;
}

/* Emit state-change signal. */
static gpointer emit_state_change(gpointer data)
{
    if (data) {
        StateChangeData *scd = (StateChangeData *)data;
        g_signal_emit_by_name(scd->obj, "state-change", scd->name, scd->state);
        g_free(scd->name);
        g_free(scd);
    }
    return G_SOURCE_REMOVE;
}

/* Emit bounds-changed signal. */
static gpointer emit_bounds_changed(gpointer data)
{
    if (data) {
        BoundsChangedData *bcd = (BoundsChangedData *)data;
        g_signal_emit_by_name(bcd->obj, "bounds-changed", &bcd->rect);
        g_free(bcd);
    }
    return G_SOURCE_REMOVE;

	acc->cached_name = sanitize_utf8(name); 
    }
    atk_object_set_name(obj, name);
}

static gchar *GetAtkDescriptionForWidget(Tk_Window win)
{
    if (!win) return NULL;

    gchar *description = NULL;

    MainThreadData data = {win, NULL, NULL, NULL, "description"};
    Tcl_HashEntry *hPtr = (Tcl_HashEntry *)RunOnMainThread(find_hash_entry_main, &data);
    if (hPtr) {
	Tcl_HashTable *AccessibleAttributes = (Tcl_HashTable *)RunOnMainThread(get_hash_value_main, &data);

/*
 * Functions to map accessible value to ATK using
 * AtkValue interface.
 */

static gchar *GetAtkValueForWidget(Tk_Window win)
{
    if (!win) return NULL;
    
    gchar *value = NULL;

    MainThreadData data = {win, NULL, NULL, NULL, "value"};
    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 (!tkwin || !parent_obj || !G_IS_OBJECT(parent_obj)) {
	g_warning("RegisterChildWidgets: Invalid tkwin or parent_obj");
	return;
    }

    TkAtkAccessible *acc = (TkAtkAccessible *)parent_obj;

    Tcl_DoWhenIdle(UpdateChildrenCache, (ClientData) acc);
}


/*
 * 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

    /* Mark creation as complete. */
    acc->is_being_created = FALSE;
    
    /* Remove from creation tracking. */
    g_hash_table_remove(creation_in_progress, tkwin);

    /* Shedule children update for LATER, not now. This breaks the recursion cycle. */
	Tcl_DoWhenIdle(DeferredChildrenUpdateTcl, acc);

    return obj;
}

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

		break;
	    }
	    parent = (Tk_Window)RunOnMainThread(get_window_parent_main, &(MainThreadData){parent, NULL, NULL, NULL, NULL});
	}
    }
}

static void UpdateChildrenCache(ClientData object)
{
	TkAtkAccessible *acc = (TkAtkAccessible*) object;
    if (!acc || !acc->tkwin || !acc->interp) return;
    if (acc->is_being_destroyed || acc->is_being_created) return;

    /* Prevent recursive calls. */
    static GHashTable *updating_objects = NULL;
    if (!updating_objects) {
        updating_objects = g_hash_table_new(g_direct_hash, g_direct_equal);

                    if (child_obj) {
                        TkAtkAccessible_RegisterEventHandlers(child, (TkAtkAccessible *)child_obj);
                    }
                }
            }
            
            /* Update the children cache now that all objects exist. */
            UpdateChildrenCache((ClientData)acc);
        }
    }

    return G_SOURCE_REMOVE;
}

/* Run DeferredChildrenUpdate on Tcl's event loop. */
static void DeferredChildrenUpdateTcl(ClientData clientData) 
{
    TkAtkAccessible *acc = (TkAtkAccessible *)clientData;
    DeferredChildrenUpdate(acc);
}

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

        UpdateNameCache(acc);
        UpdateDescriptionCache(acc);
        UpdateValueCache(acc);
        UpdateRoleCache(acc);
        UpdateStateCache(acc);
        
        /* Update children cache asynchronously to avoid recursion */
        Tcl_DoWhenIdle(UpdateChildrenCache, (ClientData) acc);
    }

    updating = FALSE;

    /* Emit signals for valid objects only */
    if (!acc->is_being_destroyed && acc->width > 0 && acc->height > 0 && acc->is_mapped) {
        BoundsChangedData *bcd = g_new0(BoundsChangedData, 1);

    TkAtkAccessible *acc = (TkAtkAccessible *)clientData;
    if (!acc || !acc->tkwin || !acc->interp) {
	g_warning("TkAtkAccessible_CreateHandler: Invalid or null acc/tkwin/interp");
	return;
    }

    /* Update children cache asynchronously. */
    Tcl_DoWhenIdle(UpdateChildrenCache, (ClientData) acc);
}



/*
 *----------------------------------------------------------------------
 *