/* ATK - The Accessibility Toolkit for GTK+

 * Copyright 2001 Sun Microsystems Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include "atk.h"

#include "atkmarshal.h"

#include <string.h>

/**

 * AtkText:

 *

 * The ATK interface implemented by components with text content.

 *

 * #AtkText should be implemented by #AtkObjects on behalf of widgets

 * that have text content which is either attributed or otherwise

 * non-trivial.  #AtkObjects whose text content is simple,

 * unattributed, and very brief may expose that content via

 * #atk_object_get_name instead; however if the text is editable,

 * multi-line, typically longer than three or four words, attributed,

 * selectable, or if the object already uses the 'name' ATK property

 * for other information, the #AtkText interface should be used to

 * expose the text content.  In the case of editable text content,

 * #AtkEditableText (a subtype of the #AtkText interface) should be

 * implemented instead.

 *

 *  #AtkText provides not only traversal facilities and change

 * notification for text content, but also caret tracking and glyph

 * bounding box calculations.  Note that the text strings are exposed

 * as UTF-8, and are therefore potentially multi-byte, and

 * caret-to-byte offset mapping makes no assumptions about the

 * character length; also bounding box glyph-to-offset mapping may be

 * complex for languages which use ligatures.

 */

static GPtrArray *extra_attributes = NULL;

enum

{

  TEXT_CHANGED,

  TEXT_CARET_MOVED,

  TEXT_SELECTION_CHANGED,

  TEXT_ATTRIBUTES_CHANGED,

  TEXT_INSERT,

  TEXT_REMOVE,

  LAST_SIGNAL

};

static const char boolean[] =

    "false\0"

    "true";

static const guint8 boolean_offsets[] = {

  0, 6

};

static const char style[] =

    "normal\0"

    "oblique\0"

    "italic";

static const guint8 style_offsets[] = {

  0, 7, 15

};

static const char variant[] =

    "normal\0"

    "small_caps";

static const guint8 variant_offsets[] = {

  0, 7

};

static const char stretch[] =

    "ultra_condensed\0"

    "extra_condensed\0"

    "condensed\0"

    "semi_condensed\0"

    "normal\0"

    "semi_expanded\0"

    "expanded\0"

    "extra_expanded\0"

    "ultra_expanded";

static const guint8 stretch_offsets[] = {

  0, 16, 32, 42, 57, 64, 78, 87, 102

};

static const char justification[] =

    "left\0"

    "right\0"

    "center\0"

    "fill";

static const guint8 justification_offsets[] = {

  0, 5, 11, 18

};

static const char direction[] =

    "none\0"

    "ltr\0"

    "rtl";

static const guint8 direction_offsets[] = {

  0, 5, 9

};

static const char wrap_mode[] =

    "none\0"

    "char\0"

    "word\0"

    "word_char";

static const guint8 wrap_mode_offsets[] = {

  0, 5, 10, 15

};

static const char underline[] =

    "none\0"

    "single\0"

    "double\0"

    "low\0"

    "error";

static const guint8 underline_offsets[] = {

  0, 5, 12, 19, 23

};

static const char text_position[] =

    "baseline\0"

    "super\0"

    "sub\0";

static const guint8 text_position_offsets[] = {

  0,

  9,

  15,

};

static void atk_text_base_init (AtkTextIface *class);

static void atk_text_real_get_range_extents (AtkText *text,

                                             gint start_offset,

                                             gint end_offset,

                                             AtkCoordType coord_type,

                                             AtkTextRectangle *rect);

static AtkTextRange **atk_text_real_get_bounded_ranges (AtkText *text,

                                                        AtkTextRectangle *rect,

                                                        AtkCoordType coord_type,

                                                        AtkTextClipType x_clip_type,

                                                        AtkTextClipType y_clip_type);

static guint atk_text_signals[LAST_SIGNAL] = { 0 };

GType

{

  static GType type = 0;

    {

      static const GTypeInfo tinfo = {

        sizeof (AtkTextIface),

        (GBaseInitFunc) atk_text_base_init,

        (GBaseFinalizeFunc) NULL,

        (GClassInitFunc) NULL /* atk_text_interface_init */,

        (GClassFinalizeFunc) NULL,

      };

    }

}

static void

