All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.purejava.appindicator._AtkTextIface Maven / Gradle / Ivy

There is a newer version: 1.4.2
Show newest version
// Generated by jextract

package org.purejava.appindicator;

import java.lang.foreign.Arena;
import java.lang.foreign.MemoryLayout;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.SegmentAllocator;
import java.lang.invoke.VarHandle;
/**
 * {@snippet :
 * struct _AtkTextIface {
 *     struct _GTypeInterface parent;
 *     char* (*get_text)(struct _AtkText*,int,int);
 *     char* (*get_text_after_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
 *     char* (*get_text_at_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
 *     unsigned int (*get_character_at_offset)(struct _AtkText*,int);
 *     char* (*get_text_before_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
 *     int (*get_caret_offset)(struct _AtkText*);
 *     struct _GSList* (*get_run_attributes)(struct _AtkText*,int,int*,int*);
 *     struct _GSList* (*get_default_attributes)(struct _AtkText*);
 *     void (*get_character_extents)(struct _AtkText*,int,int*,int*,int*,int*,enum AtkCoordType);
 *     int (*get_character_count)(struct _AtkText*);
 *     int (*get_offset_at_point)(struct _AtkText*,int,int,enum AtkCoordType);
 *     int (*get_n_selections)(struct _AtkText*);
 *     char* (*get_selection)(struct _AtkText*,int,int*,int*);
 *     int (*add_selection)(struct _AtkText*,int,int);
 *     int (*remove_selection)(struct _AtkText*,int);
 *     int (*set_selection)(struct _AtkText*,int,int,int);
 *     int (*set_caret_offset)(struct _AtkText*,int);
 *     void (*text_changed)(struct _AtkText*,int,int);
 *     void (*text_caret_moved)(struct _AtkText*,int);
 *     void (*text_selection_changed)(struct _AtkText*);
 *     void (*text_attributes_changed)(struct _AtkText*);
 *     void (*get_range_extents)(struct _AtkText*,int,int,enum AtkCoordType,struct _AtkTextRectangle*);
 *     struct _AtkTextRange** (*get_bounded_ranges)(struct _AtkText*,struct _AtkTextRectangle*,enum AtkCoordType,enum AtkTextClipType,enum AtkTextClipType);
 *     char* (*get_string_at_offset)(struct _AtkText*,int,enum AtkTextGranularity,int*,int*);
 *     int (*scroll_substring_to)(struct _AtkText*,int,int,enum AtkScrollType);
 *     int (*scroll_substring_to_point)(struct _AtkText*,int,int,enum AtkCoordType,int,int);
 * };
 * }
 */
public class _AtkTextIface {

