Tk Source Code

static GMainContext *glib_context = NULL;
static gboolean in_process_pending = FALSE;
static GHashTable *creation_in_progress = NULL;  /* Track windows being created */


/* Thread management functions. */
gpointer RunOnMainThread(gpointer (*func)(gpointer user_data), gpointer user_data);

void EmitBoundsChanged(AtkObject *obj, gint x, gint y, gint width, gint height);
static gboolean run_main_thread_callback(gpointer data);

/* Helper functions for main thread operations. */
static gpointer get_atk_role_for_widget_main(gpointer data);
static gpointer get_atk_name_for_widget_main(gpointer data);
static gpointer get_atk_description_for_widget_main(gpointer data);
static gpointer get_atk_value_for_widget_main(gpointer data);
static gpointer get_window_name_main(gpointer data);
static gpointer get_window_geometry_main(gpointer data);
static gpointer is_window_mapped_main(gpointer data);
static gpointer get_focus_window_main(gpointer data);
static gpointer get_window_parent_main(gpointer data);
static gpointer make_window_exist_main(gpointer data);
static gpointer map_window_main(gpointer data);

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 *GetAtkValueforTkWidget(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);

    g_mutex_clear(&call.mutex);
    g_cond_clear(&call.cond);

    return call.result;
}
















/*
 *----------------------------------------------------------------------
 *
 * GLib-Tcl event loop integration
 *
 *----------------------------------------------------------------------
 */

/* Helper function to integrate strings. */         
static gchar *sanitize_utf8(const gchar *str) 
{
    if (!str) return NULL;
    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 (gpointer)GetAtkValueForWidget(mt_data->tkwin);
}

/* Get accessible name. */
static gpointer get_atk_name_for_widget_main(gpointer data) 
{
    MainThreadData *mt_data = (MainThreadData *)data;
    return (gpointer)(GetAtkNameForWidget(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);
}

/* Get accessible main window name. */
static gpointer get_window_name_main(gpointer data) 
{
    MainThreadData *mt_data = (MainThreadData *)data;
    return (gpointer)Tk_PathName(mt_data->tkwin);
}

/* Get window geometry. */

    return acc->cached_role;
}

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

static gchar *GetAtkNameForWidget(Tk_Window win)
{
    if (!win) return NULL;
    
    gchar *name = NULL;

    MainThreadData data = {win, NULL, NULL, NULL, "name"};
    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);
		if (result) {
		    name = sanitize_utf8(result);
		}
	    }
	}
    }
    return name;
}

static const gchar *tk_get_name(AtkObject *obj)
{
    TkAtkAccessible *acc = (TkAtkAccessible *)obj;
    return acc->cached_name;
}

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

    if (!acc) return; 

    if (obj == tk_root_accessible) {
	/* Free old cached name.  */
	g_free(acc->cached_name);
	acc->cached_name = sanitize_utf8(name); 
    }
    atk_object_set_name(obj, name);
}

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

    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);
	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);
		if (result) {
		    description = sanitize_utf8(result);
		}
	    }
	}
    }
    return description;
}

static const gchar *tk_get_description(AtkObject *obj)
{
    TkAtkAccessible *acc = (TkAtkAccessible *)obj;
    return acc->cached_description;
}


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