{

  static gboolean initialized = FALSE;

    {

      /*

       * Note that text_changed signal supports details "insert", "delete",

       * possibly "replace".

       */

      /**

       * AtkText::text-changed:

       * @atktext: the object which received the signal.

       * @arg1: The position (character offset) of the insertion or deletion.

       * @arg2: The length (in characters) of text inserted or deleted.

       *

       * The "text-changed" signal is emitted when the text of the

       * object which implements the AtkText interface changes, This

       * signal will have a detail which is either "insert" or

       * "delete" which identifies whether the text change was an

       * insertion or a deletion.

       *

       * Deprecated: 2.9.4: Use #AtkObject::text-insert or

       * #AtkObject::text-remove instead.

       */

                        ATK_TYPE_TEXT,

                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                        G_STRUCT_OFFSET (AtkTextIface, text_changed),

                        (GSignalAccumulator) NULL, NULL,

                        atk_marshal_VOID__INT_INT,

                        G_TYPE_NONE,

                        2, G_TYPE_INT, G_TYPE_INT);

      /**

       * AtkText::text-insert:

       * @atktext: the object which received the signal.

       * @arg1: The position (character offset) of the insertion.

       * @arg2: The length (in characters) of text inserted.

       * @arg3: The new text inserted

       *

       * The "text-insert" signal is emitted when a new text is

       * inserted. If the signal was not triggered by the user

       * (e.g. typing or pasting text), the "system" detail should be

       * included.

       */

                        ATK_TYPE_TEXT,

                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                        0,

                        (GSignalAccumulator) NULL, NULL,

                        atk_marshal_VOID__INT_INT_STRING,

                        G_TYPE_NONE,

                        3, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING);

      /**

       * AtkText::text-remove:

       * @atktext: the object which received the signal.

       * @arg1: The position (character offset) of the removal.

       * @arg2: The length (in characters) of text removed.

       * @arg3: The old text removed

       *

       * The "text-remove" signal is emitted when a new text is

       * removed. If the signal was not triggered by the user

       * (e.g. typing or pasting text), the "system" detail should be

       * included.

       */

                        ATK_TYPE_TEXT,

                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                        0,

                        (GSignalAccumulator) NULL, NULL,

                        atk_marshal_VOID__INT_INT_STRING,

                        G_TYPE_NONE,

                        3, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING);

      /**

       * AtkText::text-caret-moved:

       * @atktext: the object which received the signal.

       * @arg1: The new position of the text caret.

       *

       * The "text-caret-moved" signal is emitted when the caret

       * position of the text of an object which implements AtkText

       * changes.

       */

                        ATK_TYPE_TEXT,

                        G_SIGNAL_RUN_LAST,

                        G_STRUCT_OFFSET (AtkTextIface, text_caret_moved),

                        (GSignalAccumulator) NULL, NULL,

                        g_cclosure_marshal_VOID__INT,

                        G_TYPE_NONE,

                        1, G_TYPE_INT);

      /**

       * AtkText::text-selection-changed:

       * @atktext: the object which received the signal.

       *

       * The "text-selection-changed" signal is emitted when the

       * selected text of an object which implements AtkText changes.

       */

                        ATK_TYPE_TEXT,

                        G_SIGNAL_RUN_LAST,

                        G_STRUCT_OFFSET (AtkTextIface, text_selection_changed),

                        (GSignalAccumulator) NULL, NULL,

                        g_cclosure_marshal_VOID__VOID,

                        G_TYPE_NONE, 0);

      /**

       * AtkText::text-attributes-changed:

       * @atktext: the object which received the signal.

       *

       * The "text-attributes-changed" signal is emitted when the text

       * attributes of the text of an object which implements AtkText

       * changes.

       */

                        ATK_TYPE_TEXT,

                        G_SIGNAL_RUN_LAST,

                        G_STRUCT_OFFSET (AtkTextIface, text_attributes_changed),

                        (GSignalAccumulator) NULL, NULL,

                        g_cclosure_marshal_VOID__VOID,

                        G_TYPE_NONE, 0);

    }

/**

 * atk_text_get_text:

 * @text: an #AtkText

 * @start_offset: a starting character offset within @text

 * @end_offset: an ending character offset within @text, or -1 for the end of the string.

 *

 * Gets the specified text.

 *

 * Returns: a newly allocated string containing the text from @start_offset up

 *          to, but not including @end_offset. Use g_free() to free the returned

 *          string.

 **/

