Attachment #288247 for bug #384919

View | Details | Raw Unified | Return to bug 384919
Collapse All | Expand All




 * Returns a description string, or %NULL
 * if @action does not implement this interface.
 **/
const gchar*
atk_action_get_description (AtkAction *obj,
                            gint      i)
{

 * Returns a name string, or %NULL
 * if @action does not implement this interface.
 **/
const gchar*
atk_action_get_name (AtkAction *obj,
                     gint      i)
{

 * Returns a name string, or %NULL
 * if @action does not implement this interface.
 **/
const gchar*
atk_action_get_localized_name (AtkAction *obj,
                               gint      i)
{

 * if there is no keybinding for this action.
 *
 **/
const gchar*
atk_action_get_keybinding (AtkAction *obj,
                           gint      i)
{




  gboolean                (*do_action)         (AtkAction         *action,
                                                gint              i);
  gint                    (*get_n_actions)     (AtkAction         *action);
  const gchar*   (*get_description)   (AtkAction         *action,
                                                gint              i);
  const gchar*   (*get_name)          (AtkAction         *action,
                                                gint              i);
  const gchar*   (*get_keybinding)    (AtkAction         *action,
                                                gint              i);
  gboolean                (*set_description)   (AtkAction         *action,
                                                gint              i,
                                                const gchar       *desc);
  const gchar*   (*get_localized_name)(AtkAction         *action,
						gint              i);
  AtkFunction             pad2;
};

gboolean   atk_action_do_action                (AtkAction         *action,
                                            gint              i);
gint   atk_action_get_n_actions            (AtkAction *action);
const gchar* atk_action_get_description  (AtkAction         *action,
                                                   gint              i);
const gchar* atk_action_get_name         (AtkAction         *action,
                                                   gint              i);
const gchar* atk_action_get_keybinding   (AtkAction         *action,
                                                   gint              i);
gboolean              atk_action_set_description  (AtkAction         *action,
                                                   gint              i,


/* NEW in ATK 1.1: */

const gchar* atk_action_get_localized_name (AtkAction       *action,
						     gint            i);

/*




 *
 * Returns: a string indicating the document type
 **/
const gchar*
atk_document_get_document_type (AtkDocument *document)
{
  AtkDocumentIface *iface;

 *          locale of the document content as a whole, or NULL if
 *          the document content does not specify a locale.
 **/
const gchar *
atk_document_get_locale (AtkDocument *document)
{
  AtkDocumentIface *iface;

 *    document, or NULL if a value for #attribute_name has not been specified
 *    for this document.
 */
const gchar *
atk_document_get_attribute_value (AtkDocument *document, 
				  const gchar *attribute_name)
{




struct _AtkDocumentIface
{
  GTypeInterface parent;
  const gchar* ( *get_document_type) (AtkDocument              *document);
  gpointer              ( *get_document)      (AtkDocument              *document);

  const gchar* ( *get_document_locale) (AtkDocument              *document);
  AtkAttributeSet *     ( *get_document_attributes) (AtkDocument        *document);
  const gchar* ( *get_document_attribute_value) (AtkDocument   *document,
                                                          const gchar   *attribute_name);
  gboolean              ( *set_document_attribute) (AtkDocument         *document,
                                                    const gchar         *attribute_name,


GType  atk_document_get_type             (void);

const gchar* atk_document_get_document_type (AtkDocument   *document);
gpointer atk_document_get_document (AtkDocument   *document);
const gchar* atk_document_get_locale (AtkDocument *document);
AtkAttributeSet*      atk_document_get_attributes (AtkDocument *document);
const gchar* atk_document_get_attribute_value (AtkDocument *document, 
                                                        const gchar *attribute_name);
gboolean              atk_document_set_attribute_value (AtkDocument *document,
                                                        const gchar *attribute_name,

Lines 46-52 Link Here

(-)atk-1.32.0_ORIG/atk/atkimage.c (-2 / +2 lines)
46	*	46	*
47	* Returns: a string representing the image description	47	* Returns: a string representing the image description
48	**/	48	**/
49	G_CONST_RETURN gchar*	49	const gchar*
50	atk_image_get_image_description (AtkImage *image)	50	atk_image_get_image_description (AtkImage *image)
51	{	51	{
52	AtkImageIface *iface;	52	AtkImageIface *iface;
Lines 192-198 Link Here
192	* Returns a string corresponding to the POSIX LC_MESSAGES locale used by the image description, or NULL if the image does not specify a locale.	192	* Returns a string corresponding to the POSIX LC_MESSAGES locale used by the image description, or NULL if the image does not specify a locale.
193	*	193	*
194	*/	194	*/
195	G_CONST_RETURN gchar*	195	const gchar*
196	atk_image_get_image_locale (AtkImage *image)	196	atk_image_get_image_locale (AtkImage *image)
197	{	197	{
198		198




                                                   gint                  *x,
				                   gint	                 *y,
    			                           AtkCoordType	         coord_type);
  const gchar* ( *get_image_description) (AtkImage              *image);
  void                  ( *get_image_size)        (AtkImage              *image,
                                                   gint                  *width,
                                                   gint                  *height);
  gboolean              ( *set_image_description) (AtkImage              *image,
                                                   const gchar           *description);
  const gchar* ( *get_image_locale)      (AtkImage              *image);

  AtkFunction           pad1;
	


GType  atk_image_get_type             (void);

const gchar* atk_image_get_image_description (AtkImage   *image);

void     atk_image_get_image_size        (AtkImage           *image,
                                          gint               *width,

					  gint	             *y,
    					  AtkCoordType	     coord_type);

const gchar* atk_image_get_image_locale (AtkImage   *image);

G_END_DECLS





                                                     GValue          *value,
                                                     GParamSpec      *pspec);
static void            atk_object_finalize          (GObject         *object);
static const gchar*
                       atk_object_real_get_name     (AtkObject       *object);
static const gchar*
                       atk_object_real_get_description    
                                                   (AtkObject       *object);
static AtkObject*      atk_object_real_get_parent  (AtkObject       *object);

 *
 * Returns: a character string representing the accessible name of the object.
 **/
const gchar*
atk_object_get_name (AtkObject *accessible)
{
  AtkObjectClass *klass;

 * of the accessible.
 *
 **/
const gchar*
atk_object_get_description (AtkObject *accessible)
{
  AtkObjectClass *klass;

                                AtkState  state,
                                gboolean  value)
{
  const gchar* name;

  g_return_if_fail (ATK_IS_OBJECT (accessible));


  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static const gchar*
atk_object_real_get_name (AtkObject *object)
{
  return object->name;
}

static const gchar*
atk_object_real_get_description (AtkObject *object)
{
  return object->description;

 *
 * Returns: the string describing the AtkRole
 */
const gchar*
atk_role_get_name (AtkRole role)
{
  if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)

 *
 * Returns: the localized string describing the AtkRole
 **/
const gchar*
atk_role_get_localized_name (AtkRole role)
{
  gettext_initialization ();




  /*
   * Gets the accessible name of the object
   */
  const gchar*    (* get_name)            (AtkObject                *accessible);
  /*
   * Gets the accessible description of the object
   */
  const gchar*    (* get_description)     (AtkObject                *accessible);
  /*
   * Gets the accessible parent of the object
   */

 * Properties directly supported by AtkObject
 */

const gchar*   atk_object_get_name                       (AtkObject *accessible);
const gchar*   atk_object_get_description                (AtkObject *accessible);
AtkObject*              atk_object_get_parent                     (AtkObject *accessible);
gint                    atk_object_get_n_accessible_children      (AtkObject *accessible);
AtkObject*              atk_object_ref_accessible_child           (AtkObject *accessible,

void                 atk_object_initialize                       (AtkObject                     *accessible,
                                                                  gpointer                      data);
                                    
const gchar* atk_role_get_name      (AtkRole         role);
AtkRole               atk_role_for_name      (const gchar     *name);



gboolean              atk_object_remove_relationship           (AtkObject      *object,
								AtkRelationType relationship,
								AtkObject      *target);
const gchar* atk_role_get_localized_name              (AtkRole     role);

/* */


Lines 130-136 Link Here

(-)atk-1.32.0_ORIG/atk/atkrelation.c (-1 / +1 lines)
130	*	130	*
131	* Returns: the string describing the AtkRelationType	131	* Returns: the string describing the AtkRelationType
132	*/	132	*/
133	G_CONST_RETURN gchar*	133	const gchar*
134	atk_relation_type_get_name (AtkRelationType type)	134	atk_relation_type_get_name (AtkRelationType type)
135	{	135	{
136	GTypeClass *type_class;	136	GTypeClass *type_class;

Lines 61-67 Link Here

(-)atk-1.32.0_ORIG/atk/atkrelation.h (-1 / +1 lines)
61	GType atk_relation_get_type (void);	61	GType atk_relation_get_type (void);
62		62
63	AtkRelationType atk_relation_type_register (const gchar *name);	63	AtkRelationType atk_relation_type_register (const gchar *name);
64	G_CONST_RETURN gchar* atk_relation_type_get_name (AtkRelationType type);	64	const gchar* atk_relation_type_get_name (AtkRelationType type);
65	AtkRelationType atk_relation_type_for_name (const gchar *name);	65	AtkRelationType atk_relation_type_for_name (const gchar *name);
66		66
67	/*	67	/*

Lines 57-63 Link Here

(-)atk-1.32.0_ORIG/atk/atkstate.c (-1 / +1 lines)
57	*	57	*
58	* Returns: the string describing the AtkStateType	58	* Returns: the string describing the AtkStateType
59	*/	59	*/
60	G_CONST_RETURN gchar*	60	const gchar*
61	atk_state_type_get_name (AtkStateType type)	61	atk_state_type_get_name (AtkStateType type)
62	{	62	{
63	GTypeClass *type_class;	63	GTypeClass *type_class;

Lines 170-176 Link Here

(-)atk-1.32.0_ORIG/atk/atkstate.h (-1 / +1 lines)
170		170
171	AtkStateType atk_state_type_register (const gchar *name);	171	AtkStateType atk_state_type_register (const gchar *name);
172		172
173	G_CONST_RETURN gchar* atk_state_type_get_name (AtkStateType type);	173	const gchar* atk_state_type_get_name (AtkStateType type);
174	AtkStateType atk_state_type_for_name (const gchar *name);	174	AtkStateType atk_state_type_for_name (const gchar *name);
175		175
176	G_END_DECLS	176	G_END_DECLS

Lines 73-79 Link Here

(-)atk-1.32.0_ORIG/atk/atkstreamablecontent.c (-1 / +1 lines)
73	* Returns : a gchar* representing the specified mime type; the caller	73	* Returns : a gchar* representing the specified mime type; the caller
74	* should not free the character string.	74	* should not free the character string.
75	**/	75	**/
76	G_CONST_RETURN gchar*	76	const gchar*
77	atk_streamable_content_get_mime_type (AtkStreamableContent *streamable,	77	atk_streamable_content_get_mime_type (AtkStreamableContent *streamable,
78	gint i)	78	gint i)
79	{	79	{




   * at index 0 should be considered the "default" data type for the stream.
   *
   * This assumes that the strings for the mime types are stored in the
   * AtkStreamableContent. Alternatively the const could be removed
   * and the caller would be responsible for calling g_free() on the
   * returned value.
   */
  const gchar*     (* get_mime_type)     (AtkStreamableContent     *streamable,
                                                   gint                     i);
  /*
   * One possible implementation for this method is that it constructs the

 * constructed.  Note that it is possible for get_uri to return NULL but for
 * get_stream to work nonetheless, since not all GIOChannels connect to URIs.
 */
    const  gchar*  (* get_uri)           (AtkStreamableContent     *streamable,
                                                   const gchar              *mime_type);




gint                   atk_streamable_content_get_n_mime_types (AtkStreamableContent     *streamable);
                                                       
const gchar*  atk_streamable_content_get_mime_type    (AtkStreamableContent     *streamable,
                                                                gint                     i);
GIOChannel*             atk_streamable_content_get_stream       (AtkStreamableContent     *streamable,
                                                                 const gchar              *mime_type);

Lines 300-306 Link Here

(-)atk-1.32.0_ORIG/atk/atktable.c (-2 / +2 lines)
300	* Returns: a gchar* representing the column description, or %NULL	300	* Returns: a gchar* representing the column description, or %NULL
301	* if value does not implement this interface.	301	* if value does not implement this interface.
302	**/	302	**/
303	G_CONST_RETURN gchar*	303	const gchar*
304	atk_table_get_column_description (AtkTable *table,	304	atk_table_get_column_description (AtkTable *table,
305	gint column)	305	gint column)
306	{	306	{
Lines 404-410 Link Here
404	* Returns: a gchar* representing the row description, or %NULL	404	* Returns: a gchar* representing the row description, or %NULL
405	* if value does not implement this interface.	405	* if value does not implement this interface.
406	**/	406	**/
407	G_CONST_RETURN gchar*	407	const gchar*
408	atk_table_get_row_description (AtkTable *table,	408	atk_table_get_row_description (AtkTable *table,
409	gint row)	409	gint row)
410	{	410	{




                                                  gint          column);
  AtkObject*
                    (* get_caption)              (AtkTable      *table);
  const gchar*
                    (* get_column_description)   (AtkTable      *table,
                                                  gint          column);
  AtkObject*        (* get_column_header)        (AtkTable      *table,
						  gint		column);
  const gchar*
                    (* get_row_description)      (AtkTable      *table,
                                                  gint          row);
  AtkObject*        (* get_row_header)           (AtkTable      *table,

                                                  gint             column);
AtkObject*
                  atk_table_get_caption          (AtkTable         *table);
const gchar*
                  atk_table_get_column_description (AtkTable         *table,
                                                  gint             column);
AtkObject*        atk_table_get_column_header    (AtkTable         *table,
						  gint		   column);
const gchar*
                  atk_table_get_row_description  (AtkTable         *table,
                                                  gint             row);
AtkObject*        atk_table_get_row_header       (AtkTable         *table,

Lines 1054-1060 Link Here

(-)atk-1.32.0_ORIG/atk/atktext.c (-2 / +2 lines)
1054	*	1054	*
1055	* Returns: a string containing the name; this string should not be freed	1055	* Returns: a string containing the name; this string should not be freed
1056	**/	1056	**/
1057	G_CONST_RETURN gchar*	1057	const gchar*
1058	atk_text_attribute_get_name (AtkTextAttribute attr)	1058	atk_text_attribute_get_name (AtkTextAttribute attr)
1059	{	1059	{
1060	GTypeClass *type_class;	1060	GTypeClass *type_class;
Lines 1150-1156 Link Here
1150	* Returns: a string containing the value; this string should not be freed;	1150	* Returns: a string containing the value; this string should not be freed;
1151	* NULL is returned if there are no values maintained for the attr value.	1151	* NULL is returned if there are no values maintained for the attr value.
1152	**/	1152	**/
1153	G_CONST_RETURN gchar*	1153	const gchar*
1154	atk_text_attribute_get_value (AtkTextAttribute attr,	1154	atk_text_attribute_get_value (AtkTextAttribute attr,
1155	gint index)	1155	gint index)
1156	{	1156	{

Lines 355-363 Link Here

(-)atk-1.32.0_ORIG/atk/atktext.h (-2 / +2 lines)
355	AtkTextClipType y_clip_type);	355	AtkTextClipType y_clip_type);
356	void atk_text_free_ranges (AtkTextRange **ranges);	356	void atk_text_free_ranges (AtkTextRange **ranges);
357	void atk_attribute_set_free (AtkAttributeSet *attrib_set);	357	void atk_attribute_set_free (AtkAttributeSet *attrib_set);
358	G_CONST_RETURN gchar* atk_text_attribute_get_name (AtkTextAttribute attr);	358	const gchar* atk_text_attribute_get_name (AtkTextAttribute attr);
359	AtkTextAttribute atk_text_attribute_for_name (const gchar *name);	359	AtkTextAttribute atk_text_attribute_for_name (const gchar *name);
360	G_CONST_RETURN gchar* atk_text_attribute_get_value (AtkTextAttribute attr,	360	const gchar* atk_text_attribute_get_value (AtkTextAttribute attr,
361	gint index_);	361	gint index_);
362		362
363	G_END_DECLS	363	G_END_DECLS




 *
 * Returns: name string for the GUI toolkit implementing ATK for this application
 **/
const gchar*
atk_get_toolkit_name (void)
{
  const gchar *retval;

 *
 * Returns: version string for the GUI toolkit implementing ATK for this application
 **/
const gchar*
atk_get_toolkit_version (void)
{
  const gchar *retval;

 * Returns: version string for ATK
 **/

const gchar *
atk_get_version (void)
{
  return VERSION;




						  gpointer data);
   void         (* remove_key_event_listener)    (guint               listener_id);
   AtkObject*   (* get_root)                     (void);
   const gchar* (* get_toolkit_name)    (void);
   const gchar* (* get_toolkit_version) (void);
};
GType atk_util_get_type (void);


/*
 * Returns name string for the GUI toolkit.
 */
const gchar *atk_get_toolkit_name (void);

/*
 * Returns version string for the GUI toolkit.
 */
const gchar *atk_get_toolkit_version (void);

/*
 * Gets the current version of ATK
 */
const gchar *atk_get_version (void);

/* --- GType boilerplate --- */
/* convenience macros for atk type implementations, which for a type GtkGadgetAccessible will:

Lines 3047-3053 Link Here

(-)atk-1.32.0_ORIG/ChangeLog (-1 / +1 lines)
3047	Change AtkHyperLink to AtkHyperlink	3047	Change AtkHyperLink to AtkHyperlink
3048	* atk/atktable.[c\|h]:	3048	* atk/atktable.[c\|h]:
3049	Make gchar* arguments const; make return value of type gchar*	3049	Make gchar* arguments const; make return value of type gchar*
3050	G_CONST_RETURN	3050	const
3051	* docs/atk-sections.txt	3051	* docs/atk-sections.txt
3052	Remove reference to AtkHyperLink	3052	Remove reference to AtkHyperLink
3053	* docs/atk-used.sgml, docs/tmpl/atkhyperlink.sgml	3053	* docs/atk-used.sgml, docs/tmpl/atkhyperlink.sgml




test_relation (void)
{
  AtkRelationType type1, type2;
  const gchar *name;
  AtkObject *obj;
  gboolean ret_value;
  AtkRelationSet *set;

test_role (void)
{
  AtkRole role1, role2;
  const gchar *name;

  name = atk_role_get_name (ATK_ROLE_PAGE_TAB);
  g_return_val_if_fail (name, FALSE);

test_text_attr (void)
{
  AtkTextAttribute attr1, attr2;
  const gchar *name;

  name = atk_text_attribute_get_name (ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP);
  g_return_val_if_fail (name, FALSE);

Lines 208-214 Link Here

(-)atk-1.32.0_ORIG/tests/teststateset.c (-1 / +1 lines)
208	test_state (void)	208	test_state (void)
209	{	209	{
210	AtkStateType type1, type2;	210	AtkStateType type1, type2;
211	G_CONST_RETURN gchar *name;	211	const gchar *name;
212		212
213	name = atk_state_type_get_name (ATK_STATE_VISIBLE);	213	name = atk_state_type_get_name (ATK_STATE_VISIBLE);
214	g_return_val_if_fail (name, FALSE);	214	g_return_val_if_fail (name, FALSE);

Return to bug 384919

Lines 285-293 Link Here

(-)atk-1.32.0_ORIG/atk/atkobject.c (-9 / +9 lines)
285	GValue *value,	285	GValue *value,
286	GParamSpec *pspec);	286	GParamSpec *pspec);
287	static void atk_object_finalize (GObject *object);	287	static void atk_object_finalize (GObject *object);
288	static G_CONST_RETURN gchar*	288	static const gchar*
289	atk_object_real_get_name (AtkObject *object);	289	atk_object_real_get_name (AtkObject *object);
290	static G_CONST_RETURN gchar*	290	static const gchar*
291	atk_object_real_get_description	291	atk_object_real_get_description
292	(AtkObject *object);	292	(AtkObject *object);
293	static AtkObject* atk_object_real_get_parent (AtkObject *object);	293	static AtkObject* atk_object_real_get_parent (AtkObject *object);
Lines 692-698 Link Here
692	*	692	*
693	* Returns: a character string representing the accessible name of the object.	693	* Returns: a character string representing the accessible name of the object.
694	**/	694	**/
695	G_CONST_RETURN gchar*	695	const gchar*
696	atk_object_get_name (AtkObject *accessible)	696	atk_object_get_name (AtkObject *accessible)
697	{	697	{
698	AtkObjectClass *klass;	698	AtkObjectClass *klass;
Lines 716-722 Link Here
716	* of the accessible.	716	* of the accessible.
717	*	717	*
718	**/	718	**/
719	G_CONST_RETURN gchar*	719	const gchar*
720	atk_object_get_description (AtkObject *accessible)	720	atk_object_get_description (AtkObject *accessible)
721	{	721	{
722	AtkObjectClass *klass;	722	AtkObjectClass *klass;
Lines 1123-1129 Link Here
1123	AtkState state,	1123	AtkState state,
1124	gboolean value)	1124	gboolean value)
1125	{	1125	{
1126	G_CONST_RETURN gchar* name;	1126	const gchar* name;
1127		1127
1128	g_return_if_fail (ATK_IS_OBJECT (accessible));	1128	g_return_if_fail (ATK_IS_OBJECT (accessible));
1129		1129
Lines 1319-1331 Link Here
1319	G_OBJECT_CLASS (parent_class)->finalize (object);	1319	G_OBJECT_CLASS (parent_class)->finalize (object);
1320	}	1320	}
1321		1321
1322	static G_CONST_RETURN gchar*	1322	static const gchar*
1323	atk_object_real_get_name (AtkObject *object)	1323	atk_object_real_get_name (AtkObject *object)
1324	{	1324	{
1325	return object->name;	1325	return object->name;
1326	}	1326	}
1327		1327
1328	static G_CONST_RETURN gchar*	1328	static const gchar*
1329	atk_object_real_get_description (AtkObject *object)	1329	atk_object_real_get_description (AtkObject *object)
1330	{	1330	{
1331	return object->description;	1331	return object->description;
Lines 1487-1493 Link Here
1487	*	1487	*
1488	* Returns: the string describing the AtkRole	1488	* Returns: the string describing the AtkRole
1489	*/	1489	*/
1490	G_CONST_RETURN gchar*	1490	const gchar*
1491	atk_role_get_name (AtkRole role)	1491	atk_role_get_name (AtkRole role)
1492	{	1492	{
1493	if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)	1493	if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)
Lines 1514-1520 Link Here
1514	*	1514	*
1515	* Returns: the localized string describing the AtkRole	1515	* Returns: the localized string describing the AtkRole
1516	**/	1516	**/
1517	G_CONST_RETURN gchar*	1517	const gchar*
1518	atk_role_get_localized_name (AtkRole role)	1518	atk_role_get_localized_name (AtkRole role)
1519	{	1519	{
1520	gettext_initialization ();	1520	gettext_initialization ();

Lines 340-346 Link Here

(-)atk-1.32.0_ORIG/atk/atkutil.c (-3 / +3 lines)
340	*	340	*
341	* Returns: name string for the GUI toolkit implementing ATK for this application	341	* Returns: name string for the GUI toolkit implementing ATK for this application
342	**/	342	**/
343	G_CONST_RETURN gchar*	343	const gchar*
344	atk_get_toolkit_name (void)	344	atk_get_toolkit_name (void)
345	{	345	{
346	const gchar *retval;	346	const gchar *retval;
Lines 365-371 Link Here
365	*	365	*
366	* Returns: version string for the GUI toolkit implementing ATK for this application	366	* Returns: version string for the GUI toolkit implementing ATK for this application
367	**/	367	**/
368	G_CONST_RETURN gchar*	368	const gchar*
369	atk_get_toolkit_version (void)	369	atk_get_toolkit_version (void)
370	{	370	{
371	const gchar *retval;	371	const gchar *retval;
Lines 391-397 Link Here
391	* Returns: version string for ATK	391	* Returns: version string for ATK
392	**/	392	**/
393		393
394	G_CONST_RETURN gchar *	394	const gchar *
395	atk_get_version (void)	395	atk_get_version (void)
396	{	396	{
397	return VERSION;	397	return VERSION;

Lines 147-154 Link Here

(-)atk-1.32.0_ORIG/atk/atkutil.h (-5 / +5 lines)
147	gpointer data);	147	gpointer data);
148	void (* remove_key_event_listener) (guint listener_id);	148	void (* remove_key_event_listener) (guint listener_id);
149	AtkObject* (* get_root) (void);	149	AtkObject* (* get_root) (void);
150	G_CONST_RETURN gchar* (* get_toolkit_name) (void);	150	const gchar* (* get_toolkit_name) (void);
151	G_CONST_RETURN gchar* (* get_toolkit_version) (void);	151	const gchar* (* get_toolkit_version) (void);
152	};	152	};
153	GType atk_util_get_type (void);	153	GType atk_util_get_type (void);
154		154
Lines 229-245 Link Here
229	/*	229	/*
230	* Returns name string for the GUI toolkit.	230	* Returns name string for the GUI toolkit.
231	*/	231	*/
232	G_CONST_RETURN gchar *atk_get_toolkit_name (void);	232	const gchar *atk_get_toolkit_name (void);
233		233
234	/*	234	/*
235	* Returns version string for the GUI toolkit.	235	* Returns version string for the GUI toolkit.
236	*/	236	*/
237	G_CONST_RETURN gchar *atk_get_toolkit_version (void);	237	const gchar *atk_get_toolkit_version (void);
238		238
239	/*	239	/*
240	* Gets the current version of ATK	240	* Gets the current version of ATK
241	*/	241	*/
242	G_CONST_RETURN gchar *atk_get_version (void);	242	const gchar *atk_get_version (void);
243		243
244	/* --- GType boilerplate --- */	244	/* --- GType boilerplate --- */
245	/* convenience macros for atk type implementations, which for a type GtkGadgetAccessible will:	245	/* convenience macros for atk type implementations, which for a type GtkGadgetAccessible will:

Lines 101-107 Link Here

(-)atk-1.32.0_ORIG/atk/atkaction.c (-4 / +4 lines)
101	* Returns a description string, or %NULL	101	* Returns a description string, or %NULL
102	* if @action does not implement this interface.	102	* if @action does not implement this interface.
103	**/	103	**/
104	G_CONST_RETURN gchar*	104	const gchar*
105	atk_action_get_description (AtkAction *obj,	105	atk_action_get_description (AtkAction *obj,
106	gint i)	106	gint i)
107	{	107	{
Lines 140-146 Link Here
140	* Returns a name string, or %NULL	140	* Returns a name string, or %NULL
141	* if @action does not implement this interface.	141	* if @action does not implement this interface.
142	**/	142	**/
143	G_CONST_RETURN gchar*	143	const gchar*
144	atk_action_get_name (AtkAction *obj,	144	atk_action_get_name (AtkAction *obj,
145	gint i)	145	gint i)
146	{	146	{
Lines 166-172 Link Here
166	* Returns a name string, or %NULL	166	* Returns a name string, or %NULL
167	* if @action does not implement this interface.	167	* if @action does not implement this interface.
168	**/	168	**/
169	G_CONST_RETURN gchar*	169	const gchar*
170	atk_action_get_localized_name (AtkAction *obj,	170	atk_action_get_localized_name (AtkAction *obj,
171	gint i)	171	gint i)
172	{	172	{
Lines 203-209 Link Here
203	* if there is no keybinding for this action.	203	* if there is no keybinding for this action.
204	*	204	*
205	**/	205	**/
206	G_CONST_RETURN gchar*	206	const gchar*
207	atk_action_get_keybinding (AtkAction *obj,	207	atk_action_get_keybinding (AtkAction *obj,
208	gint i)	208	gint i)
209	{	209	{

Lines 55-70 Link Here

(-)atk-1.32.0_ORIG/atk/atkaction.h (-8 / +8 lines)
55	gboolean (do_action) (AtkAction action,	55	gboolean (do_action) (AtkAction action,
56	gint i);	56	gint i);
57	gint (get_n_actions) (AtkAction action);	57	gint (get_n_actions) (AtkAction action);
58	G_CONST_RETURN gchar* (get_description) (AtkAction action,	58	const gchar* (get_description) (AtkAction action,
59	gint i);	59	gint i);
60	G_CONST_RETURN gchar* (get_name) (AtkAction action,	60	const gchar* (get_name) (AtkAction action,
61	gint i);	61	gint i);
62	G_CONST_RETURN gchar* (get_keybinding) (AtkAction action,	62	const gchar* (get_keybinding) (AtkAction action,
63	gint i);	63	gint i);
64	gboolean (set_description) (AtkAction action,	64	gboolean (set_description) (AtkAction action,
65	gint i,	65	gint i,
66	const gchar *desc);	66	const gchar *desc);
67	G_CONST_RETURN gchar* (get_localized_name)(AtkAction action,	67	const gchar* (get_localized_name)(AtkAction action,
68	gint i);	68	gint i);
69	AtkFunction pad2;	69	AtkFunction pad2;
70	};	70	};
Lines 85-95 Link Here
85	gboolean atk_action_do_action (AtkAction *action,	85	gboolean atk_action_do_action (AtkAction *action,
86	gint i);	86	gint i);
87	gint atk_action_get_n_actions (AtkAction *action);	87	gint atk_action_get_n_actions (AtkAction *action);
88	G_CONST_RETURN gchar* atk_action_get_description (AtkAction *action,	88	const gchar* atk_action_get_description (AtkAction *action,
89	gint i);	89	gint i);
90	G_CONST_RETURN gchar* atk_action_get_name (AtkAction *action,	90	const gchar* atk_action_get_name (AtkAction *action,
91	gint i);	91	gint i);
92	G_CONST_RETURN gchar* atk_action_get_keybinding (AtkAction *action,	92	const gchar* atk_action_get_keybinding (AtkAction *action,
93	gint i);	93	gint i);
94	gboolean atk_action_set_description (AtkAction *action,	94	gboolean atk_action_set_description (AtkAction *action,
95	gint i,	95	gint i,
Lines 97-103 Link Here
97		97
98	/* NEW in ATK 1.1: */	98	/* NEW in ATK 1.1: */
99		99
100	G_CONST_RETURN gchar* atk_action_get_localized_name (AtkAction *action,	100	const gchar* atk_action_get_localized_name (AtkAction *action,
101	gint i);	101	gint i);
102		102
103	/*	103	/*

Lines 93-99 Link Here

(-)atk-1.32.0_ORIG/atk/atkdocument.c (-3 / +3 lines)
93	*	93	*
94	* Returns: a string indicating the document type	94	* Returns: a string indicating the document type
95	**/	95	**/
96	G_CONST_RETURN gchar*	96	const gchar*
97	atk_document_get_document_type (AtkDocument *document)	97	atk_document_get_document_type (AtkDocument *document)
98	{	98	{
99	AtkDocumentIface *iface;	99	AtkDocumentIface *iface;
Lines 155-161 Link Here
155	* locale of the document content as a whole, or NULL if	155	* locale of the document content as a whole, or NULL if
156	* the document content does not specify a locale.	156	* the document content does not specify a locale.
157	**/	157	**/
158	G_CONST_RETURN gchar *	158	const gchar *
159	atk_document_get_locale (AtkDocument *document)	159	atk_document_get_locale (AtkDocument *document)
160	{	160	{
161	AtkDocumentIface *iface;	161	AtkDocumentIface *iface;
Lines 219-225 Link Here
219	* document, or NULL if a value for #attribute_name has not been specified	219	* document, or NULL if a value for #attribute_name has not been specified
220	* for this document.	220	* for this document.
221	*/	221	*/
222	G_CONST_RETURN gchar *	222	const gchar *
223	atk_document_get_attribute_value (AtkDocument *document,	223	atk_document_get_attribute_value (AtkDocument *document,
224	const gchar *attribute_name)	224	const gchar *attribute_name)
225	{	225	{

Lines 49-60 Link Here

(-)atk-1.32.0_ORIG/atk/atkdocument.h (-6 / +6 lines)
49	struct _AtkDocumentIface	49	struct _AtkDocumentIface
50	{	50	{
51	GTypeInterface parent;	51	GTypeInterface parent;
52	G_CONST_RETURN gchar* ( get_document_type) (AtkDocument document);	52	const gchar* ( get_document_type) (AtkDocument document);
53	gpointer ( get_document) (AtkDocument document);	53	gpointer ( get_document) (AtkDocument document);
54		54
55	G_CONST_RETURN gchar* ( get_document_locale) (AtkDocument document);	55	const gchar* ( get_document_locale) (AtkDocument document);
56	AtkAttributeSet * ( get_document_attributes) (AtkDocument document);	56	AtkAttributeSet * ( get_document_attributes) (AtkDocument document);
57	G_CONST_RETURN gchar* ( get_document_attribute_value) (AtkDocument document,	57	const gchar* ( get_document_attribute_value) (AtkDocument document,
58	const gchar *attribute_name);	58	const gchar *attribute_name);
59	gboolean ( set_document_attribute) (AtkDocument document,	59	gboolean ( set_document_attribute) (AtkDocument document,
60	const gchar *attribute_name,	60	const gchar *attribute_name,
Lines 68-78 Link Here
68		68
69	GType atk_document_get_type (void);	69	GType atk_document_get_type (void);
70		70
71	G_CONST_RETURN gchar* atk_document_get_document_type (AtkDocument *document);	71	const gchar* atk_document_get_document_type (AtkDocument *document);
72	gpointer atk_document_get_document (AtkDocument *document);	72	gpointer atk_document_get_document (AtkDocument *document);
73	G_CONST_RETURN gchar* atk_document_get_locale (AtkDocument *document);	73	const gchar* atk_document_get_locale (AtkDocument *document);
74	AtkAttributeSet* atk_document_get_attributes (AtkDocument *document);	74	AtkAttributeSet* atk_document_get_attributes (AtkDocument *document);
75	G_CONST_RETURN gchar* atk_document_get_attribute_value (AtkDocument *document,	75	const gchar* atk_document_get_attribute_value (AtkDocument *document,
76	const gchar *attribute_name);	76	const gchar *attribute_name);
77	gboolean atk_document_set_attribute_value (AtkDocument *document,	77	gboolean atk_document_set_attribute_value (AtkDocument *document,
78	const gchar *attribute_name,	78	const gchar *attribute_name,

Lines 53-65 Link Here

(-)atk-1.32.0_ORIG/atk/atkimage.h (-4 / +4 lines)
53	gint *x,	53	gint *x,
54	gint *y,	54	gint *y,
55	AtkCoordType coord_type);	55	AtkCoordType coord_type);
56	G_CONST_RETURN gchar* ( get_image_description) (AtkImage image);	56	const gchar* ( get_image_description) (AtkImage image);
57	void ( get_image_size) (AtkImage image,	57	void ( get_image_size) (AtkImage image,
58	gint *width,	58	gint *width,
59	gint *height);	59	gint *height);
60	gboolean ( set_image_description) (AtkImage image,	60	gboolean ( set_image_description) (AtkImage image,
61	const gchar *description);	61	const gchar *description);
62	G_CONST_RETURN gchar* ( get_image_locale) (AtkImage image);	62	const gchar* ( get_image_locale) (AtkImage image);
63		63
64	AtkFunction pad1;	64	AtkFunction pad1;
65		65
Lines 67-73 Link Here
67		67
68	GType atk_image_get_type (void);	68	GType atk_image_get_type (void);
69		69
70	G_CONST_RETURN gchar* atk_image_get_image_description (AtkImage *image);	70	const gchar* atk_image_get_image_description (AtkImage *image);
71		71
72	void atk_image_get_image_size (AtkImage *image,	72	void atk_image_get_image_size (AtkImage *image,
73	gint *width,	73	gint *width,
Lines 80-86 Link Here
80	gint *y,	80	gint *y,
81	AtkCoordType coord_type);	81	AtkCoordType coord_type);
82		82
83	G_CONST_RETURN gchar* atk_image_get_image_locale (AtkImage *image);	83	const gchar* atk_image_get_image_locale (AtkImage *image);
84		84
85	G_END_DECLS	85	G_END_DECLS
86		86

Lines 381-391 Link Here

(-)atk-1.32.0_ORIG/atk/atkobject.h (-6 / +6 lines)
381	/*	381	/*
382	* Gets the accessible name of the object	382	* Gets the accessible name of the object
383	*/	383	*/
384	G_CONST_RETURN gchar* (* get_name) (AtkObject *accessible);	384	const gchar* (* get_name) (AtkObject *accessible);
385	/*	385	/*
386	* Gets the accessible description of the object	386	* Gets the accessible description of the object
387	*/	387	*/
388	G_CONST_RETURN gchar* (* get_description) (AtkObject *accessible);	388	const gchar* (* get_description) (AtkObject *accessible);
389	/*	389	/*
390	* Gets the accessible parent of the object	390	* Gets the accessible parent of the object
391	*/	391	*/
Lines 535-542 Link Here
535	* Properties directly supported by AtkObject	535	* Properties directly supported by AtkObject
536	*/	536	*/
537		537
538	G_CONST_RETURN gchar* atk_object_get_name (AtkObject *accessible);	538	const gchar* atk_object_get_name (AtkObject *accessible);
539	G_CONST_RETURN gchar* atk_object_get_description (AtkObject *accessible);	539	const gchar* atk_object_get_description (AtkObject *accessible);
540	AtkObject* atk_object_get_parent (AtkObject *accessible);	540	AtkObject* atk_object_get_parent (AtkObject *accessible);
541	gint atk_object_get_n_accessible_children (AtkObject *accessible);	541	gint atk_object_get_n_accessible_children (AtkObject *accessible);
542	AtkObject* atk_object_ref_accessible_child (AtkObject *accessible,	542	AtkObject* atk_object_ref_accessible_child (AtkObject *accessible,
Lines 571-577 Link Here
571	void atk_object_initialize (AtkObject *accessible,	571	void atk_object_initialize (AtkObject *accessible,
572	gpointer data);	572	gpointer data);
573		573
574	G_CONST_RETURN gchar* atk_role_get_name (AtkRole role);	574	const gchar* atk_role_get_name (AtkRole role);
575	AtkRole atk_role_for_name (const gchar *name);	575	AtkRole atk_role_for_name (const gchar *name);
576		576
577		577
Lines 582-588 Link Here
582	gboolean atk_object_remove_relationship (AtkObject *object,	582	gboolean atk_object_remove_relationship (AtkObject *object,
583	AtkRelationType relationship,	583	AtkRelationType relationship,
584	AtkObject *target);	584	AtkObject *target);
585	G_CONST_RETURN gchar* atk_role_get_localized_name (AtkRole role);	585	const gchar* atk_role_get_localized_name (AtkRole role);
586		586
587	/* */	587	/* */
588		588

Lines 54-64 Link Here

(-)atk-1.32.0_ORIG/atk/atkstreamablecontent.h (-4 / +4 lines)
54	* at index 0 should be considered the "default" data type for the stream.	54	* at index 0 should be considered the "default" data type for the stream.
55	*	55	*
56	* This assumes that the strings for the mime types are stored in the	56	* This assumes that the strings for the mime types are stored in the
57	* AtkStreamableContent. Alternatively the G_CONST_RETURN could be removed	57	* AtkStreamableContent. Alternatively the const could be removed
58	* and the caller would be responsible for calling g_free() on the	58	* and the caller would be responsible for calling g_free() on the
59	* returned value.	59	* returned value.
60	*/	60	*/
61	G_CONST_RETURN gchar* (* get_mime_type) (AtkStreamableContent *streamable,	61	const gchar* (* get_mime_type) (AtkStreamableContent *streamable,
62	gint i);	62	gint i);
63	/*	63	/*
64	* One possible implementation for this method is that it constructs the	64	* One possible implementation for this method is that it constructs the
Lines 80-86 Link Here
80	* constructed. Note that it is possible for get_uri to return NULL but for	80	* constructed. Note that it is possible for get_uri to return NULL but for
81	* get_stream to work nonetheless, since not all GIOChannels connect to URIs.	81	* get_stream to work nonetheless, since not all GIOChannels connect to URIs.
82	*/	82	*/
83	G_CONST_RETURN gchar* (* get_uri) (AtkStreamableContent *streamable,	83	const gchar* (* get_uri) (AtkStreamableContent *streamable,
84	const gchar *mime_type);	84	const gchar *mime_type);
85		85
86		86
Lines 92-98 Link Here
92		92
93	gint atk_streamable_content_get_n_mime_types (AtkStreamableContent *streamable);	93	gint atk_streamable_content_get_n_mime_types (AtkStreamableContent *streamable);
94		94
95	G_CONST_RETURN gchar* atk_streamable_content_get_mime_type (AtkStreamableContent *streamable,	95	const gchar* atk_streamable_content_get_mime_type (AtkStreamableContent *streamable,
96	gint i);	96	gint i);
97	GIOChannel* atk_streamable_content_get_stream (AtkStreamableContent *streamable,	97	GIOChannel* atk_streamable_content_get_stream (AtkStreamableContent *streamable,
98	const gchar *mime_type);	98	const gchar *mime_type);

Lines 69-80 Link Here

(-)atk-1.32.0_ORIG/atk/atktable.h (-4 / +4 lines)
69	gint column);	69	gint column);
70	AtkObject*	70	AtkObject*
71	(* get_caption) (AtkTable *table);	71	(* get_caption) (AtkTable *table);
72	G_CONST_RETURN gchar*	72	const gchar*
73	(* get_column_description) (AtkTable *table,	73	(* get_column_description) (AtkTable *table,
74	gint column);	74	gint column);
75	AtkObject* (* get_column_header) (AtkTable *table,	75	AtkObject* (* get_column_header) (AtkTable *table,
76	gint column);	76	gint column);
77	G_CONST_RETURN gchar*	77	const gchar*
78	(* get_row_description) (AtkTable *table,	78	(* get_row_description) (AtkTable *table,
79	gint row);	79	gint row);
80	AtkObject* (* get_row_header) (AtkTable *table,	80	AtkObject* (* get_row_header) (AtkTable *table,
Lines 163-174 Link Here
163	gint column);	163	gint column);
164	AtkObject*	164	AtkObject*
165	atk_table_get_caption (AtkTable *table);	165	atk_table_get_caption (AtkTable *table);
166	G_CONST_RETURN gchar*	166	const gchar*
167	atk_table_get_column_description (AtkTable *table,	167	atk_table_get_column_description (AtkTable *table,
168	gint column);	168	gint column);
169	AtkObject* atk_table_get_column_header (AtkTable *table,	169	AtkObject* atk_table_get_column_header (AtkTable *table,
170	gint column);	170	gint column);
171	G_CONST_RETURN gchar*	171	const gchar*
172	atk_table_get_row_description (AtkTable *table,	172	atk_table_get_row_description (AtkTable *table,
173	gint row);	173	gint row);
174	AtkObject* atk_table_get_row_header (AtkTable *table,	174	AtkObject* atk_table_get_row_header (AtkTable *table,

Lines 28-34 Link Here

(-)atk-1.32.0_ORIG/tests/testrelation.c (-3 / +3 lines)
28	test_relation (void)	28	test_relation (void)
29	{	29	{
30	AtkRelationType type1, type2;	30	AtkRelationType type1, type2;
31	G_CONST_RETURN gchar *name;	31	const gchar *name;
32	AtkObject *obj;	32	AtkObject *obj;
33	gboolean ret_value;	33	gboolean ret_value;
34	AtkRelationSet *set;	34	AtkRelationSet *set;
Lines 169-175 Link Here
169	test_role (void)	169	test_role (void)
170	{	170	{
171	AtkRole role1, role2;	171	AtkRole role1, role2;
172	G_CONST_RETURN gchar *name;	172	const gchar *name;
173		173
174	name = atk_role_get_name (ATK_ROLE_PAGE_TAB);	174	name = atk_role_get_name (ATK_ROLE_PAGE_TAB);
175	g_return_val_if_fail (name, FALSE);	175	g_return_val_if_fail (name, FALSE);
Lines 230-236 Link Here
230	test_text_attr (void)	230	test_text_attr (void)
231	{	231	{
232	AtkTextAttribute attr1, attr2;	232	AtkTextAttribute attr1, attr2;
233	G_CONST_RETURN gchar *name;	233	const gchar *name;
234		234
235	name = atk_text_attribute_get_name (ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP);	235	name = atk_text_attribute_get_name (ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP);
236	g_return_val_if_fail (name, FALSE);	236	g_return_val_if_fail (name, FALSE);