static gchar *GetAtkValueforTkWidget(Tk_Window win)
{
    if (!win) return;
    
    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 (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);
		if (result) {
		    value = sanitize_utf8(result);
		}
	    }
	}
    }
    return value;
}

 
static void tk_get_current_value(AtkValue *obj, GValue *value)
{
    TkAtkAccessible *acc = (TkAtkAccessible *)ATK_OBJECT(obj);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, acc->cached_value);
}

        AddChildToParent((TkAtkAccessible *)parent_obj, obj);
        
        /* Emit child addition signal */
        ChildrenChangedAddData *cad = g_new0(ChildrenChangedAddData, 1);
        cad->parent = g_object_ref(parent_obj);
        cad->index = g_list_length(((TkAtkAccessible *)parent_obj)->children) - 1;
        cad->child = g_object_ref(obj);
        RunOnMainThread(emit_children_changed_add, cad);
    } else {
        g_warning("TkCreateAccessibleAtkObject: Invalid parent for %s", path);
        g_hash_table_remove(creation_in_progress, tkwin);  /* Clean up tracking */
        g_object_unref(obj);
        return NULL;
    }

        }
        g_free(geometry);
    }
}

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




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













    acc->cached_name = (gchar*)RunOnMainThread(get_atk_name_for_widget_main, &data);



}

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




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






    acc->cached_value = (gchar*)RunOnMainThread(get_atk_description_for_widget_main, &data);






}

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




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















    acc->cached_value = (gchar*)RunOnMainThread(get_atk_value_for_widget_main, &data);

}

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

        if (old_child && G_IS_OBJECT(old_child)) {
            if (!g_list_find(new_children, old_child)) {
                gint old_index = g_list_index(old_children, old_child);
                ChildrenChangedRemoveData *crd = g_new0(ChildrenChangedRemoveData, 1);
                crd->parent = g_object_ref(ATK_OBJECT(acc));
                crd->index = old_index;
                crd->child = g_object_ref(old_child);
                RunOnMainThread(emit_children_changed_remove, crd);
            }
            g_object_unref(old_child);
        }
        iter = g_list_next(iter);
    }
    g_list_free(old_children);

    /* Emit addition signals for genuinely new children. */
    iter = new_children;
    gint index = 0;
    while (iter) {
        AtkObject *new_child = (AtkObject *)iter->data;
        if (new_child && !g_list_find(old_children, new_child)) {
            ChildrenChangedAddData *cad = g_new0(ChildrenChangedAddData, 1);
            cad->parent = g_object_ref(ATK_OBJECT(acc));
            cad->index = index;
            cad->child = g_object_ref(new_child);
            RunOnMainThread(emit_children_changed_add, cad);
        }
        iter = g_list_next(iter);
        index++;
    }

    g_hash_table_remove(updating_objects, acc);
}

            RemoveChildFromParent(parent_acc, ATK_OBJECT(tkAccessible));
            
            /* Emit signal safely. */
            ChildrenChangedRemoveData *crd = g_new0(ChildrenChangedRemoveData, 1);
            crd->parent = g_object_ref(parent);  /* Take explicit ref */
            crd->index = index;
            crd->child = g_object_ref(ATK_OBJECT(tkAccessible));  /* Take explicit ref. */
            RunOnMainThread(emit_children_changed_remove, crd);
        }
        g_mutex_unlock(&parent_acc->cleanup_mutex);
    }

    /* Unregister from mapping - this is safe.*/
    if (tkAccessible->tkwin) {
        UnregisterAtkObjectForTkWindow(tkAccessible->tkwin);

    if (!acc->is_being_destroyed && 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;
        RunOnMainThread(emit_bounds_changed, bcd);
    }
}

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

    g_debug("TkAtkAccessible_FocusHandler: Object %s focus state: %s",
            Tk_PathName(acc->tkwin), eventPtr->type == FocusIn ? "FocusIn" : "FocusOut");

    if (eventPtr->type == FocusIn) {
        FocusEventData *fed = g_new0(FocusEventData, 1);
        fed->obj = atk_obj;
        fed->state = TRUE;
        RunOnMainThread(emit_focus_event, fed);

        StateChangeData *scd = g_new0(StateChangeData, 1);
        scd->obj = atk_obj;
        scd->name = g_strdup("focused");
        scd->state = TRUE;
        RunOnMainThread(emit_state_change, scd);
    } else if (eventPtr->type == FocusOut) {
        FocusEventData *fed = g_new0(FocusEventData, 1);
        fed->obj = atk_obj;
        fed->state = FALSE;
        RunOnMainThread(emit_focus_event, fed);

        StateChangeData *scd = g_new0(StateChangeData, 1);
        scd->obj = atk_obj;
        scd->name = g_strdup("focused");
        scd->state = FALSE;
        RunOnMainThread(emit_state_change, scd);
    }

    g_object_unref(state_set);
}

/* Respond to <CreateNotify> events. */
static void TkAtkAccessible_CreateHandler(ClientData clientData, XEvent *eventPtr) 
{
	
    if (eventPtr->type != CreateNotify) return;

    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. */
    RunOnMainThread((GSourceFunc)UpdateChildrenCache, acc);
}



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

    
    ValueChangedData *vcd = g_new0(ValueChangedData, 1);
    vcd->obj = acc;
    g_value_init(&vcd->value, G_TYPE_STRING);
    g_value_set_string(&vcd->value, g_value_get_string(&gval));
    g_value_unset(&gval);
    
    RunOnMainThread(emit_value_changed, vcd);

    if (role == ATK_ROLE_TEXT || role == ATK_ROLE_ENTRY) {
        RunOnMainThread(emit_text_selection_changed, acc);
    }
   
    return TCL_OK;
}

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

    TkAtkAccessible *tk_acc = (TkAtkAccessible *)acc;
    UpdateStateCache(tk_acc);

    FocusEventData *fed = g_new0(FocusEventData, 1);
    fed->obj = acc;
    fed->state = TRUE;
    RunOnMainThread(emit_focus_event, fed);

    StateChangeData *scd = g_new0(StateChangeData, 1);
    scd->obj = acc;
    scd->name = g_strdup("focused");
    scd->state = TRUE;
    RunOnMainThread(emit_state_change, scd);

    return TCL_OK;
}


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