gchar *

                   gint start_offset,

                   gint end_offset)

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_get_character_at_offset:

 * @text: an #AtkText

 * @offset: a character offset within @text

 *

 * Gets the specified text.

 *

 * Returns: the character at @offset or 0 in the case of failure.

 **/

gunichar

                                  gint offset)

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_get_text_after_offset:

 * @text: an #AtkText

 * @offset: position

 * @boundary_type: An #AtkTextBoundary

 * @start_offset: (out): the starting character offset of the returned string

 * @end_offset: (out): the offset of the first character after the

 *              returned substring

 *

 * Gets the specified text.

 *

 * Deprecated: 2.9.3: Please use atk_text_get_string_at_offset() instead.

 *

 * Returns: a newly allocated string containing the text after @offset bounded

 *          by the specified @boundary_type. Use g_free() to free the returned

 *          string.

 **/

gchar *

                                gint offset,

                                AtkTextBoundary boundary_type,

                                gint *start_offset,

                                gint *end_offset)

{

  AtkTextIface *iface;

  gint local_start_offset, local_end_offset;

  gint *real_start_offset, *real_end_offset;

  else

  else

  else

}

/**

 * atk_text_get_text_at_offset:

 * @text: an #AtkText

 * @offset: position

 * @boundary_type: An #AtkTextBoundary

 * @start_offset: (out): the starting character offset of the returned string

 * @end_offset: (out): the offset of the first character after the

 *              returned substring

 *

 * Gets the specified text.

 *

 * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the

 * offset is returned.

 *

 * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string

 * is from the word start at or before the offset to the word start after

 * the offset.

 *

 * The returned string will contain the word at the offset if the offset

 * is inside a word and will contain the word before the offset if the

 * offset is not inside a word.

 *

 * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned

 * string is from the sentence start at or before the offset to the sentence

 * start after the offset.

 *

 * The returned string will contain the sentence at the offset if the offset

 * is inside a sentence and will contain the sentence before the offset

 * if the offset is not inside a sentence.

 *

 * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned

 * string is from the line start at or before the offset to the line

 * start after the offset.

 *

 * Deprecated: This method is deprecated since ATK version

 * 2.9.4. Please use atk_text_get_string_at_offset() instead.

 *

 * Returns: a newly allocated string containing the text at @offset bounded

 *          by the specified @boundary_type. Use g_free() to free the returned

 *          string.

 **/

gchar *

                             gint offset,

                             AtkTextBoundary boundary_type,

                             gint *start_offset,

                             gint *end_offset)

{

  AtkTextIface *iface;

  gint local_start_offset, local_end_offset;

  gint *real_start_offset, *real_end_offset;

  else

  else

  else

}

/**

 * atk_text_get_text_before_offset:

 * @text: an #AtkText

 * @offset: position

 * @boundary_type: An #AtkTextBoundary

 * @start_offset: (out): the starting character offset of the returned string

 * @end_offset: (out): the offset of the first character after the

 *              returned substring

 *

 * Gets the specified text.

 *

 * Deprecated: 2.9.3: Please use atk_text_get_string_at_offset() instead.

 *

 * Returns: a newly allocated string containing the text before @offset bounded

 *          by the specified @boundary_type. Use g_free() to free the returned

 *          string.

 **/

gchar *

                                 gint offset,

                                 AtkTextBoundary boundary_type,

                                 gint *start_offset,

                                 gint *end_offset)

{

  AtkTextIface *iface;

  gint local_start_offset, local_end_offset;

  gint *real_start_offset, *real_end_offset;

  else

  else

  else

}