    public static MemoryLayout $LAYOUT() {
        return constants$2010.const$2;
    }
    public static MemorySegment parent$slice(MemorySegment seg) {
        return seg.asSlice(0, 16);
    }
    /**
     * {@snippet :
 * char* (*get_text)(struct _AtkText*,int,int);
     * }
     */
    public interface get_text {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2);
        static MemorySegment allocate(get_text fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2010.const$3, fi, constants$33.const$5, scope);
        }
        static get_text ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$1822.const$5.invokeExact(symbol, __x0, __x1, __x2);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_text$VH() {
        return constants$2010.const$4;
    }
    /**
     * Getter for field:
     * {@snippet :
     * char* (*get_text)(struct _AtkText*,int,int);
     * }
     */
    public static MemorySegment get_text$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2010.const$4.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * char* (*get_text)(struct _AtkText*,int,int);
     * }
     */
    public static void get_text$set(MemorySegment seg, MemorySegment x) {
        constants$2010.const$4.set(seg, x);
    }
    public static MemorySegment get_text$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2010.const$4.get(seg.asSlice(index*sizeof()));
    }
    public static void get_text$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2010.const$4.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_text get_text(MemorySegment segment, Arena scope) {
        return get_text.ofAddress(get_text$get(segment), scope);
    }
    /**
     * {@snippet :
 * char* (*get_text_after_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public interface get_text_after_offset {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, java.lang.foreign.MemorySegment _x3, java.lang.foreign.MemorySegment _x4);
        static MemorySegment allocate(get_text_after_offset fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2010.const$5, fi, constants$1421.const$1, scope);
        }
        static get_text_after_offset ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, java.lang.foreign.MemorySegment __x3, java.lang.foreign.MemorySegment __x4) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$2011.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_text_after_offset$VH() {
        return constants$2011.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * char* (*get_text_after_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public static MemorySegment get_text_after_offset$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2011.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * char* (*get_text_after_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public static void get_text_after_offset$set(MemorySegment seg, MemorySegment x) {
        constants$2011.const$1.set(seg, x);
    }
    public static MemorySegment get_text_after_offset$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2011.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void get_text_after_offset$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2011.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_text_after_offset get_text_after_offset(MemorySegment segment, Arena scope) {
        return get_text_after_offset.ofAddress(get_text_after_offset$get(segment), scope);
    }
    /**
     * {@snippet :
 * char* (*get_text_at_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public interface get_text_at_offset {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, java.lang.foreign.MemorySegment _x3, java.lang.foreign.MemorySegment _x4);
        static MemorySegment allocate(get_text_at_offset fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2011.const$2, fi, constants$1421.const$1, scope);
        }
        static get_text_at_offset ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, java.lang.foreign.MemorySegment __x3, java.lang.foreign.MemorySegment __x4) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$2011.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_text_at_offset$VH() {
        return constants$2011.const$3;
    }
    /**
     * Getter for field:
     * {@snippet :
     * char* (*get_text_at_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public static MemorySegment get_text_at_offset$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2011.const$3.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * char* (*get_text_at_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public static void get_text_at_offset$set(MemorySegment seg, MemorySegment x) {
        constants$2011.const$3.set(seg, x);
    }
    public static MemorySegment get_text_at_offset$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2011.const$3.get(seg.asSlice(index*sizeof()));
    }
    public static void get_text_at_offset$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2011.const$3.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_text_at_offset get_text_at_offset(MemorySegment segment, Arena scope) {
        return get_text_at_offset.ofAddress(get_text_at_offset$get(segment), scope);
    }
    /**
     * {@snippet :
 * unsigned int (*get_character_at_offset)(struct _AtkText*,int);
     * }
     */
    public interface get_character_at_offset {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
        static MemorySegment allocate(get_character_at_offset fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2011.const$4, fi, constants$11.const$4, scope);
        }
        static get_character_at_offset ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
                try {
                    return (int)constants$837.const$4.invokeExact(symbol, __x0, __x1);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_character_at_offset$VH() {
        return constants$2011.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * unsigned int (*get_character_at_offset)(struct _AtkText*,int);
     * }
     */
    public static MemorySegment get_character_at_offset$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2011.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * unsigned int (*get_character_at_offset)(struct _AtkText*,int);
     * }
     */
    public static void get_character_at_offset$set(MemorySegment seg, MemorySegment x) {
        constants$2011.const$5.set(seg, x);
    }
    public static MemorySegment get_character_at_offset$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2011.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void get_character_at_offset$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2011.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_character_at_offset get_character_at_offset(MemorySegment segment, Arena scope) {
        return get_character_at_offset.ofAddress(get_character_at_offset$get(segment), scope);
    }
    /**
     * {@snippet :
 * char* (*get_text_before_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public interface get_text_before_offset {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, java.lang.foreign.MemorySegment _x3, java.lang.foreign.MemorySegment _x4);
        static MemorySegment allocate(get_text_before_offset fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2012.const$0, fi, constants$1421.const$1, scope);
        }
        static get_text_before_offset ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, java.lang.foreign.MemorySegment __x3, java.lang.foreign.MemorySegment __x4) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$2011.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_text_before_offset$VH() {
        return constants$2012.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * char* (*get_text_before_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public static MemorySegment get_text_before_offset$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2012.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * char* (*get_text_before_offset)(struct _AtkText*,int,enum AtkTextBoundary,int*,int*);
     * }
     */
    public static void get_text_before_offset$set(MemorySegment seg, MemorySegment x) {
        constants$2012.const$1.set(seg, x);
    }
    public static MemorySegment get_text_before_offset$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2012.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void get_text_before_offset$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2012.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_text_before_offset get_text_before_offset(MemorySegment segment, Arena scope) {
        return get_text_before_offset.ofAddress(get_text_before_offset$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*get_caret_offset)(struct _AtkText*);
     * }
     */
    public interface get_caret_offset {

        int apply(java.lang.foreign.MemorySegment user_data);
        static MemorySegment allocate(get_caret_offset fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2012.const$2, fi, constants$10.const$5, scope);
        }
        static get_caret_offset ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _user_data) -> {
                try {
                    return (int)constants$14.const$2.invokeExact(symbol, _user_data);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_caret_offset$VH() {
        return constants$2012.const$3;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*get_caret_offset)(struct _AtkText*);
     * }
     */
    public static MemorySegment get_caret_offset$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2012.const$3.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*get_caret_offset)(struct _AtkText*);
     * }
     */
    public static void get_caret_offset$set(MemorySegment seg, MemorySegment x) {
        constants$2012.const$3.set(seg, x);
    }
    public static MemorySegment get_caret_offset$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2012.const$3.get(seg.asSlice(index*sizeof()));
    }
    public static void get_caret_offset$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2012.const$3.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_caret_offset get_caret_offset(MemorySegment segment, Arena scope) {
        return get_caret_offset.ofAddress(get_caret_offset$get(segment), scope);
    }
    /**
     * {@snippet :
 * struct _GSList* (*get_run_attributes)(struct _AtkText*,int,int*,int*);
     * }
     */
    public interface get_run_attributes {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3);
        static MemorySegment allocate(get_run_attributes fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2012.const$4, fi, constants$180.const$0, scope);
        }
        static get_run_attributes ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$987.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_run_attributes$VH() {
        return constants$2012.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * struct _GSList* (*get_run_attributes)(struct _AtkText*,int,int*,int*);
     * }
     */
    public static MemorySegment get_run_attributes$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2012.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * struct _GSList* (*get_run_attributes)(struct _AtkText*,int,int*,int*);
     * }
     */
    public static void get_run_attributes$set(MemorySegment seg, MemorySegment x) {
        constants$2012.const$5.set(seg, x);
    }
    public static MemorySegment get_run_attributes$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2012.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void get_run_attributes$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2012.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_run_attributes get_run_attributes(MemorySegment segment, Arena scope) {
        return get_run_attributes.ofAddress(get_run_attributes$get(segment), scope);
    }
    /**
     * {@snippet :
 * struct _GSList* (*get_default_attributes)(struct _AtkText*);
     * }
     */
    public interface get_default_attributes {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment user_data);
        static MemorySegment allocate(get_default_attributes fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2013.const$0, fi, constants$5.const$2, scope);
        }
        static get_default_attributes ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _user_data) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$99.const$0.invokeExact(symbol, _user_data);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_default_attributes$VH() {
        return constants$2013.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * struct _GSList* (*get_default_attributes)(struct _AtkText*);
     * }
     */
    public static MemorySegment get_default_attributes$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2013.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * struct _GSList* (*get_default_attributes)(struct _AtkText*);
     * }
     */
    public static void get_default_attributes$set(MemorySegment seg, MemorySegment x) {
        constants$2013.const$1.set(seg, x);
    }
    public static MemorySegment get_default_attributes$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2013.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void get_default_attributes$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2013.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_default_attributes get_default_attributes(MemorySegment segment, Arena scope) {
        return get_default_attributes.ofAddress(get_default_attributes$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*get_character_extents)(struct _AtkText*,int,int*,int*,int*,int*,enum AtkCoordType);
     * }
     */
    public interface get_character_extents {

        void apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3, java.lang.foreign.MemorySegment _x4, java.lang.foreign.MemorySegment _x5, int _x6);
        static MemorySegment allocate(get_character_extents fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2013.const$2, fi, constants$430.const$3, scope);
        }
        static get_character_extents ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3, java.lang.foreign.MemorySegment __x4, java.lang.foreign.MemorySegment __x5, int __x6) -> {
                try {
                    constants$2013.const$3.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5, __x6);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_character_extents$VH() {
        return constants$2013.const$4;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*get_character_extents)(struct _AtkText*,int,int*,int*,int*,int*,enum AtkCoordType);
     * }
     */
    public static MemorySegment get_character_extents$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2013.const$4.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*get_character_extents)(struct _AtkText*,int,int*,int*,int*,int*,enum AtkCoordType);
     * }
     */
    public static void get_character_extents$set(MemorySegment seg, MemorySegment x) {
        constants$2013.const$4.set(seg, x);
    }
    public static MemorySegment get_character_extents$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2013.const$4.get(seg.asSlice(index*sizeof()));
    }
    public static void get_character_extents$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2013.const$4.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_character_extents get_character_extents(MemorySegment segment, Arena scope) {
        return get_character_extents.ofAddress(get_character_extents$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*get_character_count)(struct _AtkText*);
     * }
     */
    public interface get_character_count {

        int apply(java.lang.foreign.MemorySegment user_data);
        static MemorySegment allocate(get_character_count fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2013.const$5, fi, constants$10.const$5, scope);
        }
        static get_character_count ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _user_data) -> {
                try {
                    return (int)constants$14.const$2.invokeExact(symbol, _user_data);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_character_count$VH() {
        return constants$2014.const$0;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*get_character_count)(struct _AtkText*);
     * }
     */
    public static MemorySegment get_character_count$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2014.const$0.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*get_character_count)(struct _AtkText*);
     * }
     */
    public static void get_character_count$set(MemorySegment seg, MemorySegment x) {
        constants$2014.const$0.set(seg, x);
    }
    public static MemorySegment get_character_count$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2014.const$0.get(seg.asSlice(index*sizeof()));
    }
    public static void get_character_count$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2014.const$0.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_character_count get_character_count(MemorySegment segment, Arena scope) {
        return get_character_count.ofAddress(get_character_count$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*get_offset_at_point)(struct _AtkText*,int,int,enum AtkCoordType);
     * }
     */
    public interface get_offset_at_point {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, int _x3);
        static MemorySegment allocate(get_offset_at_point fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2014.const$1, fi, constants$608.const$5, scope);
        }
        static get_offset_at_point ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, int __x3) -> {
                try {
                    return (int)constants$1995.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_offset_at_point$VH() {
        return constants$2014.const$2;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*get_offset_at_point)(struct _AtkText*,int,int,enum AtkCoordType);
     * }
     */
    public static MemorySegment get_offset_at_point$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2014.const$2.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*get_offset_at_point)(struct _AtkText*,int,int,enum AtkCoordType);
     * }
     */
    public static void get_offset_at_point$set(MemorySegment seg, MemorySegment x) {
        constants$2014.const$2.set(seg, x);
    }
    public static MemorySegment get_offset_at_point$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2014.const$2.get(seg.asSlice(index*sizeof()));
    }
    public static void get_offset_at_point$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2014.const$2.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_offset_at_point get_offset_at_point(MemorySegment segment, Arena scope) {
        return get_offset_at_point.ofAddress(get_offset_at_point$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*get_n_selections)(struct _AtkText*);
     * }
     */
    public interface get_n_selections {

        int apply(java.lang.foreign.MemorySegment user_data);
        static MemorySegment allocate(get_n_selections fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2014.const$3, fi, constants$10.const$5, scope);
        }
        static get_n_selections ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _user_data) -> {
                try {
                    return (int)constants$14.const$2.invokeExact(symbol, _user_data);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_n_selections$VH() {
        return constants$2014.const$4;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*get_n_selections)(struct _AtkText*);
     * }
     */
    public static MemorySegment get_n_selections$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2014.const$4.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*get_n_selections)(struct _AtkText*);
     * }
     */
    public static void get_n_selections$set(MemorySegment seg, MemorySegment x) {
        constants$2014.const$4.set(seg, x);
    }
    public static MemorySegment get_n_selections$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2014.const$4.get(seg.asSlice(index*sizeof()));
    }
    public static void get_n_selections$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2014.const$4.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_n_selections get_n_selections(MemorySegment segment, Arena scope) {
        return get_n_selections.ofAddress(get_n_selections$get(segment), scope);
    }
    /**
     * {@snippet :
 * char* (*get_selection)(struct _AtkText*,int,int*,int*);
     * }
     */
    public interface get_selection {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, int _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3);
        static MemorySegment allocate(get_selection fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2014.const$5, fi, constants$180.const$0, scope);
        }
        static get_selection ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$987.const$2.invokeExact(symbol, __x0, __x1, __x2, __x3);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_selection$VH() {
        return constants$2015.const$0;
    }
    /**
     * Getter for field:
     * {@snippet :
     * char* (*get_selection)(struct _AtkText*,int,int*,int*);
     * }
     */
    public static MemorySegment get_selection$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2015.const$0.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * char* (*get_selection)(struct _AtkText*,int,int*,int*);
     * }
     */
    public static void get_selection$set(MemorySegment seg, MemorySegment x) {
        constants$2015.const$0.set(seg, x);
    }
    public static MemorySegment get_selection$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2015.const$0.get(seg.asSlice(index*sizeof()));
    }
    public static void get_selection$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2015.const$0.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_selection get_selection(MemorySegment segment, Arena scope) {
        return get_selection.ofAddress(get_selection$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*add_selection)(struct _AtkText*,int,int);
     * }
     */
    public interface add_selection {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2);
        static MemorySegment allocate(add_selection fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2015.const$1, fi, constants$49.const$0, scope);
        }
        static add_selection ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2) -> {
                try {
                    return (int)constants$247.const$2.invokeExact(symbol, __x0, __x1, __x2);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle add_selection$VH() {
        return constants$2015.const$2;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*add_selection)(struct _AtkText*,int,int);
     * }
     */
    public static MemorySegment add_selection$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2015.const$2.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*add_selection)(struct _AtkText*,int,int);
     * }
     */
    public static void add_selection$set(MemorySegment seg, MemorySegment x) {
        constants$2015.const$2.set(seg, x);
    }
    public static MemorySegment add_selection$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2015.const$2.get(seg.asSlice(index*sizeof()));
    }
    public static void add_selection$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2015.const$2.set(seg.asSlice(index*sizeof()), x);
    }
    public static add_selection add_selection(MemorySegment segment, Arena scope) {
        return add_selection.ofAddress(add_selection$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*remove_selection)(struct _AtkText*,int);
     * }
     */
    public interface remove_selection {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
        static MemorySegment allocate(remove_selection fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2015.const$3, fi, constants$11.const$4, scope);
        }
        static remove_selection ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
                try {
                    return (int)constants$837.const$4.invokeExact(symbol, __x0, __x1);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle remove_selection$VH() {
        return constants$2015.const$4;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*remove_selection)(struct _AtkText*,int);
     * }
     */
    public static MemorySegment remove_selection$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2015.const$4.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*remove_selection)(struct _AtkText*,int);
     * }
     */
    public static void remove_selection$set(MemorySegment seg, MemorySegment x) {
        constants$2015.const$4.set(seg, x);
    }
    public static MemorySegment remove_selection$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2015.const$4.get(seg.asSlice(index*sizeof()));
    }
    public static void remove_selection$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2015.const$4.set(seg.asSlice(index*sizeof()), x);
    }
    public static remove_selection remove_selection(MemorySegment segment, Arena scope) {
        return remove_selection.ofAddress(remove_selection$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*set_selection)(struct _AtkText*,int,int,int);
     * }
     */
    public interface set_selection {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, int _x3);
        static MemorySegment allocate(set_selection fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2015.const$5, fi, constants$608.const$5, scope);
        }
        static set_selection ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, int __x3) -> {
                try {
                    return (int)constants$1995.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle set_selection$VH() {
        return constants$2016.const$0;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*set_selection)(struct _AtkText*,int,int,int);
     * }
     */
    public static MemorySegment set_selection$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2016.const$0.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*set_selection)(struct _AtkText*,int,int,int);
     * }
     */
    public static void set_selection$set(MemorySegment seg, MemorySegment x) {
        constants$2016.const$0.set(seg, x);
    }
    public static MemorySegment set_selection$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2016.const$0.get(seg.asSlice(index*sizeof()));
    }
    public static void set_selection$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2016.const$0.set(seg.asSlice(index*sizeof()), x);
    }
    public static set_selection set_selection(MemorySegment segment, Arena scope) {
        return set_selection.ofAddress(set_selection$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*set_caret_offset)(struct _AtkText*,int);
     * }
     */
    public interface set_caret_offset {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1);
        static MemorySegment allocate(set_caret_offset fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2016.const$1, fi, constants$11.const$4, scope);
        }
        static set_caret_offset ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
                try {
                    return (int)constants$837.const$4.invokeExact(symbol, __x0, __x1);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle set_caret_offset$VH() {
        return constants$2016.const$2;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*set_caret_offset)(struct _AtkText*,int);
     * }
     */
    public static MemorySegment set_caret_offset$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2016.const$2.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*set_caret_offset)(struct _AtkText*,int);
     * }
     */
    public static void set_caret_offset$set(MemorySegment seg, MemorySegment x) {
        constants$2016.const$2.set(seg, x);
    }
    public static MemorySegment set_caret_offset$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2016.const$2.get(seg.asSlice(index*sizeof()));
    }
    public static void set_caret_offset$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2016.const$2.set(seg.asSlice(index*sizeof()), x);
    }
    public static set_caret_offset set_caret_offset(MemorySegment segment, Arena scope) {
        return set_caret_offset.ofAddress(set_caret_offset$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*text_changed)(struct _AtkText*,int,int);
     * }
     */
    public interface text_changed {

        void apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2);
        static MemorySegment allocate(text_changed fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2016.const$3, fi, constants$467.const$3, scope);
        }
        static text_changed ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2) -> {
                try {
                    constants$1901.const$2.invokeExact(symbol, __x0, __x1, __x2);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle text_changed$VH() {
        return constants$2016.const$4;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*text_changed)(struct _AtkText*,int,int);
     * }
     */
    public static MemorySegment text_changed$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2016.const$4.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*text_changed)(struct _AtkText*,int,int);
     * }
     */
    public static void text_changed$set(MemorySegment seg, MemorySegment x) {
        constants$2016.const$4.set(seg, x);
    }
    public static MemorySegment text_changed$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2016.const$4.get(seg.asSlice(index*sizeof()));
    }
    public static void text_changed$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2016.const$4.set(seg.asSlice(index*sizeof()), x);
    }
    public static text_changed text_changed(MemorySegment segment, Arena scope) {
        return text_changed.ofAddress(text_changed$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*text_caret_moved)(struct _AtkText*,int);
     * }
     */
    public interface text_caret_moved {

        void apply(java.lang.foreign.MemorySegment colors, int n_colors);
        static MemorySegment allocate(text_caret_moved fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2016.const$5, fi, constants$40.const$2, scope);
        }
        static text_caret_moved ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _colors, int _n_colors) -> {
                try {
                    constants$509.const$5.invokeExact(symbol, _colors, _n_colors);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle text_caret_moved$VH() {
        return constants$2017.const$0;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*text_caret_moved)(struct _AtkText*,int);
     * }
     */
    public static MemorySegment text_caret_moved$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2017.const$0.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*text_caret_moved)(struct _AtkText*,int);
     * }
     */
    public static void text_caret_moved$set(MemorySegment seg, MemorySegment x) {
        constants$2017.const$0.set(seg, x);
    }
    public static MemorySegment text_caret_moved$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2017.const$0.get(seg.asSlice(index*sizeof()));
    }
    public static void text_caret_moved$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2017.const$0.set(seg.asSlice(index*sizeof()), x);
    }
    public static text_caret_moved text_caret_moved(MemorySegment segment, Arena scope) {
        return text_caret_moved.ofAddress(text_caret_moved$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*text_selection_changed)(struct _AtkText*);
     * }
     */
    public interface text_selection_changed {

        void apply(java.lang.foreign.MemorySegment display);
        static MemorySegment allocate(text_selection_changed fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2017.const$1, fi, constants$13.const$1, scope);
        }
        static text_selection_changed ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _display) -> {
                try {
                    constants$13.const$3.invokeExact(symbol, _display);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle text_selection_changed$VH() {
        return constants$2017.const$2;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*text_selection_changed)(struct _AtkText*);
     * }
     */
    public static MemorySegment text_selection_changed$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2017.const$2.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*text_selection_changed)(struct _AtkText*);
     * }
     */
    public static void text_selection_changed$set(MemorySegment seg, MemorySegment x) {
        constants$2017.const$2.set(seg, x);
    }
    public static MemorySegment text_selection_changed$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2017.const$2.get(seg.asSlice(index*sizeof()));
    }
    public static void text_selection_changed$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2017.const$2.set(seg.asSlice(index*sizeof()), x);
    }
    public static text_selection_changed text_selection_changed(MemorySegment segment, Arena scope) {
        return text_selection_changed.ofAddress(text_selection_changed$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*text_attributes_changed)(struct _AtkText*);
     * }
     */
    public interface text_attributes_changed {

        void apply(java.lang.foreign.MemorySegment display);
        static MemorySegment allocate(text_attributes_changed fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2017.const$3, fi, constants$13.const$1, scope);
        }
        static text_attributes_changed ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _display) -> {
                try {
                    constants$13.const$3.invokeExact(symbol, _display);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle text_attributes_changed$VH() {
        return constants$2017.const$4;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*text_attributes_changed)(struct _AtkText*);
     * }
     */
    public static MemorySegment text_attributes_changed$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2017.const$4.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*text_attributes_changed)(struct _AtkText*);
     * }
     */
    public static void text_attributes_changed$set(MemorySegment seg, MemorySegment x) {
        constants$2017.const$4.set(seg, x);
    }
    public static MemorySegment text_attributes_changed$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2017.const$4.get(seg.asSlice(index*sizeof()));
    }
    public static void text_attributes_changed$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2017.const$4.set(seg.asSlice(index*sizeof()), x);
    }
    public static text_attributes_changed text_attributes_changed(MemorySegment segment, Arena scope) {
        return text_attributes_changed.ofAddress(text_attributes_changed$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*get_range_extents)(struct _AtkText*,int,int,enum AtkCoordType,struct _AtkTextRectangle*);
     * }
     */
    public interface get_range_extents {

        void apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, int _x3, java.lang.foreign.MemorySegment _x4);
        static MemorySegment allocate(get_range_extents fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2017.const$5, fi, constants$1954.const$1, scope);
        }
        static get_range_extents ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, int __x3, java.lang.foreign.MemorySegment __x4) -> {
                try {
                    constants$2018.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_range_extents$VH() {
        return constants$2018.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*get_range_extents)(struct _AtkText*,int,int,enum AtkCoordType,struct _AtkTextRectangle*);
     * }
     */
    public static MemorySegment get_range_extents$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2018.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*get_range_extents)(struct _AtkText*,int,int,enum AtkCoordType,struct _AtkTextRectangle*);
     * }
     */
    public static void get_range_extents$set(MemorySegment seg, MemorySegment x) {
        constants$2018.const$1.set(seg, x);
    }
    public static MemorySegment get_range_extents$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2018.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void get_range_extents$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2018.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_range_extents get_range_extents(MemorySegment segment, Arena scope) {
        return get_range_extents.ofAddress(get_range_extents$get(segment), scope);
    }
    /**
     * {@snippet :
 * struct _AtkTextRange** (*get_bounded_ranges)(struct _AtkText*,struct _AtkTextRectangle*,enum AtkCoordType,enum AtkTextClipType,enum AtkTextClipType);
     * }
     */
    public interface get_bounded_ranges {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, int _x2, int _x3, int _x4);
        static MemorySegment allocate(get_bounded_ranges fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2018.const$3, fi, constants$2018.const$2, scope);
        }
        static get_bounded_ranges ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, int __x2, int __x3, int __x4) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$2018.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_bounded_ranges$VH() {
        return constants$2018.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * struct _AtkTextRange** (*get_bounded_ranges)(struct _AtkText*,struct _AtkTextRectangle*,enum AtkCoordType,enum AtkTextClipType,enum AtkTextClipType);
     * }
     */
    public static MemorySegment get_bounded_ranges$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2018.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * struct _AtkTextRange** (*get_bounded_ranges)(struct _AtkText*,struct _AtkTextRectangle*,enum AtkCoordType,enum AtkTextClipType,enum AtkTextClipType);
     * }
     */
    public static void get_bounded_ranges$set(MemorySegment seg, MemorySegment x) {
        constants$2018.const$5.set(seg, x);
    }
    public static MemorySegment get_bounded_ranges$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2018.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void get_bounded_ranges$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2018.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_bounded_ranges get_bounded_ranges(MemorySegment segment, Arena scope) {
        return get_bounded_ranges.ofAddress(get_bounded_ranges$get(segment), scope);
    }
    /**
     * {@snippet :
 * char* (*get_string_at_offset)(struct _AtkText*,int,enum AtkTextGranularity,int*,int*);
     * }
     */
    public interface get_string_at_offset {

        java.lang.foreign.MemorySegment apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, java.lang.foreign.MemorySegment _x3, java.lang.foreign.MemorySegment _x4);
        static MemorySegment allocate(get_string_at_offset fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2019.const$0, fi, constants$1421.const$1, scope);
        }
        static get_string_at_offset ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, java.lang.foreign.MemorySegment __x3, java.lang.foreign.MemorySegment __x4) -> {
                try {
                    return (java.lang.foreign.MemorySegment)constants$2011.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle get_string_at_offset$VH() {
        return constants$2019.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * char* (*get_string_at_offset)(struct _AtkText*,int,enum AtkTextGranularity,int*,int*);
     * }
     */
    public static MemorySegment get_string_at_offset$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2019.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * char* (*get_string_at_offset)(struct _AtkText*,int,enum AtkTextGranularity,int*,int*);
     * }
     */
    public static void get_string_at_offset$set(MemorySegment seg, MemorySegment x) {
        constants$2019.const$1.set(seg, x);
    }
    public static MemorySegment get_string_at_offset$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2019.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void get_string_at_offset$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2019.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static get_string_at_offset get_string_at_offset(MemorySegment segment, Arena scope) {
        return get_string_at_offset.ofAddress(get_string_at_offset$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*scroll_substring_to)(struct _AtkText*,int,int,enum AtkScrollType);
     * }
     */
    public interface scroll_substring_to {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, int _x3);
        static MemorySegment allocate(scroll_substring_to fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2019.const$2, fi, constants$608.const$5, scope);
        }
        static scroll_substring_to ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, int __x3) -> {
                try {
                    return (int)constants$1995.const$1.invokeExact(symbol, __x0, __x1, __x2, __x3);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle scroll_substring_to$VH() {
        return constants$2019.const$3;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*scroll_substring_to)(struct _AtkText*,int,int,enum AtkScrollType);
     * }
     */
    public static MemorySegment scroll_substring_to$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2019.const$3.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*scroll_substring_to)(struct _AtkText*,int,int,enum AtkScrollType);
     * }
     */
    public static void scroll_substring_to$set(MemorySegment seg, MemorySegment x) {
        constants$2019.const$3.set(seg, x);
    }
    public static MemorySegment scroll_substring_to$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2019.const$3.get(seg.asSlice(index*sizeof()));
    }
    public static void scroll_substring_to$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2019.const$3.set(seg.asSlice(index*sizeof()), x);
    }
    public static scroll_substring_to scroll_substring_to(MemorySegment segment, Arena scope) {
        return scroll_substring_to.ofAddress(scroll_substring_to$get(segment), scope);
    }
    /**
     * {@snippet :
 * int (*scroll_substring_to_point)(struct _AtkText*,int,int,enum AtkCoordType,int,int);
     * }
     */
    public interface scroll_substring_to_point {

        int apply(java.lang.foreign.MemorySegment _x0, int _x1, int _x2, int _x3, int _x4, int _x5);
        static MemorySegment allocate(scroll_substring_to_point fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$2019.const$4, fi, constants$1942.const$3, scope);
        }
        static scroll_substring_to_point ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1, int __x2, int __x3, int __x4, int __x5) -> {
                try {
                    return (int)constants$1998.const$0.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4, __x5);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle scroll_substring_to_point$VH() {
        return constants$2019.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * int (*scroll_substring_to_point)(struct _AtkText*,int,int,enum AtkCoordType,int,int);
     * }
     */
    public static MemorySegment scroll_substring_to_point$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$2019.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * int (*scroll_substring_to_point)(struct _AtkText*,int,int,enum AtkCoordType,int,int);
     * }
     */
    public static void scroll_substring_to_point$set(MemorySegment seg, MemorySegment x) {
        constants$2019.const$5.set(seg, x);
    }
    public static MemorySegment scroll_substring_to_point$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$2019.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void scroll_substring_to_point$set(MemorySegment seg, long index, MemorySegment x) {
        constants$2019.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static scroll_substring_to_point scroll_substring_to_point(MemorySegment segment, Arena scope) {
        return scroll_substring_to_point.ofAddress(scroll_substring_to_point$get(segment), scope);
    }
    public static long sizeof() { return $LAYOUT().byteSize(); }
    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
    }
    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
}






© 2015 - 2025 Weber Informatics LLC | Privacy Policy