/**

 * atk_text_get_string_at_offset:

 * @text: an #AtkText

 * @offset: position

 * @granularity: An #AtkTextGranularity

 * @start_offset: (out): the starting character offset of the returned string, or -1

 *                in the case of error (e.g. invalid offset, not implemented)

 * @end_offset: (out): the offset of the first character after the returned string,

 *              or -1 in the case of error (e.g. invalid offset, not implemented)

 *

 * Gets a portion of the text exposed through an #AtkText according to a given @offset

 * and a specific @granularity, along with the start and end offsets defining the

 * boundaries of such a portion of text.

 *

 * If @granularity is ATK_TEXT_GRANULARITY_CHAR the character at the

 * offset is returned.

 *

 * If @granularity is ATK_TEXT_GRANULARITY_WORD the returned string

 * is from the word start at or before the offset to the word start after

 * the offset.

 *

 * The returned string will contain the word at the offset if the offset

 * is inside a word and will contain the word before the offset if the

 * offset is not inside a word.

 *

 * If @granularity is ATK_TEXT_GRANULARITY_SENTENCE the returned string

 * is from the sentence start at or before the offset to the sentence

 * start after the offset.

 *

 * The returned string will contain the sentence at the offset if the offset

 * is inside a sentence and will contain the sentence before the offset

 * if the offset is not inside a sentence.

 *

 * If @granularity is ATK_TEXT_GRANULARITY_LINE the returned string

 * is from the line start at or before the offset to the line

 * start after the offset.

 *

 * If @granularity is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string

 * is from the start of the paragraph at or before the offset to the start

 * of the following paragraph after the offset.

 *

 * Since: 2.10

 *

 * Returns: (nullable): a newly allocated string containing the text at

 *          the @offset bounded by the specified @granularity. Use g_free()

 *          to free the returned string.  Returns %NULL if the offset is invalid

 *          or no implementation is available.

 **/

gchar *

                               gint offset,

                               AtkTextGranularity granularity,

                               gint *start_offset,

                               gint *end_offset)

{

  AtkTextIface *iface;

  gint local_start_offset, local_end_offset;

  gint *real_start_offset, *real_end_offset;

    {

    }

  else

    {

    }

  else

  else

}

/**

 * atk_text_get_caret_offset:

 * @text: an #AtkText

 *

 * Gets the offset of the position of the caret (cursor).

 *

 * Returns: the character offset of the position of the caret or -1 if

 *          the caret is not located inside the element or in the case of

 *          any other failure.

 **/

gint

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_get_character_extents:

 * @text: an #AtkText

 * @offset: The offset of the text character for which bounding information is required.

 * @x: (out) (optional): Pointer for the x coordinate of the bounding box

 * @y: (out) (optional): Pointer for the y coordinate of the bounding box

 * @width: (out) (optional): Pointer for the width of the bounding box

 * @height: (out) (optional): Pointer for the height of the bounding box

 * @coords: specify whether coordinates are relative to the screen or widget window

 *

 * If the extent can not be obtained (e.g. missing support), all of x, y, width,

 * height are set to -1.

 *

 * Get the bounding box containing the glyph representing the character at

 *     a particular text offset.

 **/

void

                                gint offset,

                                gint *x,

                                gint *y,

                                gint *width,

                                gint *height,

                                AtkCoordType coords)

{

  AtkTextIface *iface;

  gint local_x, local_y, local_width, local_height;

  gint *real_x, *real_y, *real_width, *real_height;

  else

  else

  else

  else

    {

    }

}

/**

 * atk_text_get_run_attributes:

 *@text: an #AtkText

 *@offset: the character offset at which to get the attributes, -1 means the offset of

 *the character to be inserted at the caret location.

 *@start_offset: (out): the address to put the start offset of the range

 *@end_offset: (out): the address to put the end offset of the range

 *

 *Creates an #AtkAttributeSet which consists of the attributes explicitly

 *set at the position @offset in the text. @start_offset and @end_offset are

 *set to the start and end of the range around @offset where the attributes are

 *invariant. Note that @end_offset is the offset of the first character

 *after the range.  See the enum AtkTextAttribute for types of text

 *attributes that can be returned. Note that other attributes may also be

 *returned.

 *

 *Returns: (transfer full): an #AtkAttributeSet which contains the attributes

 *         explicitly set at @offset. This #AtkAttributeSet should be freed by

 *         a call to atk_attribute_set_free().

 **/

AtkAttributeSet *

                             gint offset,

                             gint *start_offset,

                             gint *end_offset)

{

  AtkTextIface *iface;

  gint local_start_offset, local_end_offset;

  gint *real_start_offset, *real_end_offset;

  else

  else

  else

}

/**

 * atk_text_get_default_attributes:

 *@text: an #AtkText

 *

 *Creates an #AtkAttributeSet which consists of the default values of

 *attributes for the text. See the enum AtkTextAttribute for types of text

 *attributes that can be returned. Note that other attributes may also be

 *returned.

 *

 *Returns: (transfer full): an #AtkAttributeSet which contains the default text

 *          attributes for this #AtkText. This #AtkAttributeSet should be freed by

 *          a call to atk_attribute_set_free().

 */

AtkAttributeSet *

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_get_character_count:

 * @text: an #AtkText

 *

 * Gets the character count.

 *

 * Returns: the number of characters or -1 in case of failure.

 **/

gint

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_get_offset_at_point:

 * @text: an #AtkText

 * @x: screen x-position of character

 * @y: screen y-position of character

 * @coords: specify whether coordinates are relative to the screen or

 * widget window

 *

 * Gets the offset of the character located at coordinates @x and @y. @x and @y

 * are interpreted as being relative to the screen or this widget's window

 * depending on @coords.

 *

 * Returns: the offset to the character which is located at  the specified

 *          @x and @y coordinates of -1 in case of failure.

 **/

gint

                              gint x,

                              gint y,

                              AtkCoordType coords)

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_get_n_selections:

 * @text: an #AtkText

 *

 * Gets the number of selected regions.

 *

 * Returns: The number of selected regions, or -1 in the case of failure.

 **/

gint

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_get_selection:

 * @text: an #AtkText

 * @selection_num: The selection number.  The selected regions are

 * assigned numbers that correspond to how far the region is from the

 * start of the text.  The selected region closest to the beginning

 * of the text region is assigned the number 0, etc.  Note that adding,

 * moving or deleting a selected region can change the numbering.

 * @start_offset: (out): passes back the starting character offset of the selected region

 * @end_offset: (out): passes back the ending character offset (offset immediately past)

 * of the selected region

 *

 * Gets the text from the specified selection.

 *

 * Returns: a newly allocated string containing the selected text. Use g_free()

 *          to free the returned string.

 **/

gchar *

                        gint selection_num,

                        gint *start_offset,

                        gint *end_offset)

{

  AtkTextIface *iface;

  gint local_start_offset, local_end_offset;

  gint *real_start_offset, *real_end_offset;

  else

  else

    {

                                        real_start_offset, real_end_offset);

    }

  else

}

/**

 * atk_text_add_selection:

 * @text: an #AtkText

 * @start_offset: the starting character offset of the selected region

 * @end_offset: the offset of the first character after the selected region.

 *

 * Adds a selection bounded by the specified offsets.

 *

 * Returns: %TRUE if successful, %FALSE otherwise

 **/

gboolean

                        gint start_offset,

                        gint end_offset)

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_remove_selection:

 * @text: an #AtkText

 * @selection_num: The selection number.  The selected regions are

 * assigned numbers that correspond to how far the region is from the

 * start of the text.  The selected region closest to the beginning

 * of the text region is assigned the number 0, etc.  Note that adding,

 * moving or deleting a selected region can change the numbering.

 *

 * Removes the specified selection.

 *

 * Returns: %TRUE if successful, %FALSE otherwise

 **/

gboolean

                           gint selection_num)

{

  AtkTextIface *iface;

  else

}

/**

 * atk_text_set_selection:

 * @text: an #AtkText

 * @selection_num: The selection number.  The selected regions are

 * assigned numbers that correspond to how far the region is from the

 * start of the text.  The selected region closest to the beginning

 * of the text region is assigned the number 0, etc.  Note that adding,

 * moving or deleting a selected region can change the numbering.

 * @start_offset: the new starting character offset of the selection

 * @end_offset: the new end position of (e.g. offset immediately past)

 * the selection

 *

 * Changes the start and end offset of the specified selection.

 *

 * Returns: %TRUE if successful, %FALSE otherwise

 **/

gboolean

                        gint selection_num,

                        gint start_offset,

                        gint end_offset)

{

  AtkTextIface *iface;

    {

                                        start_offset, end_offset);

    }

  else

}

/**

 * atk_text_set_caret_offset:

 * @text: an #AtkText

 * @offset: the character offset of the new caret position

 *

 * Sets the caret (cursor) position to the specified @offset.

 *

 * In the case of rich-text content, this method should either grab focus

 * or move the sequential focus navigation starting point (if the application

 * supports this concept) as if the user had clicked on the new caret position.

 * Typically, this means that the target of this operation is the node containing

 * the new caret position or one of its ancestors. In other words, after this

 * method is called, if the user advances focus, it should move to the first

 * focusable node following the new caret position.

 *

 * Calling this method should also scroll the application viewport in a way

 * that matches the behavior of the application's typical caret motion or tab

 * navigation as closely as possible. This also means that if the application's

 * caret motion or focus navigation does not trigger a scroll operation, this

 * method should not trigger one either. If the application does not have a caret

 * motion or focus navigation operation, this method should try to scroll the new

 * caret position into view while minimizing unnecessary scroll motion.

 *

 * Returns: %TRUE if successful, %FALSE otherwise.

 **/

gboolean

                           gint offset)

{

  AtkTextIface *iface;

    {

    }

  else

    {

    }

}

/**

 * atk_text_get_range_extents:

 * @text: an #AtkText

 * @start_offset: The offset of the first text character for which boundary

 *        information is required.

 * @end_offset: The offset of the text character after the last character

 *        for which boundary information is required.

 * @coord_type: Specify whether coordinates are relative to the screen or widget window.

 * @rect: (out): A pointer to a AtkTextRectangle which is filled in by this function.

 *

 * Get the bounding box for text within the specified range.

 *

 * If the extents can not be obtained (e.g. or missing support), the rectangle

 * fields are set to -1.

 *

 * Since: 1.3

 **/

void

                            gint start_offset,

                            gint end_offset,

                            AtkCoordType coord_type,

                            AtkTextRectangle *rect)

{

  AtkTextIface *iface;

  else

    {

    }

}

/**

 * atk_text_get_bounded_ranges: (virtual get_bounded_ranges)

 * @text: an #AtkText

 * @rect: An AtkTextRectangle giving the dimensions of the bounding box.

 * @coord_type: Specify whether coordinates are relative to the screen or widget window.

 * @x_clip_type: Specify the horizontal clip type.

 * @y_clip_type: Specify the vertical clip type.

 *

 * Get the ranges of text in the specified bounding box.

 *

 * Since: 1.3

 *

 * Returns: (array zero-terminated=1): Array of AtkTextRange. The last

 *          element of the array returned by this function will be NULL.

 **/

AtkTextRange **

                             AtkTextRectangle *rect,

                             AtkCoordType coord_type,

                             AtkTextClipType x_clip_type,

                             AtkTextClipType y_clip_type)

{

  AtkTextIface *iface;

  else

}

/**

 * atk_attribute_set_free:

 * @attrib_set: The #AtkAttributeSet to free

 *

 * Frees the memory used by an #AtkAttributeSet, including all its

 * #AtkAttributes.

 **/

void

{

  GSList *temp;

    {

      AtkAttribute *att;

    }

/**

 * atk_text_attribute_register:

 * @name: a name string

 *

 * Associate @name with a new #AtkTextAttribute

 *

 * Returns: an #AtkTextAttribute associated with @name

 **/

AtkTextAttribute

{

}

/**

 * atk_text_attribute_get_name:

 * @attr: The #AtkTextAttribute whose name is required

 *

 * Gets the name corresponding to the #AtkTextAttribute

 *

 * Returns: a string containing the name; this string should not be freed

 **/

const gchar *

{

  GTypeClass *type_class;

  GEnumValue *value;

    {

    }

  else

    {

        {

        }

    }

}

/**

 * atk_text_attribute_for_name:

 * @name: a string which is the (non-localized) name of an ATK text attribute.

 *

 * Get the #AtkTextAttribute type corresponding to a text attribute name.

 *

 * Returns: the #AtkTextAttribute enumerated type corresponding to the specified

 *          name, or #ATK_TEXT_ATTRIBUTE_INVALID if no matching text attribute

 *          is found.

 **/

AtkTextAttribute

{

  GTypeClass *type_class;

  GEnumValue *value;

    {

    }

  else

    {

      gint i;

        {

            {

                {

                }

            }

        }

    }

}

/**

 * atk_text_attribute_get_value:

 * @attr: The #AtkTextAttribute for which a value is required

 * @index_: The index of the required value

 *

 * Gets the value for the index of the #AtkTextAttribute

 *

 * Returns: (nullable): a string containing the value; this string

 * should not be freed; %NULL is returned if there are no values

 * maintained for the attr value.

 **/

const gchar *

                              gint index)

{

    {

    case ATK_TEXT_ATTR_EDITABLE:

    case ATK_TEXT_ATTR_BG_FULL_HEIGHT:

    case ATK_TEXT_ATTR_STRIKETHROUGH:

    case ATK_TEXT_ATTR_BG_STIPPLE:

    case ATK_TEXT_ATTR_FG_STIPPLE: