Add m-esr52 at 52.6.0

30 files changed, 3884 insertions, 0 deletions

diff --git a/other-licenses/atk-1.0/atk/atk-enum-types.h b/other-licenses/atk-1.0/atk/atk-enum-types.h
new file mode 100644
index 000000000..f95e70a67
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atk-enum-types.h
@@ -0,0 +1,41 @@
+
+/* Generated data (by glib-mkenums) */
+
+#ifndef __ATK_ENUM_TYPES_H__
+#define __ATK_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+/* enumerations from "atkhyperlink.h" */
+GType atk_hyperlink_state_flags_get_type (void);
+#define ATK_TYPE_HYPERLINK_STATE_FLAGS (atk_hyperlink_state_flags_get_type())
+/* enumerations from "atkobject.h" */
+GType atk_role_get_type (void);
+#define ATK_TYPE_ROLE (atk_role_get_type())
+GType atk_layer_get_type (void);
+#define ATK_TYPE_LAYER (atk_layer_get_type())
+/* enumerations from "atkrelationtype.h" */
+GType atk_relation_type_get_type (void);
+#define ATK_TYPE_RELATION_TYPE (atk_relation_type_get_type())
+/* enumerations from "atkstate.h" */
+GType atk_state_type_get_type (void);
+#define ATK_TYPE_STATE_TYPE (atk_state_type_get_type())
+/* enumerations from "atktext.h" */
+GType atk_text_attribute_get_type (void);
+#define ATK_TYPE_TEXT_ATTRIBUTE (atk_text_attribute_get_type())
+GType atk_text_boundary_get_type (void);
+#define ATK_TYPE_TEXT_BOUNDARY (atk_text_boundary_get_type())
+GType atk_text_clip_type_get_type (void);
+#define ATK_TYPE_TEXT_CLIP_TYPE (atk_text_clip_type_get_type())
+/* enumerations from "atkutil.h" */
+GType atk_key_event_type_get_type (void);
+#define ATK_TYPE_KEY_EVENT_TYPE (atk_key_event_type_get_type())
+GType atk_coord_type_get_type (void);
+#define ATK_TYPE_COORD_TYPE (atk_coord_type_get_type())
+G_END_DECLS
+
+#endif /* __ATK_ENUM_TYPES_H__ */
+
+/* Generated data ends here */
+
diff --git a/other-licenses/atk-1.0/atk/atk.h b/other-licenses/atk-1.0/atk/atk.h
new file mode 100644
index 000000000..39cec7f05
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atk.h
@@ -0,0 +1,62 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_H__
+#define __ATK_H__
+
+#define __ATK_H_INSIDE__
+
+// XXX this is a Mozilla hack to avoid using atkversion.h which needs to be run
+// through m4, and we don't want to deal with that.  Fortunately we don't need
+// any of the fancyness in that header to deal with compile time version
+// detection.
+#define ATK_AVAILABLE_IN_2_12 extern
+
+#include <atk/atkobject.h>
+#include <atk/atkaction.h>
+#include <atk/atkcomponent.h>
+#include <atk/atkdocument.h>
+#include <atk/atkeditabletext.h>
+#include <atk/atkgobjectaccessible.h>
+#include <atk/atkhyperlink.h>
+#include <atk/atkhyperlinkimpl.h>
+#include <atk/atkhypertext.h>
+#include <atk/atkimage.h>
+#include <atk/atknoopobject.h>
+#include <atk/atknoopobjectfactory.h>
+#include <atk/atkobjectfactory.h>
+#include <atk/atkplug.h>
+#include <atk/atkregistry.h>
+#include <atk/atkrelation.h>
+#include <atk/atkrelationset.h>
+#include <atk/atkrelationtype.h>
+#include <atk/atkselection.h>
+#include <atk/atksocket.h>
+#include <atk/atkstate.h>
+#include <atk/atkstateset.h>
+#include <atk/atkstreamablecontent.h>
+#include <atk/atktable.h>
+#include <atk/atktablecell.h>
+#include <atk/atktext.h>
+#include <atk/atkutil.h>
+#include <atk/atkvalue.h>
+
+#undef __ATK_H_INSIDE__
+
+#endif /* __ATK_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkaction.h b/other-licenses/atk-1.0/atk/atkaction.h
new file mode 100644
index 000000000..8dfee9fe1
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkaction.h
@@ -0,0 +1,112 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_ACTION_H__
+#define __ATK_ACTION_H__
+
+#include <atk/atkobject.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The interface AtkAction should be supported by any object that can 
+ * perform one or more actions. The interface provides the standard 
+ * mechanism for an assistive technology to determine what those actions 
+ * are as well as tell the object to perform them. Any object that can 
+ * be manipulated should support this interface.
+ */
+
+
+#define ATK_TYPE_ACTION                    (atk_action_get_type ())
+#define ATK_IS_ACTION(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_ACTION)
+#define ATK_ACTION(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_ACTION, AtkAction)
+#define ATK_ACTION_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_ACTION, AtkActionIface))
+
+#ifndef _TYPEDEF_ATK_ACTION_
+#define _TYPEDEF_ATK_ACTION_
+typedef struct _AtkAction AtkAction;
+#endif
+typedef struct _AtkActionIface AtkActionIface;
+
+struct _AtkActionIface
+{
+  GTypeInterface parent;
+
+  gboolean                (*do_action)         (AtkAction         *action,
+                                                gint              i);
+  gint                    (*get_n_actions)     (AtkAction         *action);
+  G_CONST_RETURN gchar*   (*get_description)   (AtkAction         *action,
+                                                gint              i);
+  G_CONST_RETURN gchar*   (*get_name)          (AtkAction         *action,
+                                                gint              i);
+  G_CONST_RETURN gchar*   (*get_keybinding)    (AtkAction         *action,
+                                                gint              i);
+  gboolean                (*set_description)   (AtkAction         *action,
+                                                gint              i,
+                                                const gchar       *desc);
+  G_CONST_RETURN gchar*   (*get_localized_name)(AtkAction         *action,
+						gint              i);
+  AtkFunction             pad2;
+};
+
+GType atk_action_get_type (void);
+
+/*
+ * These are the function which would be called by an application with
+ * the argument being a AtkObject object cast to (AtkAction).
+ *
+ * The function will just check that * the corresponding
+ * function pointer is not NULL and will call it.
+ *
+ * The "real" implementation of the function for accessible will be
+ * provided in a support library
+ */
+
+gboolean   atk_action_do_action                (AtkAction         *action,
+                                            gint              i);
+gint   atk_action_get_n_actions            (AtkAction *action);
+G_CONST_RETURN gchar* atk_action_get_description  (AtkAction         *action,
+                                                   gint              i);
+G_CONST_RETURN gchar* atk_action_get_name         (AtkAction         *action,
+                                                   gint              i);
+G_CONST_RETURN gchar* atk_action_get_keybinding   (AtkAction         *action,
+                                                   gint              i);
+gboolean              atk_action_set_description  (AtkAction         *action,
+                                                   gint              i,
+                                                   const gchar       *desc);
+
+/* NEW in ATK 1.1: */
+
+G_CONST_RETURN gchar* atk_action_get_localized_name (AtkAction       *action,
+						     gint            i);
+
+/*
+ * Additional GObject properties exported by AtkAction:
+ *    "accessible_action"
+ *       (an accessible action, or the list of actions, has changed)
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_ACTION_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkcomponent.h b/other-licenses/atk-1.0/atk/atkcomponent.h
new file mode 100644
index 000000000..c72a72837
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkcomponent.h
@@ -0,0 +1,171 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_COMPONENT_H__
+#define __ATK_COMPONENT_H__
+
+#include <atk/atkobject.h>
+#include <atk/atkutil.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The AtkComponent interface should be supported by any object that is 
+ * rendered on the screen. The interface provides the standard mechanism 
+ * for an assistive technology to determine and set the graphical
+ * representation of an object.
+ */
+
+#define ATK_TYPE_COMPONENT                    (atk_component_get_type ())
+#define ATK_IS_COMPONENT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_COMPONENT)
+#define ATK_COMPONENT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_COMPONENT, AtkComponent)
+#define ATK_COMPONENT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_COMPONENT, AtkComponentIface))
+
+#ifndef _TYPEDEF_ATK_COMPONENT_
+#define _TYPEDEF_ATK_COMPONENT_
+typedef struct _AtkComponent AtkComponent;
+#endif
+typedef struct _AtkComponentIface  AtkComponentIface;
+
+typedef void (*AtkFocusHandler) (AtkObject*, gboolean);
+
+typedef struct _AtkRectangle       AtkRectangle;
+
+struct _AtkRectangle
+{
+  gint x;
+  gint y;
+  gint width;
+  gint height;
+};
+
+GType atk_rectangle_get_type (void);
+
+#define ATK_TYPE_RECTANGLE (atk_rectangle_get_type ())
+struct _AtkComponentIface
+{
+  GTypeInterface parent;
+
+  guint          (* add_focus_handler)  (AtkComponent          *component,
+                                         AtkFocusHandler        handler);
+
+  gboolean       (* contains)           (AtkComponent          *component,
+                                         gint                   x,
+                                         gint                   y,
+                                         AtkCoordType           coord_type);
+
+  AtkObject*    (* ref_accessible_at_point)  (AtkComponent     *component,
+                                         gint                   x,
+                                         gint                   y,
+                                         AtkCoordType           coord_type);
+  void          (* get_extents)         (AtkComponent          *component,
+                                         gint                  *x,
+                                         gint                  *y,
+                                         gint                  *width,
+                                         gint                  *height,
+                                         AtkCoordType          coord_type);
+  void                     (* get_position)     (AtkComponent   *component,
+                                                 gint           *x,
+                                                 gint           *y,
+                                                 AtkCoordType   coord_type);
+  void                     (* get_size)                 (AtkComponent   *component,
+                                                         gint           *width,
+                                                         gint           *height);
+  gboolean                 (* grab_focus)               (AtkComponent   *component);
+  void                     (* remove_focus_handler)      (AtkComponent  *component,
+                                                          guint         handler_id);
+  gboolean                 (* set_extents)      (AtkComponent   *component,
+                                                 gint           x,
+                                                 gint           y,
+                                                 gint           width,
+                                                 gint           height,
+                                                 AtkCoordType   coord_type);
+  gboolean                 (* set_position)     (AtkComponent   *component,
+                                                 gint           x,
+                                                 gint           y,
+                                                 AtkCoordType   coord_type);
+  gboolean                 (* set_size)         (AtkComponent   *component,
+                                                 gint           width,
+                                                 gint           height);
+  	
+  AtkLayer                 (* get_layer)        (AtkComponent   *component);
+  gint                     (* get_mdi_zorder)   (AtkComponent   *component);
+
+  /*
+   * signal handlers
+   */
+  void                     (* bounds_changed)   (AtkComponent   *component,
+                                                 AtkRectangle   *bounds);
+  gdouble                  (* get_alpha)        (AtkComponent   *component);
+};
+
+GType atk_component_get_type (void);
+
+/* convenience functions */
+
+guint                atk_component_add_focus_handler      (AtkComponent    *component,
+                                                           AtkFocusHandler handler);
+gboolean              atk_component_contains               (AtkComponent    *component,
+                                                            gint            x,
+                                                            gint            y,
+                                                            AtkCoordType    coord_type);
+AtkObject*            atk_component_ref_accessible_at_point(AtkComponent    *component,
+                                                            gint            x,
+                                                            gint            y,
+                                                            AtkCoordType    coord_type);
+void                  atk_component_get_extents            (AtkComponent    *component,
+                                                            gint            *x,
+                                                            gint            *y,
+                                                            gint            *width,
+                                                            gint            *height,
+                                                            AtkCoordType    coord_type);
+void                  atk_component_get_position           (AtkComponent    *component,
+                                                            gint            *x,
+                                                            gint            *y,
+                                                            AtkCoordType    coord_type);
+void                  atk_component_get_size               (AtkComponent    *component,
+                                                            gint            *width,
+                                                            gint            *height);
+AtkLayer              atk_component_get_layer              (AtkComponent    *component);
+gint                  atk_component_get_mdi_zorder         (AtkComponent    *component);
+gboolean              atk_component_grab_focus             (AtkComponent    *component);
+void                  atk_component_remove_focus_handler   (AtkComponent    *component,
+                                                            guint           handler_id);
+gboolean              atk_component_set_extents            (AtkComponent    *component,
+                                                            gint            x,
+                                                            gint            y,
+                                                            gint            width,
+                                                            gint            height,
+                                                            AtkCoordType    coord_type);
+gboolean              atk_component_set_position           (AtkComponent    *component,
+                                                            gint            x,
+                                                            gint            y,
+                                                            AtkCoordType    coord_type);
+gboolean              atk_component_set_size               (AtkComponent    *component,
+                                                            gint            width,
+                                                            gint            height);
+gdouble               atk_component_get_alpha              (AtkComponent    *component);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_COMPONENT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkdocument.h b/other-licenses/atk-1.0/atk/atkdocument.h
new file mode 100644
index 000000000..4b83aa93d
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkdocument.h
@@ -0,0 +1,80 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_DOCUMENT_H__
+#define __ATK_DOCUMENT_H__
+
+#include <atk/atkobject.h>
+#include <atk/atkutil.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The AtkDocument interface should be supported by any object that is a container
+ * for 'document content' as opposed to a collection of user interface elements.
+ *
+ */
+
+#define ATK_TYPE_DOCUMENT                   (atk_document_get_type ())
+#define ATK_IS_DOCUMENT(obj)                G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_DOCUMENT)
+#define ATK_DOCUMENT(obj)                   G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_DOCUMENT, AtkDocument)
+#define ATK_DOCUMENT_GET_IFACE(obj)         (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_DOCUMENT, AtkDocumentIface))
+
+#ifndef _TYPEDEF_ATK_DOCUMENT_
+#define _TYPEDEF_ATK_DOCUMENT_
+typedef struct _AtkDocument AtkDocument;
+#endif
+typedef struct _AtkDocumentIface AtkDocumentIface;
+
+struct _AtkDocumentIface
+{
+  GTypeInterface parent;
+  G_CONST_RETURN gchar* ( *get_document_type) (AtkDocument              *document);
+  gpointer              ( *get_document)      (AtkDocument              *document);
+
+  G_CONST_RETURN gchar* ( *get_document_locale) (AtkDocument              *document);
+  AtkAttributeSet *     ( *get_document_attributes) (AtkDocument        *document);
+  G_CONST_RETURN gchar* ( *get_document_attribute_value) (AtkDocument   *document,
+                                                          const gchar   *attribute_name);
+  gboolean              ( *set_document_attribute) (AtkDocument         *document,
+                                                    const gchar         *attribute_name,
+                                                    const gchar         *attribute_value);
+  AtkFunction pad1;
+  AtkFunction pad2;
+  AtkFunction pad3;
+  AtkFunction pad4;
+};
+
+GType  atk_document_get_type             (void);
+
+G_CONST_RETURN gchar* atk_document_get_document_type (AtkDocument   *document);
+gpointer atk_document_get_document (AtkDocument   *document);
+G_CONST_RETURN gchar* atk_document_get_locale (AtkDocument *document);
+AtkAttributeSet*      atk_document_get_attributes (AtkDocument *document);
+G_CONST_RETURN gchar* atk_document_get_attribute_value (AtkDocument *document, 
+                                                        const gchar *attribute_name);
+gboolean              atk_document_set_attribute_value (AtkDocument *document,
+                                                        const gchar *attribute_name,
+                                                        const gchar *attribute_value);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __ATK_DOCUMENT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkeditabletext.h b/other-licenses/atk-1.0/atk/atkeditabletext.h
new file mode 100644
index 000000000..02937ff87
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkeditabletext.h
@@ -0,0 +1,105 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_EDITABLE_TEXT_H__
+#define __ATK_EDITABLE_TEXT_H__
+
+#include <atk/atkobject.h>
+#include <atk/atktext.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * AtkEditableText is used to support access in an "accessibility" context
+ * to editing features of editable text widgets.
+ */
+
+#define ATK_TYPE_EDITABLE_TEXT                    (atk_editable_text_get_type ())
+#define ATK_IS_EDITABLE_TEXT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_EDITABLE_TEXT)
+#define ATK_EDITABLE_TEXT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_EDITABLE_TEXT, AtkEditableText)
+#define ATK_EDITABLE_TEXT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_EDITABLE_TEXT, AtkEditableTextIface))
+
+#ifndef _TYPEDEF_ATK_EDITABLE_TEXT_
+#define _TYPEDEF_ATK_EDITABLE_TEXT_
+typedef struct _AtkEditableText AtkEditableText;
+#endif
+typedef struct _AtkEditableTextIface AtkEditableTextIface;
+
+struct _AtkEditableTextIface
+{
+  GTypeInterface parent_interface;
+
+  gboolean (* set_run_attributes) (AtkEditableText  *text,
+                                   AtkAttributeSet  *attrib_set,
+                                   gint		    start_offset,
+ 				   gint		    end_offset);
+  void   (* set_text_contents)    (AtkEditableText  *text,
+                                   const gchar      *string);
+  void   (* insert_text)          (AtkEditableText  *text,
+                                   const gchar      *string,
+                                   gint             length,
+                                   gint             *position);
+  void   (* copy_text)            (AtkEditableText  *text,
+                                   gint             start_pos,
+                                   gint             end_pos);
+  void   (* cut_text)             (AtkEditableText  *text,
+                                   gint             start_pos,
+                                   gint             end_pos);
+  void   (* delete_text)          (AtkEditableText  *text,
+                                   gint             start_pos,
+                                   gint             end_pos);
+  void   (* paste_text)           (AtkEditableText  *text,
+                                   gint             position);
+
+  AtkFunction                     pad1;
+  AtkFunction                     pad2;
+};
+GType atk_editable_text_get_type (void);
+
+
+gboolean atk_editable_text_set_run_attributes (AtkEditableText          *text,
+                                               AtkAttributeSet  *attrib_set,
+                                               gint    	        start_offset,
+ 					       gint	        end_offset);
+void atk_editable_text_set_text_contents    (AtkEditableText  *text,
+                                             const gchar      *string);
+void atk_editable_text_insert_text          (AtkEditableText  *text,
+                                             const gchar      *string,
+                                             gint             length,
+                                             gint             *position);
+void atk_editable_text_copy_text            (AtkEditableText  *text,
+                                             gint             start_pos,
+                                             gint             end_pos);
+void atk_editable_text_cut_text             (AtkEditableText  *text,
+                                             gint             start_pos,
+                                             gint             end_pos);
+void atk_editable_text_delete_text          (AtkEditableText  *text,
+                                             gint             start_pos,
+                                             gint             end_pos);
+void atk_editable_text_paste_text           (AtkEditableText  *text,
+                                             gint             position);
+ 
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_EDITABLE_TEXT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkgobjectaccessible.h b/other-licenses/atk-1.0/atk/atkgobjectaccessible.h
new file mode 100644
index 000000000..adb46cd9a
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkgobjectaccessible.h
@@ -0,0 +1,67 @@
+/* ATK - Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_GOBJECT_ACCESSIBLE_H__
+#define __ATK_GOBJECT_ACCESSIBLE_H__
+
+#include <atk/atk.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The AtkGObjectAccessible class is provided as a basis for implementing
+ * accessibility support for objects which are not GTK+ widgets
+ */
+#define ATK_TYPE_GOBJECT_ACCESSIBLE            (atk_gobject_accessible_get_type ())
+#define ATK_GOBJECT_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE, AtkGObjectAccessible))
+#define ATK_GOBJECT_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_GOBJECT_ACCESSIBLE, AtkGObjectAccessibleClass))
+#define ATK_IS_GOBJECT_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE))
+#define ATK_IS_GOBJECT_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_GOBJECT_ACCESSIBLE))
+#define ATK_GOBJECT_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_GOBJECT_ACCESSIBLE, AtkGObjectAccessibleClass))
+
+typedef struct _AtkGObjectAccessible                AtkGObjectAccessible;
+typedef struct _AtkGObjectAccessibleClass           AtkGObjectAccessibleClass;
+
+struct _AtkGObjectAccessible
+{
+  AtkObject parent;
+};
+
+GType atk_gobject_accessible_get_type (void);
+
+struct _AtkGObjectAccessibleClass
+{
+  AtkObjectClass parent_class;
+
+  AtkFunction pad1;
+  AtkFunction pad2;
+};
+
+AtkObject *atk_gobject_accessible_for_object      (GObject           *obj);
+GObject   *atk_gobject_accessible_get_object      (AtkGObjectAccessible *obj);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_GOBJECT_ACCESSIBLE_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkhyperlink.h b/other-licenses/atk-1.0/atk/atkhyperlink.h
new file mode 100644
index 000000000..a5d3716f0
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkhyperlink.h
@@ -0,0 +1,106 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_HYPERLINK_H__
+#define __ATK_HYPERLINK_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <atk/atkaction.h>
+
+/*
+ * AtkHyperlink encapsulates a link or set of links in a hypertext document.
+ *
+ * It implements the AtkAction interface.
+ */
+
+/**
+ *AtkHyperlinkStateFlags
+ *@ATK_HYPERLINK_IS_INLINE: Link is inline
+ *
+ *Describes the type of link
+ **/ 
+typedef enum 
+{
+  ATK_HYPERLINK_IS_INLINE = 1 << 0
+} AtkHyperlinkStateFlags;
+
+#define ATK_TYPE_HYPERLINK                        (atk_hyperlink_get_type ())
+#define ATK_HYPERLINK(obj)                        (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERLINK, AtkHyperlink))
+#define ATK_HYPERLINK_CLASS(klass)                (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_HYPERLINK, AtkHyperlinkClass))
+#define ATK_IS_HYPERLINK(obj)                     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERLINK))
+#define ATK_IS_HYPERLINK_CLASS(klass)             (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_HYPERLINK))
+#define ATK_HYPERLINK_GET_CLASS(obj)              (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_HYPERLINK, AtkHyperlinkClass))
+
+typedef struct _AtkHyperlink                      AtkHyperlink;
+typedef struct _AtkHyperlinkClass                 AtkHyperlinkClass;
+
+struct _AtkHyperlink
+{
+  GObject parent;
+};
+
+struct _AtkHyperlinkClass
+{
+  GObjectClass parent;
+
+  gchar*           (* get_uri)             (AtkHyperlink     *link_,
+                                            gint             i);
+  AtkObject*       (* get_object)          (AtkHyperlink     *link_,
+                                            gint             i);
+  gint             (* get_end_index)       (AtkHyperlink     *link_);
+  gint             (* get_start_index)     (AtkHyperlink     *link_);
+  gboolean         (* is_valid)            (AtkHyperlink     *link_);
+  gint	           (* get_n_anchors)	   (AtkHyperlink     *link_);
+  guint	           (* link_state)	   (AtkHyperlink     *link_);
+  gboolean         (* is_selected_link)    (AtkHyperlink     *link_);
+
+  /* Signals */
+  void             ( *link_activated)      (AtkHyperlink     *link_);
+  AtkFunction      pad1;
+};
+
+GType            atk_hyperlink_get_type             (void);
+
+gchar*           atk_hyperlink_get_uri              (AtkHyperlink     *link_,
+                                                     gint             i);
+
+AtkObject*       atk_hyperlink_get_object           (AtkHyperlink     *link_,
+                                                     gint             i);
+
+gint             atk_hyperlink_get_end_index        (AtkHyperlink     *link_);
+
+gint             atk_hyperlink_get_start_index      (AtkHyperlink     *link_);
+
+gboolean         atk_hyperlink_is_valid             (AtkHyperlink     *link_);
+
+gboolean         atk_hyperlink_is_inline             (AtkHyperlink     *link_);
+
+gint		 atk_hyperlink_get_n_anchors        (AtkHyperlink     *link_);
+gboolean         atk_hyperlink_is_selected_link     (AtkHyperlink     *link_);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_HYPERLINK_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkhyperlinkimpl.h b/other-licenses/atk-1.0/atk/atkhyperlinkimpl.h
new file mode 100644
index 000000000..b08a1d53c
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkhyperlinkimpl.h
@@ -0,0 +1,76 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_HYPERLINK_IMPL_H__
+#define __ATK_HYPERLINK_IMPL_H__
+
+#include <atk/atkobject.h>
+#include <atk/atkhyperlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The AtkHyperlinkImpl interface should be supported by objects
+ * exposed within the hierarchy as children of an AtkHypertext container
+ * which correspond to "links" or embedded content within the text.
+ * HTML anchors are not, for instance, normally exposed this way,
+ * but embedded images and components which appear inline in the
+ * content of a text object are. The AtkHyperlinkIface interface
+ * allows a means of determining which children are hyperlinks in this
+ * sense of the word, and for obtaining their corresponding AtkHyperlink 
+ * object, from which the embedding range, URI, etc. can be obtained.
+ *
+ * To some extent this interface exists because, for historical 
+ * reasons, AtkHyperlink was defined as an object type, not an interface.
+ * Thus, in order to interact with AtkObjects via AtkHyperlink semantics,
+ * a new interface was required.
+ */
+
+#define ATK_TYPE_HYPERLINK_IMPL          (atk_hyperlink_impl_get_type ())
+#define ATK_IS_HYPERLINK_IMPL(obj)       G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERLINK_IMPL)
+#define ATK_HYPERLINK_IMPL(obj)             G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERLINK_IMPL, AtkHyperlinkImpl)
+#define ATK_HYPERLINK_IMPL_GET_IFACE(obj)   G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_HYPERLINK_IMPL, AtkHyperlinkImplIface)
+
+#ifndef _TYPEDEF_ATK_HYPERLINK_IMPL_
+#define _TYPEDEF_ATK_HYPERLINK_IMPL__
+typedef struct _AtkHyperlinkImpl AtkHyperlinkImpl;
+#endif
+typedef struct _AtkHyperlinkImplIface AtkHyperlinkImplIface;
+
+struct _AtkHyperlinkImplIface
+{
+  GTypeInterface parent;
+    
+  AtkHyperlink*  (* get_hyperlink) (AtkHyperlinkImpl *impl);
+
+  AtkFunction pad1;
+};
+
+GType            atk_hyperlink_impl_get_type (void);
+
+AtkHyperlink    *atk_hyperlink_impl_get_hyperlink (AtkHyperlinkImpl *obj);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_HYPERLINK_IMPL_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkhypertext.h b/other-licenses/atk-1.0/atk/atkhypertext.h
new file mode 100644
index 000000000..18464d9ff
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkhypertext.h
@@ -0,0 +1,80 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_HYPERTEXT_H__
+#define __ATK_HYPERTEXT_H__
+
+#include <atk/atkobject.h>
+#include <atk/atkhyperlink.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The AtkHypertext interface provides standard  mechanisms for manipulating 
+ * hyperlinks.
+ */
+
+#define ATK_TYPE_HYPERTEXT                    (atk_hypertext_get_type ())
+#define ATK_IS_HYPERTEXT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_HYPERTEXT)
+#define ATK_HYPERTEXT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_HYPERTEXT, AtkHypertext)
+#define ATK_HYPERTEXT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_HYPERTEXT, AtkHypertextIface))
+
+#ifndef _TYPEDEF_ATK_HYPERTEXT_
+#define _TYPEDEF_ATK_HYPERTEXT_
+typedef struct _AtkHypertext AtkHypertext;
+#endif
+typedef struct _AtkHypertextIface AtkHypertextIface;
+
+struct _AtkHypertextIface
+{
+  GTypeInterface parent;
+
+  AtkHyperlink*(* get_link)                 (AtkHypertext       *hypertext,
+                                             gint               link_index);
+  gint         (* get_n_links)              (AtkHypertext       *hypertext);
+  gint         (* get_link_index)           (AtkHypertext       *hypertext,
+                                             gint               char_index);
+
+  /*
+   * signal handlers
+   */
+  void         (* link_selected)            (AtkHypertext       *hypertext,
+                                             gint               link_index);
+
+  AtkFunction pad1;
+  AtkFunction pad2;
+  AtkFunction pad3;
+};
+GType atk_hypertext_get_type (void);
+
+AtkHyperlink* atk_hypertext_get_link       (AtkHypertext *hypertext,
+                                            gint          link_index);
+gint          atk_hypertext_get_n_links    (AtkHypertext *hypertext);
+gint          atk_hypertext_get_link_index (AtkHypertext *hypertext,
+                                            gint          char_index);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_HYPERTEXT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkimage.h b/other-licenses/atk-1.0/atk/atkimage.h
new file mode 100644
index 000000000..7e60c8180
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkimage.h
@@ -0,0 +1,86 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_IMAGE_H__
+#define __ATK_IMAGE_H__
+
+#include <atk/atkobject.h>
+#include <atk/atkutil.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The AtkImage interface should be supported by any object that has an 
+ * associated image. This interface provides the standard mechanism for 
+ * an assistive technology to get descriptive information about images.
+ */
+
+#define ATK_TYPE_IMAGE                   (atk_image_get_type ())
+#define ATK_IS_IMAGE(obj)                G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_IMAGE)
+#define ATK_IMAGE(obj)                   G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_IMAGE, AtkImage)
+#define ATK_IMAGE_GET_IFACE(obj)         (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_IMAGE, AtkImageIface))
+
+#ifndef _TYPEDEF_ATK_IMAGE_
+#define _TYPEDEF_ATK_IMAGE_
+typedef struct _AtkImage AtkImage;
+#endif
+typedef struct _AtkImageIface AtkImageIface;
+
+struct _AtkImageIface
+{
+  GTypeInterface parent;
+  void          	( *get_image_position)    (AtkImage		 *image,
+                                                   gint                  *x,
+				                   gint	                 *y,
+    			                           AtkCoordType	         coord_type);
+  G_CONST_RETURN 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);
+  G_CONST_RETURN gchar* ( *get_image_locale)      (AtkImage              *image);
+
+  AtkFunction           pad1;
+	
+};
+
+GType  atk_image_get_type             (void);
+
+G_CONST_RETURN gchar* atk_image_get_image_description (AtkImage   *image);
+
+void     atk_image_get_image_size        (AtkImage           *image,
+                                          gint               *width,
+                                          gint               *height);
+
+gboolean atk_image_set_image_description (AtkImage           *image,
+                                          const gchar       *description);
+void     atk_image_get_image_position    (AtkImage	     *image,
+                                          gint               *x,
+					  gint	             *y,
+    					  AtkCoordType	     coord_type);
+
+G_CONST_RETURN gchar* atk_image_get_image_locale (AtkImage   *image);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __ATK_IMAGE_H__ */
diff --git a/other-licenses/atk-1.0/atk/atknoopobject.h b/other-licenses/atk-1.0/atk/atknoopobject.h
new file mode 100644
index 000000000..3c4e432a8
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atknoopobject.h
@@ -0,0 +1,51 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_NO_OP_OBJECT_H__
+#define __ATK_NO_OP_OBJECT_H__
+
+G_BEGIN_DECLS
+
+#define ATK_TYPE_NO_OP_OBJECT                (atk_no_op_object_get_type ())
+#define ATK_NO_OP_OBJECT(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_NO_OP_OBJECT, AtkNoOpObject))
+#define ATK_NO_OP_OBJECT_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_NO_OP_OBJECT, AtkNoOpObjectClass))
+#define ATK_IS_NO_OP_OBJECT(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_NO_OP_OBJECT))
+#define ATK_IS_NO_OP_OBJECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_NO_OP_OBJECT))
+#define ATK_NO_OP_OBJECT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_NO_OP_OBJECT, AtkNoOpObjectClass))
+
+typedef struct _AtkNoOpObject                   AtkNoOpObject;
+typedef struct _AtkNoOpObjectClass              AtkNoOpObjectClass;
+
+struct _AtkNoOpObject
+{
+  AtkObject     parent;
+};
+
+GType atk_no_op_object_get_type (void);
+
+struct _AtkNoOpObjectClass
+{
+  AtkObjectClass parent_class;
+};
+
+AtkObject *atk_no_op_object_new (GObject  *obj);
+
+G_END_DECLS
+
+#endif /* __ATK_NO_OP_OBJECT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atknoopobjectfactory.h b/other-licenses/atk-1.0/atk/atknoopobjectfactory.h
new file mode 100644
index 000000000..c32453133
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atknoopobjectfactory.h
@@ -0,0 +1,58 @@
+/* ATK - Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_NO_OP_OBJECT_FACTORY_H__
+#define __ATK_NO_OP_OBJECT_FACTORY_H__
+
+#include <atk/atkobjectfactory.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define ATK_TYPE_NO_OP_OBJECT_FACTORY                (atk_no_op_object_factory_get_type ())
+#define ATK_NO_OP_OBJECT_FACTORY(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_NO_OP_OBJECT_FACTORY, AtkNoOpObjectFactory))
+#define ATK_NO_OP_OBJECT_FACTORY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_NO_OP_OBJECT_FACTORY, AtkNoOpObjectFactoryClass))
+#define ATK_IS_NO_OP_OBJECT_FACTORY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_NO_OP_OBJECT_FACTORY))
+#define ATK_IS_NO_OP_OBJECT_FACTORY_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_NO_OP_OBJECT_FACTORY))
+#define ATK_NO_OP_OBJECT_FACTORY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ( (obj), ATK_TYPE_NO_OP_OBJECT_FACTORY, AtkNoOpObjectFactoryClass))
+
+typedef struct _AtkNoOpObjectFactory                 AtkNoOpObjectFactory;
+typedef struct _AtkNoOpObjectFactoryClass            AtkNoOpObjectFactoryClass;
+
+struct _AtkNoOpObjectFactory
+{
+  AtkObjectFactory parent;
+};
+
+struct _AtkNoOpObjectFactoryClass
+{
+  AtkObjectFactoryClass parent_class;
+};
+
+GType atk_no_op_object_factory_get_type(void);
+
+AtkObjectFactory *atk_no_op_object_factory_new(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_NO_OP_OBJECT_FACTORY_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkobject.h b/other-licenses/atk-1.0/atk/atkobject.h
new file mode 100644
index 000000000..987f2cefc
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkobject.h
@@ -0,0 +1,768 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_OBJECT_H__
+#define __ATK_OBJECT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <glib-object.h>
+#include <atk/atkstate.h>
+#include <atk/atkrelationtype.h>
+
+/*
+ * AtkObject represents the minimum information all accessible objects
+ * return. This information includes accessible name, accessible
+ * description, role and state of the object, as well information about
+ * its parent and children. It is also possible to obtain more specific
+ * accessibility information about a component if it supports one or more
+ * of the following interfaces:
+ */
+
+
+/**
+ *AtkRole:
+ *@ATK_ROLE_INVALID: Invalid role
+ *@ATK_ROLE_ACCEL_LABEL: A label which represents an accelerator
+ *@ATK_ROLE_ALERT: An object which is an alert to the user. Assistive Technologies typically respond to ATK_ROLE_ALERT by reading the entire onscreen contents of containers advertising this role.  Should be used for warning dialogs, etc.
+ *@ATK_ROLE_ANIMATION: An object which is an animated image
+ *@ATK_ROLE_ARROW: An arrow in one of the four cardinal directions
+ *@ATK_ROLE_CALENDAR:  An object that displays a calendar and allows the user to select a date
+ *@ATK_ROLE_CANVAS: An object that can be drawn into and is used to trap events
+ *@ATK_ROLE_CHECK_BOX: A choice that can be checked or unchecked and provides a separate indicator for the current state
+ *@ATK_ROLE_CHECK_MENU_ITEM: A menu item with a check box
+ *@ATK_ROLE_COLOR_CHOOSER: A specialized dialog that lets the user choose a color
+ *@ATK_ROLE_COLUMN_HEADER: The header for a column of data
+ *@ATK_ROLE_COMBO_BOX: A collapsible list of choices the user can select from
+ *@ATK_ROLE_DATE_EDITOR: An object whose purpose is to allow a user to edit a date
+ *@ATK_ROLE_DESKTOP_ICON: An inconifed internal frame within a DESKTOP_PANE
+ *@ATK_ROLE_DESKTOP_FRAME: A pane that supports internal frames and iconified versions of those internal frames
+ *@ATK_ROLE_DIAL: An object whose purpose is to allow a user to set a value
+ *@ATK_ROLE_DIALOG: A top level window with title bar and a border
+ *@ATK_ROLE_DIRECTORY_PANE: A pane that allows the user to navigate through and select the contents of a directory
+ *@ATK_ROLE_DRAWING_AREA: An object used for drawing custom user interface elements
+ *@ATK_ROLE_FILE_CHOOSER: A specialized dialog that lets the user choose a file
+ *@ATK_ROLE_FILLER: A object that fills up space in a user interface
+ *@ATK_ROLE_FONT_CHOOSER: A specialized dialog that lets the user choose a font
+ *@ATK_ROLE_FRAME: A top level window with a title bar, border, menubar, etc.
+ *@ATK_ROLE_GLASS_PANE: A pane that is guaranteed to be painted on top of all panes beneath it
+ *@ATK_ROLE_HTML_CONTAINER: A document container for HTML, whose children represent the document content
+ *@ATK_ROLE_ICON: A small fixed size picture, typically used to decorate components
+ *@ATK_ROLE_IMAGE: An object whose primary purpose is to display an image
+ *@ATK_ROLE_INTERNAL_FRAME: A frame-like object that is clipped by a desktop pane
+ *@ATK_ROLE_LABEL: An object used to present an icon or short string in an interface
+ *@ATK_ROLE_LAYERED_PANE: A specialized pane that allows its children to be drawn in layers, providing a form of stacking order
+ *@ATK_ROLE_LIST: An object that presents a list of objects to the user and allows the user to select one or more of them 
+ *@ATK_ROLE_LIST_ITEM: An object that represents an element of a list 
+ *@ATK_ROLE_MENU: An object usually found inside a menu bar that contains a list of actions the user can choose from
+ *@ATK_ROLE_MENU_BAR: An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from 
+ *@ATK_ROLE_MENU_ITEM: An object usually contained in a menu that presents an action the user can choose
+ *@ATK_ROLE_OPTION_PANE: A specialized pane whose primary use is inside a DIALOG
+ *@ATK_ROLE_PAGE_TAB: An object that is a child of a page tab list
+ *@ATK_ROLE_PAGE_TAB_LIST: An object that presents a series of panels (or page tabs), one at a time, through some mechanism provided by the object 
+ *@ATK_ROLE_PANEL: A generic container that is often used to group objects
+ *@ATK_ROLE_PASSWORD_TEXT: A text object uses for passwords, or other places where the text content is not shown visibly to the user
+ *@ATK_ROLE_POPUP_MENU: A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices
+ *@ATK_ROLE_PROGRESS_BAR: An object used to indicate how much of a task has been completed
+ *@ATK_ROLE_PUSH_BUTTON: An object the user can manipulate to tell the application to do something
+ *@ATK_ROLE_RADIO_BUTTON: A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked
+ *@ATK_ROLE_RADIO_MENU_ITEM: A check menu item which belongs to a group. At each instant exactly one of the radio menu items from a group is selected
+ *@ATK_ROLE_ROOT_PANE: A specialized pane that has a glass pane and a layered pane as its children
+ *@ATK_ROLE_ROW_HEADER: The header for a row of data
+ *@ATK_ROLE_SCROLL_BAR: An object usually used to allow a user to incrementally view a large amount of data.
+ *@ATK_ROLE_SCROLL_PANE: An object that allows a user to incrementally view a large amount of information
+ *@ATK_ROLE_SEPARATOR: An object usually contained in a menu to provide a visible and logical separation of the contents in a menu
+ *@ATK_ROLE_SLIDER: An object that allows the user to select from a bounded range
+ *@ATK_ROLE_SPLIT_PANE: A specialized panel that presents two other panels at the same time
+ *@ATK_ROLE_SPIN_BUTTON: An object used to get an integer or floating point number from the user
+ *@ATK_ROLE_STATUSBAR: An object which reports messages of minor importance to the user
+ *@ATK_ROLE_TABLE: An object used to represent information in terms of rows and columns
+ *@ATK_ROLE_TABLE_CELL: A cell in a table
+ *@ATK_ROLE_TABLE_COLUMN_HEADER: The header for a column of a table
+ *@ATK_ROLE_TABLE_ROW_HEADER: The header for a row of a table
+ *@ATK_ROLE_TEAR_OFF_MENU_ITEM: A menu item used to tear off and reattach its menu
+ *@ATK_ROLE_TERMINAL: An object that represents an accessible terminal.  @Since: ATK-0.6
+ *@ATK_ROLE_TEXT: An interactive widget that supports multiple lines of text and
+ * optionally accepts user input, but whose purpose is not to solicit user input.
+ * Thus ATK_ROLE_TEXT is appropriate for the text view in a plain text editor
+ * but inappropriate for an input field in a dialog box or web form. For widgets
+ * whose purpose is to solicit input from the user, see ATK_ROLE_ENTRY and
+ * ATK_ROLE_PASSWORD_TEXT. For generic objects which display a brief amount of
+ * textual information, see ATK_ROLE_STATIC.
+ *@ATK_ROLE_TOGGLE_BUTTON: A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state
+ *@ATK_ROLE_TOOL_BAR: A bar or palette usually composed of push buttons or toggle buttons
+ *@ATK_ROLE_TOOL_TIP: An object that provides information about another object
+ *@ATK_ROLE_TREE: An object used to represent hierarchical information to the user
+ *@ATK_ROLE_TREE_TABLE: An object capable of expanding and collapsing rows as well as showing multiple columns of data.   @Since: ATK-0.7
+ *@ATK_ROLE_UNKNOWN: The object contains some Accessible information, but its role is not known
+ *@ATK_ROLE_VIEWPORT: An object usually used in a scroll pane
+ *@ATK_ROLE_WINDOW: A top level window with no title or border.
+ *@ATK_ROLE_HEADER: An object that serves as a document header. @Since: ATK-1.1.1
+ *@ATK_ROLE_FOOTER: An object that serves as a document footer.  @Since: ATK-1.1.1
+ *@ATK_ROLE_PARAGRAPH: An object which is contains a paragraph of text content.   @Since: ATK-1.1.1
+ *@ATK_ROLE_RULER: An object which describes margins and tab stops, etc. for text objects which it controls (should have CONTROLLER_FOR relation to such).   @Since: ATK-1.1.1
+ *@ATK_ROLE_APPLICATION: The object is an application object, which may contain @ATK_ROLE_FRAME objects or other types of accessibles.  The root accessible of any application's ATK hierarchy should have ATK_ROLE_APPLICATION.   @Since: ATK-1.1.4
+ *@ATK_ROLE_AUTOCOMPLETE: The object is a dialog or list containing items for insertion into an entry widget, for instance a list of words for completion of a text entry.   @Since: ATK-1.3
+ *@ATK_ROLE_EDITBAR: The object is an editable text object in a toolbar.  @Since: ATK-1.5
+ *@ATK_ROLE_EMBEDDED: The object is an embedded container within a document or panel.  This role is a grouping "hint" indicating that the contained objects share a context.  @Since: ATK-1.7.2
+ *@ATK_ROLE_ENTRY: The object is a component whose textual content may be entered or modified by the user, provided @ATK_STATE_EDITABLE is present.   @Since: ATK-1.11
+ *@ATK_ROLE_CHART: The object is a graphical depiction of quantitative data. It may contain multiple subelements whose attributes and/or description may be queried to obtain both the quantitative data and information about how the data is being presented. The LABELLED_BY relation is particularly important in interpreting objects of this type, as is the accessible-description property.  @Since: ATK-1.11
+ *@ATK_ROLE_CAPTION: The object contains descriptive information, usually textual, about another user interface element such as a table, chart, or image.  @Since: ATK-1.11
+ *@ATK_ROLE_DOCUMENT_FRAME: The object is a visual frame or container which contains a view of document content. Document frames may occur within another Document instance, in which case the second document may be said to be embedded in the containing instance. HTML frames are often ROLE_DOCUMENT_FRAME. Either this object, or a singleton descendant, should implement the Document interface.  @Since: ATK-1.11
+ *@ATK_ROLE_HEADING: The object serves as a heading for content which follows it in a document. The 'heading level' of the heading, if availabe, may be obtained by querying the object's attributes.
+ *@ATK_ROLE_PAGE: The object is a containing instance which encapsulates a page of information. @ATK_ROLE_PAGE is used in documents and content which support a paginated navigation model.  @Since: ATK-1.11
+ *@ATK_ROLE_SECTION: The object is a containing instance of document content which constitutes a particular 'logical' section of the document. The type of content within a section, and the nature of the section division itself, may be obtained by querying the object's attributes. Sections may be nested. @Since: ATK-1.11
+ *@ATK_ROLE_REDUNDANT_OBJECT: The object is redundant with another object in the hierarchy, and is exposed for purely technical reasons.  Objects of this role should normally be ignored by clients. @Since: ATK-1.11
+ *@ATK_ROLE_FORM: The object is a container for form controls, for instance as part of a 
+ * web form or user-input form within a document.  This role is primarily a tag/convenience for 
+ * clients when navigating complex documents, it is not expected that ordinary GUI containers will 
+ * always have ATK_ROLE_FORM. @Since: ATK-1.12.0
+ *@ATK_ROLE_LINK: The object is a hypertext anchor, i.e. a "link" in a
+ * hypertext document.  Such objects are distinct from 'inline'
+ * content which may also use the Hypertext/Hyperlink interfaces
+ * to indicate the range/location within a text object where
+ * an inline or embedded object lies.  @Since: ATK-1.12.1
+ *@ATK_ROLE_INPUT_METHOD_WINDOW: The object is a window or similar viewport 
+ * which is used to allow composition or input of a 'complex character',
+ * in other words it is an "input method window." @Since: ATK-1.12.1
+ *@ATK_ROLE_TABLE_ROW: A row in a table.  @Since: ATK-2.1.0
+ *@ATK_ROLE_TREE_ITEM: An object that represents an element of a tree.  @Since: ATK-2.1.0
+ *@ATK_ROLE_DOCUMENT_SPREADSHEET: A document frame which contains a spreadsheet.  @Since: ATK-2.1.0
+ *@ATK_ROLE_DOCUMENT_PRESENTATION: A document frame which contains a presentation or slide content.  @Since: ATK-2.1.0
+ *@ATK_ROLE_DOCUMENT_TEXT: A document frame which contains textual content, such as found in a word processing application.  @Since: ATK-2.1.0
+ *@ATK_ROLE_DOCUMENT_WEB: A document frame which contains HTML or other markup suitable for display in a web browser.  @Since: ATK-2.1.0
+ *@ATK_ROLE_DOCUMENT_EMAIL: A document frame which contains email content to be displayed or composed either in plain text or HTML.  @Since: ATK-2.1.0
+ *@ATK_ROLE_COMMENT: An object found within a document and designed to present a comment, note, or other annotation. In some cases, this object might not be visible until activated.  @Since: ATK-2.1.0
+ *@ATK_ROLE_LIST_BOX: A non-collapsible list of choices the user can select from. @Since: ATK-2.1.0
+ *@ATK_ROLE_GROUPING: A group of related widgets. This group typically has a label. @Since: ATK-2.1.0
+ *@ATK_ROLE_IMAGE_MAP: An image map object. Usually a graphic with multiple hotspots, where each hotspot can be activated resulting in the loading of another document or section of a document. @Since: ATK-2.1.0
+ *@ATK_ROLE_NOTIFICATION: A transitory object designed to present a message to the user, typically at the desktop level rather than inside a particular application.  @Since: ATK-2.1.0
+ *@ATK_ROLE_INFO_BAR: An object designed to present a message to the user within an existing window. @Since: ATK-2.1.0
+ *@ATK_ROLE_LEVEL_BAR: A bar that serves as a level indicator to, for instance, show the strength of a password or the state of a battery.  @Since: ATK-2.7.3
+ *@ATK_ROLE_TITLE_BAR: A bar that serves as the title of a window or a
+ * dialog. @Since: ATK-2.12
+ *@ATK_ROLE_BLOCK_QUOTE: An object which contains a text section
+ * that is quoted from another source. @Since: ATK-2.12
+ *@ATK_ROLE_AUDIO: An object which represents an audio element. @Since: ATK-2.12
+ *@ATK_ROLE_VIDEO: An object which represents a video element. @Since: ATK-2.12
+ *@ATK_ROLE_DEFINITION: A definition of a term or concept. @Since: ATK-2.12
+ *@ATK_ROLE_ARTICLE: A section of a page that consists of a
+ * composition that forms an independent part of a document, page, or
+ * site. Examples: A blog entry, a news story, a forum post. @Since:
+ * ATK-2.12
+ *@ATK_ROLE_LANDMARK: A region of a web page intended as a
+ * navigational landmark. This is designed to allow Assistive
+ * Technologies to provide quick navigation among key regions within a
+ * document. @Since: ATK-2.12
+ *@ATK_ROLE_LOG: A text widget or container holding log content, such
+ * as chat history and error logs. In this role there is a
+ * relationship between the arrival of new items in the log and the
+ * reading order. The log contains a meaningful sequence and new
+ * information is added only to the end of the log, not at arbitrary
+ * points. @Since: ATK-2.12
+ *@ATK_ROLE_MARQUEE: A container where non-essential information
+ * changes frequently. Common usages of marquee include stock tickers
+ * and ad banners. The primary difference between a marquee and a log
+ * is that logs usually have a meaningful order or sequence of
+ * important content changes. @Since: ATK-2.12
+ *@ATK_ROLE_MATH: A text widget or container that holds a mathematical
+ * expression. @Since: ATK-2.12
+ *@ATK_ROLE_RATING: A widget whose purpose is to display a rating,
+ * such as the number of stars associated with a song in a media
+ * player. Objects of this role should also implement
+ * AtkValue. @Since: ATK-2.12
+ *@ATK_ROLE_TIMER: An object containing a numerical counter which
+ * indicates an amount of elapsed time from a start point, or the time
+ * remaining until an end point. @Since: ATK-2.12
+ *@ATK_ROLE_DESCRIPTION_LIST: An object that represents a list of
+ * term-value groups. A term-value group represents a individual
+ * description and consist of one or more names
+ * (ATK_ROLE_DESCRIPTION_TERM) followed by one or more values
+ * (ATK_ROLE_DESCRIPTION_VALUE). For each list, there should not be
+ * more than one group with the same term name. @Since: ATK-2.12
+ *@ATK_ROLE_DESCRIPTION_TERM: An object that represents the term, or
+ * name, part of a term-description group in a description
+ * list. @Since: ATK-2.12
+ *@ATK_ROLE_DESCRIPTION_VALUE: An object that represents the
+ * description, definition or value of a term-description group in a
+ * description list. The values within a group are alternatives,
+ * meaning that you can have several ATK_ROLE_DESCRIPTION_VALUE for a
+ * given ATK_ROLE_DESCRIPTION_TERM. @Since: ATK-2.12
+ *@ATK_ROLE_STATIC: A generic non-container object whose purpose is to display a
+ * brief amount of information to the user and whose role is known by the
+ * implementor but lacks semantic value for the user. Examples in which
+ * ATK_ROLE_STATIC is appropriate include the message displayed in a message box
+ * and an image used as an alternative means to display text. ATK_ROLE_STATIC
+ * should not be applied to widgets which are traditionally interactive, objects
+ * which display a significant amount of content, or any object which has an
+ * accessible relation pointing to another object. Implementors should expose the
+ * displayed information through the accessible name of the object. If doing so seems
+ * inappropriate, it may indicate that a different role should be used. For
+ * labels which describe another widget, see ATK_ROLE_LABEL. For text views, see
+ * ATK_ROLE_TEXT. For generic containers, see ATK_ROLE_PANEL. For objects whose
+ * role is not known by the implementor, see ATK_ROLE_UNKNOWN. @Since: ATK-2.16.
+ *@ATK_ROLE_MATH_FRACTION: An object that represents a mathematical fraction.
+ * @Since: ATK-2.16.
+ *@ATK_ROLE_MATH_ROOT: An object that represents a mathematical expression
+ * displayed with a radical. @Since: ATK-2.16.
+ *@ATK_ROLE_LAST_DEFINED: not a valid role, used for finding end of the enumeration
+ *
+ * Describes the role of an object
+ *
+ * These are the built-in enumerated roles that UI components can have in
+ * ATK.  Other roles may be added at runtime, so an AtkRole >=
+ * ATK_ROLE_LAST_DEFINED is not necessarily an error.
+ **/
+typedef enum
+{
+  ATK_ROLE_INVALID = 0,
+  ATK_ROLE_ACCEL_LABEL,      /*<nick=accelerator-label>*/
+  ATK_ROLE_ALERT,
+  ATK_ROLE_ANIMATION,
+  ATK_ROLE_ARROW,
+  ATK_ROLE_CALENDAR,
+  ATK_ROLE_CANVAS,
+  ATK_ROLE_CHECK_BOX,
+  ATK_ROLE_CHECK_MENU_ITEM,
+  ATK_ROLE_COLOR_CHOOSER,
+  ATK_ROLE_COLUMN_HEADER,
+  ATK_ROLE_COMBO_BOX,
+  ATK_ROLE_DATE_EDITOR,
+  ATK_ROLE_DESKTOP_ICON,
+  ATK_ROLE_DESKTOP_FRAME,
+  ATK_ROLE_DIAL,
+  ATK_ROLE_DIALOG,
+  ATK_ROLE_DIRECTORY_PANE,
+  ATK_ROLE_DRAWING_AREA,
+  ATK_ROLE_FILE_CHOOSER,
+  ATK_ROLE_FILLER,
+  ATK_ROLE_FONT_CHOOSER,
+  ATK_ROLE_FRAME,
+  ATK_ROLE_GLASS_PANE,
+  ATK_ROLE_HTML_CONTAINER,
+  ATK_ROLE_ICON,
+  ATK_ROLE_IMAGE,
+  ATK_ROLE_INTERNAL_FRAME,
+  ATK_ROLE_LABEL,
+  ATK_ROLE_LAYERED_PANE,
+  ATK_ROLE_LIST,
+  ATK_ROLE_LIST_ITEM,
+  ATK_ROLE_MENU,
+  ATK_ROLE_MENU_BAR,
+  ATK_ROLE_MENU_ITEM,
+  ATK_ROLE_OPTION_PANE,
+  ATK_ROLE_PAGE_TAB,
+  ATK_ROLE_PAGE_TAB_LIST,
+  ATK_ROLE_PANEL,
+  ATK_ROLE_PASSWORD_TEXT,
+  ATK_ROLE_POPUP_MENU,
+  ATK_ROLE_PROGRESS_BAR,
+  ATK_ROLE_PUSH_BUTTON,
+  ATK_ROLE_RADIO_BUTTON,
+  ATK_ROLE_RADIO_MENU_ITEM,
+  ATK_ROLE_ROOT_PANE,
+  ATK_ROLE_ROW_HEADER,
+  ATK_ROLE_SCROLL_BAR,
+  ATK_ROLE_SCROLL_PANE,
+  ATK_ROLE_SEPARATOR,
+  ATK_ROLE_SLIDER,
+  ATK_ROLE_SPLIT_PANE,
+  ATK_ROLE_SPIN_BUTTON,
+  ATK_ROLE_STATUSBAR,
+  ATK_ROLE_TABLE,
+  ATK_ROLE_TABLE_CELL,
+  ATK_ROLE_TABLE_COLUMN_HEADER,
+  ATK_ROLE_TABLE_ROW_HEADER,
+  ATK_ROLE_TEAR_OFF_MENU_ITEM,
+  ATK_ROLE_TERMINAL,
+  ATK_ROLE_TEXT,
+  ATK_ROLE_TOGGLE_BUTTON,
+  ATK_ROLE_TOOL_BAR,
+  ATK_ROLE_TOOL_TIP,
+  ATK_ROLE_TREE,
+  ATK_ROLE_TREE_TABLE,
+  ATK_ROLE_UNKNOWN,
+  ATK_ROLE_VIEWPORT,
+  ATK_ROLE_WINDOW,
+  ATK_ROLE_HEADER,
+  ATK_ROLE_FOOTER,
+  ATK_ROLE_PARAGRAPH,
+  ATK_ROLE_RULER,
+  ATK_ROLE_APPLICATION,
+  ATK_ROLE_AUTOCOMPLETE,
+  ATK_ROLE_EDITBAR,
+  ATK_ROLE_EMBEDDED,
+  ATK_ROLE_ENTRY,
+  ATK_ROLE_CHART,
+  ATK_ROLE_CAPTION,
+  ATK_ROLE_DOCUMENT_FRAME,
+  ATK_ROLE_HEADING,
+  ATK_ROLE_PAGE,
+  ATK_ROLE_SECTION,
+  ATK_ROLE_REDUNDANT_OBJECT,
+  ATK_ROLE_FORM,
+  ATK_ROLE_LINK,
+  ATK_ROLE_INPUT_METHOD_WINDOW,
+  ATK_ROLE_TABLE_ROW,
+  ATK_ROLE_TREE_ITEM,
+  ATK_ROLE_DOCUMENT_SPREADSHEET,
+  ATK_ROLE_DOCUMENT_PRESENTATION,
+  ATK_ROLE_DOCUMENT_TEXT,
+  ATK_ROLE_DOCUMENT_WEB,
+  ATK_ROLE_DOCUMENT_EMAIL,
+  ATK_ROLE_COMMENT,
+  ATK_ROLE_LIST_BOX,
+  ATK_ROLE_GROUPING,
+  ATK_ROLE_IMAGE_MAP,
+  ATK_ROLE_NOTIFICATION,
+  ATK_ROLE_INFO_BAR,
+  ATK_ROLE_LEVEL_BAR,
+  ATK_ROLE_TITLE_BAR,
+  ATK_ROLE_BLOCK_QUOTE,
+  ATK_ROLE_AUDIO,
+  ATK_ROLE_VIDEO,
+  ATK_ROLE_DEFINITION,
+  ATK_ROLE_ARTICLE,
+  ATK_ROLE_LANDMARK,
+  ATK_ROLE_LOG,
+  ATK_ROLE_MARQUEE,
+  ATK_ROLE_MATH,
+  ATK_ROLE_RATING,
+  ATK_ROLE_TIMER,
+  ATK_ROLE_DESCRIPTION_LIST,
+  ATK_ROLE_DESCRIPTION_TERM,
+  ATK_ROLE_DESCRIPTION_VALUE,
+  ATK_ROLE_STATIC,
+  ATK_ROLE_MATH_FRACTION,
+  ATK_ROLE_MATH_ROOT,
+  ATK_ROLE_LAST_DEFINED
+} AtkRole;
+
+AtkRole                  atk_role_register        (const gchar *name);
+
+/**
+ *AtkLayer:
+ *@ATK_LAYER_INVALID: The object does not have a layer
+ *@ATK_LAYER_BACKGROUND: This layer is reserved for the desktop background
+ *@ATK_LAYER_CANVAS: This layer is used for Canvas components
+ *@ATK_LAYER_WIDGET: This layer is normally used for components
+ *@ATK_LAYER_MDI: This layer is used for layered components
+ *@ATK_LAYER_POPUP: This layer is used for popup components, such as menus
+ *@ATK_LAYER_OVERLAY: This layer is reserved for future use.
+ *@ATK_LAYER_WINDOW: This layer is used for toplevel windows.
+ *
+ * Describes the layer of a component
+ *
+ * These enumerated "layer values" are used when determining which UI
+ * rendering layer a component is drawn into, which can help in making
+ * determinations of when components occlude one another.
+ **/
+typedef enum
+{
+  ATK_LAYER_INVALID,
+  ATK_LAYER_BACKGROUND,
+  ATK_LAYER_CANVAS,
+  ATK_LAYER_WIDGET,
+  ATK_LAYER_MDI,
+  ATK_LAYER_POPUP,
+  ATK_LAYER_OVERLAY,
+  ATK_LAYER_WINDOW
+} AtkLayer;
+
+/**
+ * AtkAttributeSet:
+ *
+ * This is a singly-linked list (a #GSList) of #AtkAttribute. It is
+ * used by atk_text_get_run_attributes(), atk_text_get_default_attributes()
+ * and atk_editable_text_set_run_attributes()
+ **/
+typedef GSList AtkAttributeSet;
+
+/**
+ * AtkAttribute:
+ * @name: The attribute name. Call atk_text_attr_get_name()
+ * @value: the value of the attribute, represented as a string. 
+ * Call atk_text_attr_get_value() for those which are strings.
+ * For values which are numbers, the string representation of the number 
+ * is in value.
+ *
+ * A string name/value pair representing a text attribute. 
+ **/
+typedef struct _AtkAttribute AtkAttribute;
+
+struct _AtkAttribute {
+  gchar* name;
+  gchar* value;
+};
+
+#define ATK_TYPE_OBJECT                           (atk_object_get_type ())
+#define ATK_OBJECT(obj)                           (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_OBJECT, AtkObject))
+#define ATK_OBJECT_CLASS(klass)                   (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_OBJECT, AtkObjectClass))
+#define ATK_IS_OBJECT(obj)                        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_OBJECT))
+#define ATK_IS_OBJECT_CLASS(klass)                (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_OBJECT))
+#define ATK_OBJECT_GET_CLASS(obj)                 (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_OBJECT, AtkObjectClass))
+
+#define ATK_TYPE_IMPLEMENTOR                      (atk_implementor_get_type ())
+#define ATK_IS_IMPLEMENTOR(obj)                   G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_IMPLEMENTOR)
+#define ATK_IMPLEMENTOR(obj)                      G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_IMPLEMENTOR, AtkImplementor)
+#define ATK_IMPLEMENTOR_GET_IFACE(obj)            (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_IMPLEMENTOR, AtkImplementorIface))
+
+
+typedef struct _AtkImplementor            AtkImplementor; /* dummy typedef */
+typedef struct _AtkImplementorIface       AtkImplementorIface;
+
+
+typedef struct _AtkObject                 AtkObject;
+typedef struct _AtkObjectClass            AtkObjectClass;
+typedef struct _AtkRelationSet            AtkRelationSet;
+typedef struct _AtkStateSet               AtkStateSet;
+
+/**
+ * AtkPropertyValues:
+ * @property_name: The name of the ATK property which is being presented or which has been changed.
+ * @old_value: The old property value, NULL; in some contexts this value is undefined (see note below).
+ * @new_value: The new value of the named property.
+ *
+ * @note: For most properties the old_value field of AtkPropertyValues will
+ * not contain a valid value.
+ *
+ * Currently, the only property for which old_value is used is
+ * accessible-state; for instance if there is a focus state the
+ * property change handler will be called for the object which lost the focus
+ * with the old_value containing an AtkState value corresponding to focused
+ * and the property change handler will be called for the object which
+ * received the focus with the new_value containing an AtkState value
+ * corresponding to focused.
+ *
+ **/
+struct _AtkPropertyValues
+{
+  const gchar  *property_name;
+  GValue old_value;
+  GValue new_value;
+};
+
+typedef struct _AtkPropertyValues        AtkPropertyValues;
+
+typedef gboolean (*AtkFunction)          (gpointer data); 
+/*
+ * For most properties the old_value field of AtkPropertyValues will
+ * not contain a valid value.
+ *
+ * Currently, the only property for which old_value is used is
+ * accessible-state; for instance if there is a focus state the
+ * property change handler will be called for the object which lost the focus
+ * with the old_value containing an AtkState value corresponding to focused
+ * and the property change handler will be called for the object which
+ * received the focus with the new_value containing an AtkState value
+ * corresponding to focused.
+ */
+typedef void (*AtkPropertyChangeHandler) (AtkObject*, AtkPropertyValues*);
+
+
+struct _AtkObject
+{
+  GObject parent;
+
+  gchar *description;
+  gchar *name;
+  AtkObject *accessible_parent;
+  AtkRole role;
+  AtkRelationSet *relation_set;
+  AtkLayer layer;
+};
+
+struct _AtkObjectClass
+{
+  GObjectClass parent;
+
+  /*
+   * Gets the accessible name of the object
+   */
+  G_CONST_RETURN gchar*    (* get_name)            (AtkObject                *accessible);
+  /*
+   * Gets the accessible description of the object
+   */
+  G_CONST_RETURN gchar*    (* get_description)     (AtkObject                *accessible);
+  /*
+   * Gets the accessible parent of the object
+   */
+  AtkObject*               (*get_parent)           (AtkObject                *accessible);
+
+  /*
+   * Gets the number of accessible children of the object
+   */
+  gint                    (* get_n_children)       (AtkObject                *accessible);
+  /*
+   * Returns a reference to the specified accessible child of the object.
+   * The accessible children are 0-based so the first accessible child is
+   * at index 0, the second at index 1 and so on.
+   */
+  AtkObject*              (* ref_child)            (AtkObject                *accessible,
+                                                    gint                      i);
+  /*
+   * Gets the 0-based index of this object in its parent; returns -1 if the
+   * object does not have an accessible parent.
+   */
+  gint                    (* get_index_in_parent) (AtkObject                 *accessible);
+  /*
+   * Gets the RelationSet associated with the object
+   */
+  AtkRelationSet*         (* ref_relation_set)    (AtkObject                 *accessible);
+  /*
+   * Gets the role of the object
+   */
+  AtkRole                 (* get_role)            (AtkObject                 *accessible);
+  AtkLayer                (* get_layer)           (AtkObject                 *accessible);
+  gint                    (* get_mdi_zorder)      (AtkObject                 *accessible);
+  /*
+   * Gets the state set of the object
+   */
+  AtkStateSet*            (* ref_state_set)       (AtkObject                 *accessible);
+  /*
+   * Sets the accessible name of the object
+   */
+  void                    (* set_name)            (AtkObject                 *accessible,
+                                                   const gchar               *name);
+  /*
+   * Sets the accessible description of the object
+   */
+  void                    (* set_description)     (AtkObject                 *accessible,
+                                                   const gchar               *description);
+  /*
+   * Sets the accessible parent of the object
+   */
+  void                    (* set_parent)          (AtkObject                 *accessible,
+                                                   AtkObject                 *parent);
+  /*
+   * Sets the accessible role of the object
+   */
+  void                    (* set_role)            (AtkObject                 *accessible,
+                                                   AtkRole                   role);
+  /*
+   * Specifies a function to be called when a property changes value
+   */
+guint                     (* connect_property_change_handler)    (AtkObject
+                 *accessible,
+                                                                  AtkPropertyChangeHandler       *handler);
+  /*
+   * Removes a property change handler which was specified using
+   * connect_property_change_handler
+   */
+void                      (* remove_property_change_handler)     (AtkObject
+                *accessible,
+                                                                  guint
+                handler_id);
+void                      (* initialize)                         (AtkObject                     *accessible,
+                                                                  gpointer                      data);
+  /*
+   * The signal handler which is executed when there is a change in the
+   * children of the object
+   */
+  void                    (* children_changed)    (AtkObject                  *accessible,
+                                                   guint                      change_index,
+                                                   gpointer                   changed_child);
+  /*
+   * The signal handler which is executed  when there is a focus event
+   * for an object.
+   */
+  void                    (* focus_event)         (AtkObject                  *accessible,
+                                                   gboolean                   focus_in);
+  /*
+   * The signal handler which is executed  when there is a property_change 
+   * signal for an object.
+   */
+  void                    (* property_change)     (AtkObject                  *accessible,
+                                                   AtkPropertyValues          *values);
+  /*
+   * The signal handler which is executed  when there is a state_change 
+   * signal for an object.
+   */
+  void                    (* state_change)        (AtkObject                  *accessible,
+                                                   const gchar                *name,
+                                                   gboolean                   state_set);
+  /*
+   * The signal handler which is executed when there is a change in the
+   * visible data for an object
+   */
+  void                    (*visible_data_changed) (AtkObject                  *accessible);
+
+  /*
+   * The signal handler which is executed when there is a change in the
+   * 'active' child or children of the object, for instance when 
+   * interior focus changes in a table or list.  This signal should be emitted
+   * by objects whose state includes ATK_STATE_MANAGES_DESCENDANTS.
+   */
+  void                    (*active_descendant_changed) (AtkObject                  *accessible,
+                                                        gpointer                   *child);
+
+  /*    	
+   * Gets a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of name-value pairs. 
+   * Since ATK 1.12
+   */
+  AtkAttributeSet* 	  (*get_attributes)            (AtkObject                  *accessible);
+
+  const gchar*            (*get_object_locale)         (AtkObject                  *accessible);
+
+  AtkFunction             pad1;
+};
+
+GType            atk_object_get_type   (void);
+
+struct _AtkImplementorIface
+{
+  GTypeInterface parent;
+
+  AtkObject*   (*ref_accessible) (AtkImplementor *implementor);
+};
+GType atk_implementor_get_type (void);
+
+/*
+ * This method uses the ref_accessible method in AtkImplementorIface,
+ * if the object's class implements AtkImplementorIface.
+ * Otherwise it returns %NULL.
+ *
+ * IMPORTANT:
+ * Note also that because this method may return flyweight objects,
+ * it increments the returned AtkObject's reference count.
+ * Therefore it is the responsibility of the calling
+ * program to unreference the object when no longer needed.
+ * (c.f. gtk_widget_get_accessible() where this is not the case).
+ */
+AtkObject*              atk_implementor_ref_accessible            (AtkImplementor *implementor);
+
+/*
+ * Properties directly supported by AtkObject
+ */
+
+G_CONST_RETURN gchar*   atk_object_get_name                       (AtkObject *accessible);
+G_CONST_RETURN 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,
+                                                                   gint        i);
+AtkRelationSet*         atk_object_ref_relation_set               (AtkObject *accessible);
+AtkRole                 atk_object_get_role                       (AtkObject *accessible);
+AtkLayer                atk_object_get_layer                      (AtkObject *accessible);
+gint                    atk_object_get_mdi_zorder                 (AtkObject *accessible);
+AtkAttributeSet*        atk_object_get_attributes                 (AtkObject *accessible);
+AtkStateSet*            atk_object_ref_state_set                  (AtkObject *accessible);
+gint                    atk_object_get_index_in_parent            (AtkObject *accessible);
+void                    atk_object_set_name                       (AtkObject *accessible,
+                                                                   const gchar *name);
+void                    atk_object_set_description                (AtkObject *accessible,
+                                                                   const gchar *description);
+void                    atk_object_set_parent                     (AtkObject *accessible,
+                                                                   AtkObject *parent);
+void                    atk_object_set_role                       (AtkObject *accessible,
+                                                                   AtkRole   role);
+
+
+guint                atk_object_connect_property_change_handler  (AtkObject                      *accessible,
+                                                                  AtkPropertyChangeHandler       *handler);
+void                 atk_object_remove_property_change_handler   (AtkObject                      *accessible,
+                                                                  guint                          handler_id);
+
+void                 atk_object_notify_state_change              (AtkObject                      *accessible,
+                                                                  AtkState                       state,
+                                                                  gboolean                       value);
+void                 atk_object_initialize                       (AtkObject                     *accessible,
+                                                                  gpointer                      data);
+                                    
+G_CONST_RETURN gchar* atk_role_get_name      (AtkRole         role);
+AtkRole               atk_role_for_name      (const gchar     *name);
+
+
+/* NEW in 1.1: convenience API */
+gboolean              atk_object_add_relationship              (AtkObject      *object,
+								AtkRelationType relationship,
+								AtkObject      *target);
+gboolean              atk_object_remove_relationship           (AtkObject      *object,
+								AtkRelationType relationship,
+								AtkObject      *target);
+G_CONST_RETURN gchar* atk_role_get_localized_name              (AtkRole     role);
+
+/* */
+
+
+/*
+ * Note: the properties which are registered with the GType
+ *   property registry, for type ATK_TYPE_OBJECT, are as follows:
+ *
+ *   "accessible-name"
+ *   "accessible-description"
+ *   "accessible-parent"
+ *   "accessible-role"
+ *   "accessible-value"
+ *   "accessible-component-layer"
+ *   "accessible-component-zorder"
+ *   "accessible-table-caption"
+ *   "accessible-table-column-description"
+ *   "accessible-table-column-header"
+ *   "accessible-table-row-description"
+ *   "accessible-table-row-header"
+ *   "accessible-table-summary"
+ *   "accessible-model"
+ *
+ * accessibility property change listeners should use the
+ *   normal GObject property interfaces and "property-change"
+ *   signal handler semantics to interpret the property change
+ *   information relayed from AtkObject.
+ *   (AtkObject instances will connect to the "notify"
+ *   signal in their host objects, and relay the signals when appropriate).
+ */
+
+/* For other signals, see related interfaces
+ *
+ *    AtkActionIface,
+ *    AtkComponentIface,
+ *    AtkHypertextIface,
+ *    AtkImageIface,
+ *    AtkSelectionIface,
+ *    AtkTableIface,
+ *    AtkTextIface,
+ *    AtkValueIface.
+ *
+ *  The usage model for obtaining these interface instances is:
+ *    ATK_<interfacename>_GET_IFACE(GObject *accessible),
+ *    where accessible, though specified as a GObject, is
+ *    the AtkObject instance being queried.
+ *  More usually, the interface will be used via a cast to the
+ *    interface's corresponding "type":
+ *
+ *    AtkText textImpl = ATK_TEXT(accessible);
+ *    if (textImpl)
+ *      {
+ *        cpos = atk_text_get_caret_position(textImpl);
+ *      }
+ *
+ *  If it's known in advance that accessible implements AtkTextIface,
+ *    this is shortened to:
+ *
+ *    cpos = atk_text_get_caret_position (ATK_TEXT (accessible));
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_OBJECT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkobjectfactory.h b/other-licenses/atk-1.0/atk/atkobjectfactory.h
new file mode 100644
index 000000000..fb163adb8
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkobjectfactory.h
@@ -0,0 +1,68 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_OBJECT_FACTORY_H__
+#define __ATK_OBJECT_FACTORY_H__
+
+#include <glib-object.h>
+#include <atk/atkobject.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define ATK_TYPE_OBJECT_FACTORY                     (atk_object_factory_get_type ())
+#define ATK_OBJECT_FACTORY(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_OBJECT_FACTORY, AtkObjectFactory))
+#define ATK_OBJECT_FACTORY_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_OBJECT_FACTORY, AtkObjectFactoryClass))
+#define ATK_IS_OBJECT_FACTORY(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_OBJECT_FACTORY))
+#define ATK_IS_OBJECT_FACTORY_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_OBJECT_FACTORY))
+#define ATK_OBJECT_FACTORY_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_OBJECT_FACTORY, AtkObjectFactoryClass))
+
+typedef struct _AtkObjectFactory                AtkObjectFactory;
+typedef struct _AtkObjectFactoryClass           AtkObjectFactoryClass;
+
+struct _AtkObjectFactory
+{
+  GObject parent;
+};
+
+struct _AtkObjectFactoryClass
+{
+  GObjectClass parent_class;
+
+  AtkObject* (* create_accessible) (GObject          *obj);
+  void       (* invalidate)        (AtkObjectFactory *factory);
+  GType      (* get_accessible_type)    (void);
+
+  AtkFunction pad1;
+  AtkFunction pad2;
+};
+
+GType atk_object_factory_get_type(void);
+
+AtkObject* atk_object_factory_create_accessible (AtkObjectFactory *factory, GObject *obj);
+void       atk_object_factory_invalidate (AtkObjectFactory *factory);
+GType      atk_object_factory_get_accessible_type (AtkObjectFactory *factory);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GTK_OBJECT_FACTORY_H__ */
+
diff --git a/other-licenses/atk-1.0/atk/atkplug.h b/other-licenses/atk-1.0/atk/atkplug.h
new file mode 100644
index 000000000..7d6efd4b9
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkplug.h
@@ -0,0 +1,61 @@
+/* ATK -  Accessibility Toolkit
+ * Copyright 2009 Novell, 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.
+ */
+
+#if defined(ATK_DISABLE_SINGLE_INCLUDES) && !defined (__ATK_H_INSIDE__) && !defined (ATK_COMPILATION)
+#error "Only <atk/atk.h> can be included directly."
+#endif
+
+#ifndef __ATK_PLUG_H__
+#define __ATK_PLUG_H__
+
+G_BEGIN_DECLS
+
+#define ATK_TYPE_PLUG               (atk_plug_get_type ())
+#define ATK_PLUG(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_PLUG, AtkPlug))
+#define ATK_IS_PLUG(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_PLUG))
+#define ATK_PLUG_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_PLUG, AtkPlugClass))
+#define ATK_IS_PLUG_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_PLUG))
+#define ATK_PLUG_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_PLUG, AtkPlugClass))
+
+typedef struct _AtkPlug         AtkPlug;
+typedef struct _AtkPlugClass    AtkPlugClass;
+
+struct _AtkPlug
+{
+  AtkObject parent;
+};
+
+GType atk_plug_get_type (void);
+
+struct _AtkPlugClass
+{
+  AtkObjectClass parent_class;
+  
+  /* to be subscribed to by atk-bridge */
+
+  /*< protected >*/
+  gchar* (* get_object_id) (AtkPlug* obj);
+};
+
+AtkObject*    atk_plug_new     (void);
+gchar*        atk_plug_get_id  (AtkPlug* plug);
+
+G_END_DECLS
+
+#endif /* __ATK_PLUG_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkregistry.h b/other-licenses/atk-1.0/atk/atkregistry.h
new file mode 100644
index 000000000..3ab0414ae
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkregistry.h
@@ -0,0 +1,69 @@
+/* ATK - Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_REGISTRY_H__
+#define __ATK_REGISTRY_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <glib-object.h>
+#include "atkobjectfactory.h"
+
+#define ATK_TYPE_REGISTRY                (atk_registry_get_type ())
+#define ATK_REGISTRY(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_REGISTRY, AtkRegistry))
+#define ATK_REGISTRY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_REGISTRY, AtkRegistryClass))
+#define ATK_IS_REGISTRY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_REGISTRY))
+#define ATK_IS_REGISTRY_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_REGISTRY))
+#define ATK_REGISTRY_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_REGISTRY, AtkRegistryClass))
+
+struct _AtkRegistry
+{
+  GObject    parent;
+  GHashTable *factory_type_registry;
+  GHashTable *factory_singleton_cache;
+};
+
+struct _AtkRegistryClass
+{
+  GObjectClass    parent_class;
+};
+
+typedef struct _AtkRegistry             AtkRegistry;
+typedef struct _AtkRegistryClass        AtkRegistryClass;
+
+
+GType             atk_registry_get_type         (void);
+void              atk_registry_set_factory_type (AtkRegistry *registry,
+                                                 GType type,
+                                                 GType factory_type);
+GType             atk_registry_get_factory_type (AtkRegistry *registry,
+						 GType type);
+AtkObjectFactory* atk_registry_get_factory      (AtkRegistry *registry,
+                                                 GType type);
+
+AtkRegistry*      atk_get_default_registry      (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __ATK_REGISTRY_H__ */
+
diff --git a/other-licenses/atk-1.0/atk/atkrelation.h b/other-licenses/atk-1.0/atk/atkrelation.h
new file mode 100644
index 000000000..08b0708f1
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkrelation.h
@@ -0,0 +1,88 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_RELATION_H__
+#define __ATK_RELATION_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <glib-object.h>
+#include <atk/atkrelationtype.h>
+
+/*
+ * An AtkRelation describes a relation between the object and one or more 
+ * other objects. The actual relations that an object has with other objects
+ * are defined as an AtkRelationSet, which is a set of AtkRelations. 
+ */
+
+#define ATK_TYPE_RELATION                         (atk_relation_get_type ())
+#define ATK_RELATION(obj)                         (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_RELATION, AtkRelation))
+#define ATK_RELATION_CLASS(klass)                 (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_RELATION, AtkRelationClass))
+#define ATK_IS_RELATION(obj)                      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_RELATION))
+#define ATK_IS_RELATION_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_RELATION))
+#define ATK_RELATION_GET_CLASS(obj)               (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_RELATION, AtkRelationClass))
+
+typedef struct _AtkRelation            AtkRelation;
+typedef struct _AtkRelationClass       AtkRelationClass;
+
+struct _AtkRelation
+{
+  GObject parent;
+
+  GPtrArray       *target;
+  AtkRelationType relationship;
+};
+
+struct _AtkRelationClass
+{
+  GObjectClass parent;
+};
+
+GType atk_relation_get_type (void);
+
+AtkRelationType       atk_relation_type_register      (const gchar     *name);
+G_CONST_RETURN gchar* atk_relation_type_get_name      (AtkRelationType type);
+AtkRelationType       atk_relation_type_for_name      (const gchar     *name);
+
+/*
+ * Create a new relation for the specified key and the specified list
+ * of targets.
+ */
+AtkRelation*          atk_relation_new                (AtkObject       **targets,
+                                                       gint            n_targets,
+                                                       AtkRelationType relationship);
+/*
+ * Returns the type of a relation.
+ */
+AtkRelationType       atk_relation_get_relation_type  (AtkRelation     *relation);
+/*
+ * Returns the target list of a relation.
+ */
+GPtrArray*            atk_relation_get_target         (AtkRelation     *relation);
+void                  atk_relation_add_target         (AtkRelation     *relation,
+                                                       AtkObject       *target);
+                
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __ATK_RELATION_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkrelationset.h b/other-licenses/atk-1.0/atk/atkrelationset.h
new file mode 100644
index 000000000..2225baf90
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkrelationset.h
@@ -0,0 +1,79 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_RELATION_SET_H__
+#define __ATK_RELATION_SET_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <glib-object.h>
+#include <atk/atkobject.h>
+#include <atk/atkrelation.h>
+
+#define ATK_TYPE_RELATION_SET                     (atk_relation_set_get_type ())
+#define ATK_RELATION_SET(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_RELATION_SET, AtkRelationSet))
+#define ATK_RELATION_SET_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_RELATION_SET, AtkRelationSetClass))
+#define ATK_IS_RELATION_SET(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_RELATION_SET))
+#define ATK_IS_RELATION_SET_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_RELATION_SET))
+#define ATK_RELATION_SET_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_RELATION_SET, AtkRelationSetClass))
+
+typedef struct _AtkRelationSetClass       AtkRelationSetClass;
+
+
+struct _AtkRelationSet
+{
+  GObject parent;
+
+  GPtrArray *relations;
+};
+
+struct _AtkRelationSetClass
+{
+  GObjectClass parent;
+
+  AtkFunction pad1;
+  AtkFunction pad2;
+};
+
+GType atk_relation_set_get_type (void);
+
+AtkRelationSet* atk_relation_set_new                  (void);
+gboolean        atk_relation_set_contains             (AtkRelationSet  *set,
+                                                       AtkRelationType relationship);
+void            atk_relation_set_remove               (AtkRelationSet  *set,
+                                                       AtkRelation     *relation);
+void            atk_relation_set_add                  (AtkRelationSet  *set,
+                                                       AtkRelation     *relation);
+gint            atk_relation_set_get_n_relations      (AtkRelationSet  *set);
+AtkRelation*    atk_relation_set_get_relation         (AtkRelationSet  *set,
+                                                       gint            i);
+AtkRelation*    atk_relation_set_get_relation_by_type (AtkRelationSet  *set,
+                                                       AtkRelationType relationship);
+void            atk_relation_set_add_relation_by_type (AtkRelationSet  *set,
+                                                       AtkRelationType relationship,
+                                                       AtkObject       *target);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_RELATION_SET_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkrelationtype.h b/other-licenses/atk-1.0/atk/atkrelationtype.h
new file mode 100755
index 000000000..c932e5641
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkrelationtype.h
@@ -0,0 +1,83 @@
+/* ATK -  Accessibility Toolkit
+ * Copyright 2002 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.
+ */
+
+#if defined(ATK_DISABLE_SINGLE_INCLUDES) && !defined (__ATK_H_INSIDE__) && !defined (ATK_COMPILATION)
+#error "Only <atk/atk.h> can be included directly."
+#endif
+
+#ifndef __ATK_RELATION_TYPE_H__
+#define __ATK_RELATION_TYPE_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/**
+ *AtkRelationType:
+ *@ATK_RELATION_NULL: Not used, represens "no relationship" or an error condition.
+ *@ATK_RELATION_CONTROLLED_BY: Indicates an object controlled by one or more target objects.
+ *@ATK_RELATION_CONTROLLER_FOR: Indicates an object is an controller for one or more target objects.
+ *@ATK_RELATION_LABEL_FOR: Indicates an object is a label for one or more target objects.
+ *@ATK_RELATION_LABELLED_BY: Indicates an object is labelled by one or more target objects.
+ *@ATK_RELATION_MEMBER_OF: Indicates an object is a member of a group of one or more target objects.
+ *@ATK_RELATION_NODE_CHILD_OF: Indicates an object is a cell in a treetable which is displayed because a cell in the same column is expanded and identifies that cell.
+ *@ATK_RELATION_FLOWS_TO: Indicates that the object has content that flows logically to another
+ *  AtkObject in a sequential way, (for instance text-flow).
+ *@ATK_RELATION_FLOWS_FROM: Indicates that the object has content that flows logically from
+ *  another AtkObject in a sequential way, (for instance text-flow).
+ *@ATK_RELATION_SUBWINDOW_OF: Indicates a subwindow attached to a component but otherwise has no connection in  the UI heirarchy to that component.
+ *@ATK_RELATION_EMBEDS: Indicates that the object visually embeds 
+ *  another object's content, i.e. this object's content flows around 
+ *  another's content.
+ *@ATK_RELATION_EMBEDDED_BY: Inverse of %ATK_RELATION_EMBEDS, indicates that
+ *  this object's content is visualy embedded in another object.
+ *@ATK_RELATION_POPUP_FOR: Indicates that an object is a popup for another object.
+ *@ATK_RELATION_PARENT_WINDOW_OF: Indicates that an object is a parent window of another object.
+ *@ATK_RELATION_DESCRIBED_BY: Indicates that another object provides descriptive information about this object; more verbose than ATK_RELATION_LABELLED_BY.
+ *@ATK_RELATION_DESCRIPTION_FOR: Indicates that an object provides descriptive information about another object; more verbose than ATK_RELATION_LABEL_FOR.
+ *@ATK_RELATION_NODE_PARENT_OF: Indicates an object is a cell in a treetable and is expanded to display other cells in the same column.
+ *@ATK_RELATION_LAST_DEFINED: Not used, this value indicates the end of the enumeration.
+ * 
+ *Describes the type of the relation
+ **/
+typedef enum
+{
+  ATK_RELATION_NULL = 0,
+  ATK_RELATION_CONTROLLED_BY,
+  ATK_RELATION_CONTROLLER_FOR,
+  ATK_RELATION_LABEL_FOR,
+  ATK_RELATION_LABELLED_BY,
+  ATK_RELATION_MEMBER_OF,
+  ATK_RELATION_NODE_CHILD_OF,
+  ATK_RELATION_FLOWS_TO,
+  ATK_RELATION_FLOWS_FROM,
+  ATK_RELATION_SUBWINDOW_OF, 
+  ATK_RELATION_EMBEDS, 
+  ATK_RELATION_EMBEDDED_BY, 
+  ATK_RELATION_POPUP_FOR, 
+  ATK_RELATION_PARENT_WINDOW_OF, 
+  ATK_RELATION_DESCRIBED_BY,
+  ATK_RELATION_DESCRIPTION_FOR,
+  ATK_RELATION_NODE_PARENT_OF,
+  ATK_RELATION_LAST_DEFINED
+} AtkRelationType;
+
+G_END_DECLS
+
+#endif /* __ATK_RELATION_TYPE_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkselection.h b/other-licenses/atk-1.0/atk/atkselection.h
new file mode 100644
index 000000000..7b16930c1
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkselection.h
@@ -0,0 +1,96 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_SELECTION_H__
+#define __ATK_SELECTION_H__
+
+#include <atk/atkobject.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * This AtkSelection interface provides the standard mechanism for an 
+ * assistive technology to determine what the current selected children are, 
+ * as well as modify the selection set. Any object that has children that 
+ * can be selected should support the AtkSelection interface.
+ */
+
+#define ATK_TYPE_SELECTION                        (atk_selection_get_type ())
+#define ATK_IS_SELECTION(obj)                     G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_SELECTION)
+#define ATK_SELECTION(obj)                        G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_SELECTION, AtkSelection)
+#define ATK_SELECTION_GET_IFACE(obj)              (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_SELECTION, AtkSelectionIface))
+
+#ifndef _TYPEDEF_ATK_SELECTION_
+#define _TYPEDEF_ATK_SELECTION_
+typedef struct _AtkSelection AtkSelection;
+#endif
+typedef struct _AtkSelectionIface AtkSelectionIface;
+
+struct _AtkSelectionIface
+{
+  GTypeInterface parent;
+
+  gboolean     (* add_selection)        (AtkSelection   *selection,
+                                         gint           i);
+  gboolean     (* clear_selection)      (AtkSelection   *selection);
+  AtkObject*   (* ref_selection)        (AtkSelection   *selection,
+                                         gint           i);
+  gint         (* get_selection_count)  (AtkSelection   *selection);
+  gboolean     (* is_child_selected)    (AtkSelection   *selection,
+                                         gint           i);
+  gboolean     (* remove_selection)     (AtkSelection   *selection,
+                                         gint           i);
+  gboolean     (* select_all_selection) (AtkSelection   *selection);
+
+  /* signal handlers */
+  
+  void         (*selection_changed)     (AtkSelection   *selection);
+
+  AtkFunction  pad1;
+  AtkFunction  pad2;
+};
+
+GType atk_selection_get_type (void);
+
+gboolean     atk_selection_add_selection        (AtkSelection   *selection,
+                                                 gint           i);
+
+gboolean     atk_selection_clear_selection      (AtkSelection   *selection);
+
+AtkObject*   atk_selection_ref_selection        (AtkSelection   *selection,
+                                                 gint           i);
+
+gint         atk_selection_get_selection_count  (AtkSelection   *selection);
+
+gboolean     atk_selection_is_child_selected    (AtkSelection   *selection,
+                                                 gint           i);
+
+gboolean     atk_selection_remove_selection     (AtkSelection   *selection,
+                                                 gint           i);
+
+gboolean     atk_selection_select_all_selection (AtkSelection   *selection);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_SELECTION_H__ */
diff --git a/other-licenses/atk-1.0/atk/atksocket.h b/other-licenses/atk-1.0/atk/atksocket.h
new file mode 100644
index 000000000..813d4f3c9
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atksocket.h
@@ -0,0 +1,65 @@
+/* ATK -  Accessibility Toolkit
+ * Copyright 2009 Novell, 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.
+ */
+
+#if defined(ATK_DISABLE_SINGLE_INCLUDES) && !defined (__ATK_H_INSIDE__) && !defined (ATK_COMPILATION)
+#error "Only <atk/atk.h> can be included directly."
+#endif
+
+#ifndef __ATK_SOCKET_H__
+#define __ATK_SOCKET_H__
+
+G_BEGIN_DECLS
+
+#define ATK_TYPE_SOCKET               (atk_socket_get_type ())
+#define ATK_SOCKET(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_SOCKET, AtkSocket))
+#define ATK_IS_SOCKET(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_SOCKET))
+#define ATK_SOCKET_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_SOCKET, AtkSocketClass))
+#define ATK_IS_SOCKET_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_SOCKET))
+#define ATK_SOCKET_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_SOCKET, AtkSocketClass))
+
+typedef struct _AtkSocket         AtkSocket;
+typedef struct _AtkSocketClass    AtkSocketClass;
+
+struct _AtkSocket
+{
+  AtkObject parent;
+
+  /*< private >*/
+  gchar* embedded_plug_id;
+};
+
+GType atk_socket_get_type (void);
+
+struct _AtkSocketClass
+{
+  AtkObjectClass parent_class;
+  
+  /* to be subscribed to by atk-bridge */
+
+  /*< protected >*/
+  void (* embed) (AtkSocket *obj, gchar* plug_id);
+};
+
+AtkObject*    atk_socket_new           (void);
+void          atk_socket_embed         (AtkSocket* obj, gchar* plug_id);
+gboolean      atk_socket_is_occupied   (AtkSocket* obj);
+
+G_END_DECLS
+
+#endif /* __ATK_SOCKET_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkstate.h b/other-licenses/atk-1.0/atk/atkstate.h
new file mode 100644
index 000000000..a3912e98d
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkstate.h
@@ -0,0 +1,198 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_STATE_H__
+#define __ATK_STATE_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/**
+ *AtkStateType:
+ *@ATK_STATE_INVALID: Indicates an invalid state - probably an error condition.
+ *@ATK_STATE_ACTIVE: Indicates a window is currently the active window, or an object is the active subelement within a container or table. ATK_STATE_ACTIVE should not be used for objects which have ATK_STATE_FOCUSABLE or ATK_STATE_SELECTABLE: Those objects should use ATK_STATE_FOCUSED and ATK_STATE_SELECTED respectively. ATK_STATE_ACTIVE is a means to indicate that an object which is not focusable and not selectable is the currently-active item within its parent container.
+ *@ATK_STATE_ARMED: Indicates that the object is 'armed', i.e. will be activated by if a pointer button-release event occurs within its bounds.  Buttons often enter this state when a pointer click occurs within their bounds, as a precursor to activation. ATK_STATE_ARMED has been deprecated since ATK-2.16 and should not be used in newly-written code.
+ *@ATK_STATE_BUSY:  Indicates the current object is busy, i.e. onscreen representation is in the process of changing, or the object is temporarily unavailable for interaction due to activity already in progress.  This state may be used by implementors of Document to indicate that content loading is underway.  It also may indicate other 'pending' conditions; clients may wish to interrogate this object when the ATK_STATE_BUSY flag is removed.
+ *@ATK_STATE_CHECKED: Indicates this object is currently checked, for instance a checkbox is 'non-empty'.
+ *@ATK_STATE_DEFUNCT: Indicates that this object no longer has a valid backing widget (for instance, if its peer object has been destroyed)
+ *@ATK_STATE_EDITABLE: Indicates that this object can contain text, and that the
+ * user can change the textual contents of this object by editing those contents
+ * directly. For an object which is expected to be editable due to its type, but
+ * which cannot be edited due to the application or platform preventing the user
+ * from doing so, that object's #AtkStateSet should lack ATK_STATE_EDITABLE and
+ * should contain ATK_STATE_READ_ONLY.
+ *@ATK_STATE_ENABLED:   Indicates that this object is enabled, i.e. that it currently reflects some application state. Objects that are "greyed out" may lack this state, and may lack the STATE_SENSITIVE if direct user interaction cannot cause them to acquire STATE_ENABLED. See also: ATK_STATE_SENSITIVE
+ *@ATK_STATE_EXPANDABLE: Indicates this object allows progressive disclosure of its children
+ *@ATK_STATE_EXPANDED: Indicates this object its expanded - see ATK_STATE_EXPANDABLE above
+ *@ATK_STATE_FOCUSABLE: Indicates this object can accept keyboard focus, which means all events resulting from typing on the keyboard will normally be passed to it when it has focus
+ *@ATK_STATE_FOCUSED: Indicates this object currently has the keyboard focus
+ *@ATK_STATE_HORIZONTAL: Indicates the orientation of this object is horizontal; used, for instance, by objects of ATK_ROLE_SCROLL_BAR.  For objects where vertical/horizontal orientation is especially meaningful.
+ *@ATK_STATE_ICONIFIED: Indicates this object is minimized and is represented only by an icon
+ *@ATK_STATE_MODAL: Indicates something must be done with this object before the user can interact with an object in a different window
+ *@ATK_STATE_MULTI_LINE: Indicates this (text) object can contain multiple lines of text
+ *@ATK_STATE_MULTISELECTABLE: Indicates this object allows more than one of its children to be selected at the same time, or in the case of text objects, that the object supports non-contiguous text selections.
+ *@ATK_STATE_OPAQUE: Indicates this object paints every pixel within its rectangular region.
+ *@ATK_STATE_PRESSED: Indicates this object is currently pressed.
+ *@ATK_STATE_RESIZABLE: Indicates the size of this object is not fixed
+ *@ATK_STATE_SELECTABLE: Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that can be selected
+ *@ATK_STATE_SELECTED: Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that has been selected
+ *@ATK_STATE_SENSITIVE: Indicates this object is sensitive, e.g. to user interaction. 
+ * STATE_SENSITIVE usually accompanies STATE_ENABLED for user-actionable controls,
+ * but may be found in the absence of STATE_ENABLED if the current visible state of the 
+ * control is "disconnected" from the application state.  In such cases, direct user interaction
+ * can often result in the object gaining STATE_SENSITIVE, for instance if a user makes 
+ * an explicit selection using an object whose current state is ambiguous or undefined.
+ * @see STATE_ENABLED, STATE_INDETERMINATE.
+ *@ATK_STATE_SHOWING: Indicates this object, the object's parent, the object's parent's parent, and so on, 
+ * are all 'shown' to the end-user, i.e. subject to "exposure" if blocking or obscuring objects do not interpose
+ * between this object and the top of the window stack.
+ *@ATK_STATE_SINGLE_LINE: Indicates this (text) object can contain only a single line of text
+ *@ATK_STATE_STALE: Indicates that the information returned for this object may no longer be
+ * synchronized with the application state.  This is implied if the object has STATE_TRANSIENT,
+ * and can also occur towards the end of the object peer's lifecycle. It can also be used to indicate that 
+ * the index associated with this object has changed since the user accessed the object (in lieu of
+ * "index-in-parent-changed" events).
+ *@ATK_STATE_TRANSIENT: Indicates this object is transient, i.e. a snapshot which may not emit events when its
+ * state changes.  Data from objects with ATK_STATE_TRANSIENT should not be cached, since there may be no
+ * notification given when the cached data becomes obsolete.
+ *@ATK_STATE_VERTICAL: Indicates the orientation of this object is vertical
+ *@ATK_STATE_VISIBLE: Indicates this object is visible, e.g. has been explicitly marked for exposure to the user.
+ * @note: STATE_VISIBLE is no guarantee that the object is actually unobscured on the screen, only
+ * that it is 'potentially' visible, barring obstruction, being scrolled or clipped out of the 
+ * field of view, or having an ancestor container that has not yet made visible.
+ * A widget is potentially onscreen if it has both STATE_VISIBLE and STATE_SHOWING.
+ * The absence of STATE_VISIBLE and STATE_SHOWING is semantically equivalent to saying 
+ * that an object is 'hidden'.  See also STATE_TRUNCATED, which applies if a VISIBLE and SHOWING object
+ * lies within a viewport which means that its contents are clipped, e.g. a truncated spreadsheet cell or
+ * an image within a scrolling viewport.  Mostly useful for screen-review and magnification algorithms.
+ *@ATK_STATE_MANAGES_DESCENDANTS: Indicates that "active-descendant-changed" event
+ * is sent when children become 'active' (i.e. are selected or navigated to onscreen).
+ * Used to prevent need to enumerate all children in very large containers, like tables.
+ * The presence of STATE_MANAGES_DESCENDANTS is an indication to the client.
+ * that the children should not, and need not, be enumerated by the client.
+ * Objects implementing this state are expected to provide relevant state
+ * notifications to listening clients, for instance notifications of visibility
+ * changes and activation of their contained child objects, without the client 
+ * having previously requested references to those children.
+ *@ATK_STATE_INDETERMINATE: Indicates that the value, or some other quantifiable
+ * property, of this AtkObject cannot be fully determined. In the case of a large
+ * data set in which the total number of items in that set is unknown (e.g. 1 of
+ * 999+), implementors should expose the currently-known set size (999) along
+ * with this state. In the case of a check box, this state should be used to
+ * indicate that the check box is a tri-state check box which is currently
+ * neither checked nor unchecked.
+ *@ATK_STATE_TRUNCATED: Indicates that an object is truncated, e.g. a text value in a speradsheet cell.
+ *@ATK_STATE_REQUIRED: Indicates that explicit user interaction with an object is required by the user interface, e.g. a required field in a "web-form" interface.
+ *@ATK_STATE_INVALID_ENTRY: Indicates that the object has encountered an error condition due to failure of input validation. For instance, a form control may acquire this state in response to invalid or malformed user input.
+ *@ATK_STATE_SUPPORTS_AUTOCOMPLETION:  Indicates that the object in question implements some form of ¨typeahead¨ or 
+ * pre-selection behavior whereby entering the first character of one or more sub-elements
+ * causes those elements to scroll into view or become selected.  Subsequent character input
+ * may narrow the selection further as long as one or more sub-elements match the string.
+ * This state is normally only useful and encountered on objects that implement Selection.
+ * In some cases the typeahead behavior may result in full or partial ¨completion¨ of 
+ * the data in the input field, in which case these input events may trigger text-changed
+ * events from the AtkText interface.  This state supplants @ATK_ROLE_AUTOCOMPLETE.
+ *@ATK_STATE_SELECTABLE_TEXT:Indicates that the object in question supports text selection. It should only be exposed on objects which implement the Text interface, in order to distinguish this state from @ATK_STATE_SELECTABLE, which infers that the object in question is a selectable child of an object which implements Selection. While similar, text selection and subelement selection are distinct operations.
+ *@ATK_STATE_DEFAULT: Indicates that the object is the "default" active component, i.e. the object which is activated by an end-user press of the "Enter" or "Return" key.  Typically a "close" or "submit" button.
+ *@ATK_STATE_ANIMATED: Indicates that the object changes its appearance dynamically as an inherent part of its presentation.  This state may come and go if an object is only temporarily animated on the way to a 'final' onscreen presentation.
+ * @note some applications, notably content viewers, may not be able to detect
+ * all kinds of animated content.  Therefore the absence of this state should not
+ * be taken as definitive evidence that the object's visual representation is
+ * static; this state is advisory.
+ *@ATK_STATE_VISITED: Indicates that the object (typically a hyperlink) has already been 'activated', and/or its backing data has already been downloaded, rendered, or otherwise "visited".
+ *@ATK_STATE_CHECKABLE: Indicates this object has the potential to be
+ *  checked, such as a checkbox or toggle-able table cell. @Since:
+ *  ATK-2.12
+ *@ATK_STATE_HAS_POPUP: Indicates that the object has a popup context
+ * menu or sub-level menu which may or may not be showing. This means
+ * that activation renders conditional content.  Note that ordinary
+ * tooltips are not considered popups in this context. @Since: ATK-2.12
+ *@ATK_STATE_HAS_TOOLTIP: Indicates this object has a tooltip. @Since: ATK-2.16
+ *@ATK_STATE_READ_ONLY: Indicates that a widget which is ENABLED and SENSITIVE
+ * has a value which can be read, but not modified, by the user. Note that this
+ * state should only be applied to widget types whose value is normally directly
+ * user modifiable, such as check boxes, radio buttons, spin buttons, text input
+ * fields, and combo boxes, as a means to convey that the expected interaction
+ * with that widget is not possible. When the expected interaction with a
+ * widget does not include modification by the user, as is the case with
+ * labels and containers, ATK_STATE_READ_ONLY should not be applied. See also
+ * ATK_STATE_EDITABLE. @Since: ATK-2-16
+ *@ATK_STATE_LAST_DEFINED: Not a valid state, used for finding end of enumeration
+ *
+ *The possible types of states of an object
+ **/
+typedef enum
+{
+  ATK_STATE_INVALID,
+  ATK_STATE_ACTIVE,
+  ATK_STATE_ARMED,
+  ATK_STATE_BUSY,
+  ATK_STATE_CHECKED,
+  ATK_STATE_DEFUNCT,
+  ATK_STATE_EDITABLE,
+  ATK_STATE_ENABLED,
+  ATK_STATE_EXPANDABLE,
+  ATK_STATE_EXPANDED,
+  ATK_STATE_FOCUSABLE,
+  ATK_STATE_FOCUSED,
+  ATK_STATE_HORIZONTAL,
+  ATK_STATE_ICONIFIED,
+  ATK_STATE_MODAL,
+  ATK_STATE_MULTI_LINE,
+  ATK_STATE_MULTISELECTABLE,
+  ATK_STATE_OPAQUE,
+  ATK_STATE_PRESSED,
+  ATK_STATE_RESIZABLE,
+  ATK_STATE_SELECTABLE,
+  ATK_STATE_SELECTED,
+  ATK_STATE_SENSITIVE,
+  ATK_STATE_SHOWING,
+  ATK_STATE_SINGLE_LINE,
+  ATK_STATE_STALE,
+  ATK_STATE_TRANSIENT,
+  ATK_STATE_VERTICAL,
+  ATK_STATE_VISIBLE,
+  ATK_STATE_MANAGES_DESCENDANTS,
+  ATK_STATE_INDETERMINATE,
+  ATK_STATE_TRUNCATED,
+  ATK_STATE_REQUIRED,
+  ATK_STATE_INVALID_ENTRY,
+  ATK_STATE_SUPPORTS_AUTOCOMPLETION,
+  ATK_STATE_SELECTABLE_TEXT,
+  ATK_STATE_DEFAULT,
+  ATK_STATE_ANIMATED,
+  ATK_STATE_VISITED,
+  ATK_STATE_CHECKABLE,
+  ATK_STATE_HAS_POPUP,
+  ATK_STATE_HAS_TOOLTIP,
+  ATK_STATE_READ_ONLY,
+  ATK_STATE_LAST_DEFINED
+} AtkStateType;
+
+typedef guint64      AtkState;
+
+AtkStateType atk_state_type_register            (const gchar *name);
+
+const gchar*          atk_state_type_get_name   (AtkStateType type);
+AtkStateType          atk_state_type_for_name   (const gchar  *name);
+
+G_END_DECLS
+
+#endif /* __ATK_STATE_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkstateset.h b/other-licenses/atk-1.0/atk/atkstateset.h
new file mode 100644
index 000000000..43c3ea3d1
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkstateset.h
@@ -0,0 +1,81 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_STATE_SET_H__
+#define __ATK_STATE_SET_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <glib-object.h>
+#include <atk/atkobject.h>
+#include <atk/atkstate.h>
+
+#define ATK_TYPE_STATE_SET                        (atk_state_set_get_type ())
+#define ATK_STATE_SET(obj)                        (G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_STATE_SET, AtkStateSet))
+#define ATK_STATE_SET_CLASS(klass)                (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_STATE_SET, AtkStateSetClass))
+#define ATK_IS_STATE_SET(obj)                     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_STATE_SET))
+#define ATK_IS_STATE_SET_CLASS(klass)             (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_STATE_SET))
+#define ATK_STATE_SET_GET_CLASS(obj)              (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_STATE_SET, AtkStateSetClass))
+
+typedef struct _AtkStateSetClass       AtkStateSetClass;
+
+
+struct _AtkStateSet
+{
+  GObject parent;
+
+};
+
+struct _AtkStateSetClass
+{
+  GObjectClass parent;
+};
+
+GType atk_state_set_get_type (void);
+
+AtkStateSet*    atk_state_set_new               (void);
+gboolean        atk_state_set_is_empty          (AtkStateSet  *set);
+gboolean        atk_state_set_add_state         (AtkStateSet  *set,
+                                                 AtkStateType type);
+void            atk_state_set_add_states        (AtkStateSet  *set,
+                                                 AtkStateType *types,
+                                                 gint         n_types);
+void            atk_state_set_clear_states      (AtkStateSet  *set);
+gboolean        atk_state_set_contains_state    (AtkStateSet  *set,
+                                                 AtkStateType type);
+gboolean        atk_state_set_contains_states   (AtkStateSet  *set,
+                                                 AtkStateType *types,
+                                                 gint         n_types);
+gboolean        atk_state_set_remove_state      (AtkStateSet  *set,
+                                                 AtkStateType type);
+AtkStateSet*    atk_state_set_and_sets          (AtkStateSet  *set,
+                                                 AtkStateSet  *compare_set);
+AtkStateSet*    atk_state_set_or_sets           (AtkStateSet  *set,
+                                                 AtkStateSet  *compare_set);
+AtkStateSet*    atk_state_set_xor_sets          (AtkStateSet  *set,
+                                                 AtkStateSet  *compare_set);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_STATE_SET_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkstreamablecontent.h b/other-licenses/atk-1.0/atk/atkstreamablecontent.h
new file mode 100644
index 000000000..abdbfa959
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkstreamablecontent.h
@@ -0,0 +1,107 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_STREAMABLE_CONTENT_H__
+#define __ATK_STREAMABLE_CONTENT_H__
+
+#include <atk/atkobject.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define ATK_TYPE_STREAMABLE_CONTENT           (atk_streamable_content_get_type ())
+#define ATK_IS_STREAMABLE_CONTENT(obj)        G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_STREAMABLE_CONTENT)
+#define ATK_STREAMABLE_CONTENT(obj)           G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_STREAMABLE_CONTENT, AtkStreamableContent)
+#define ATK_STREAMABLE_CONTENT_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_STREAMABLE_CONTENT, AtkStreamableContentIface))
+
+#ifndef _TYPEDEF_ATK_STREAMABLE_CONTENT
+#define _TYPEDEF_ATK_STREAMABLE_CONTENT
+typedef struct _AtkStreamableContent AtkStreamableContent;
+#endif
+typedef struct _AtkStreamableContentIface AtkStreamableContentIface;
+
+struct _AtkStreamableContentIface
+{
+  GTypeInterface parent;
+
+  /*
+   * Get the number of mime types supported by this object
+   */
+  gint                      (* get_n_mime_types)  (AtkStreamableContent     *streamable);
+  /*
+   * Gets the specified mime type supported by this object.
+   * The mime types are 0-based so the first mime type is 
+   * at index 0, the second at index 1 and so on.  The mime-type
+   * 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 G_CONST_RETURN could be removed
+   * and the caller would be responsible for calling g_free() on the
+   * returned value.
+   */
+  G_CONST_RETURN gchar*     (* get_mime_type)     (AtkStreamableContent     *streamable,
+                                                   gint                     i);
+  /*
+   * One possible implementation for this method is that it constructs the
+   * content appropriate for the mime type and then creates a temporary
+   * file containing the content, opens the file and then calls
+   * g_io_channel_unix_new_fd().
+   */
+  GIOChannel*               (* get_stream)        (AtkStreamableContent     *streamable,
+                                                   const gchar              *mime_type);
+
+/*
+ * Returns a string representing a URI in IETF standard format
+ * (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
+ * may be streamed in the specified mime-type.
+ * If mime_type is NULL, the URI for the default (and possibly only) mime-type is
+ * returned.
+ *
+ * returns NULL if the mime-type is not supported, or if no URI can be 
+ * 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.
+ */
+    G_CONST_RETURN  gchar*  (* get_uri)           (AtkStreamableContent     *streamable,
+                                                   const gchar              *mime_type);
+
+
+  AtkFunction               pad1;
+  AtkFunction               pad2;
+  AtkFunction               pad3;
+};
+GType                  atk_streamable_content_get_type (void);
+
+gint                   atk_streamable_content_get_n_mime_types (AtkStreamableContent     *streamable);
+                                                       
+G_CONST_RETURN gchar*  atk_streamable_content_get_mime_type    (AtkStreamableContent     *streamable,
+                                                                gint                     i);
+GIOChannel*             atk_streamable_content_get_stream       (AtkStreamableContent     *streamable,
+                                                                 const gchar              *mime_type);
+
+gchar*                  atk_streamable_content_get_uri          (AtkStreamableContent     *streamable,
+                                                                 const gchar              *mime_type);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_STREAMABLE_CONTENT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atktable.h b/other-licenses/atk-1.0/atk/atktable.h
new file mode 100644
index 000000000..790fbb448
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atktable.h
@@ -0,0 +1,218 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_TABLE_H__
+#define __ATK_TABLE_H__
+
+#include <atk/atkobject.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * AtkTable describes a user-interface component that presents data in
+ * two-dimensional table format.
+ */
+
+
+#define ATK_TYPE_TABLE                    (atk_table_get_type ())
+#define ATK_IS_TABLE(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TABLE)
+#define ATK_TABLE(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TABLE, AtkTable)
+#define ATK_TABLE_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TABLE, AtkTableIface))
+
+#ifndef _TYPEDEF_ATK_TABLE_
+#define _TYPEDEF_ATK_TABLE_
+typedef struct _AtkTable AtkTable;
+#endif
+typedef struct _AtkTableIface AtkTableIface;
+
+struct _AtkTableIface
+{
+  GTypeInterface parent;
+
+  AtkObject*        (* ref_at)                   (AtkTable      *table,
+                                                  gint          row,
+                                                  gint          column);
+  gint              (* get_index_at)             (AtkTable      *table,
+                                                  gint          row,
+                                                  gint          column);
+  gint              (* get_column_at_index)      (AtkTable      *table,
+                                                  gint          index_);
+  gint              (* get_row_at_index)         (AtkTable      *table,
+                                                  gint          index_);
+  gint              (* get_n_columns)           (AtkTable      *table);
+  gint              (* get_n_rows)               (AtkTable      *table);
+  gint              (* get_column_extent_at)     (AtkTable      *table,
+                                                  gint          row,
+                                                  gint          column);
+  gint              (* get_row_extent_at)        (AtkTable      *table,
+                                                  gint          row,
+                                                  gint          column);
+  AtkObject*
+                    (* get_caption)              (AtkTable      *table);
+  G_CONST_RETURN gchar*
+                    (* get_column_description)   (AtkTable      *table,
+                                                  gint          column);
+  AtkObject*        (* get_column_header)        (AtkTable      *table,
+						  gint		column);
+  G_CONST_RETURN gchar*
+                    (* get_row_description)      (AtkTable      *table,
+                                                  gint          row);
+  AtkObject*        (* get_row_header)           (AtkTable      *table,
+						  gint		row);
+  AtkObject*        (* get_summary)              (AtkTable      *table);
+  void              (* set_caption)              (AtkTable      *table,
+                                                  AtkObject     *caption);
+  void              (* set_column_description)   (AtkTable      *table,
+                                                  gint          column,
+                                                  const gchar   *description);
+  void              (* set_column_header)        (AtkTable      *table,
+                                                  gint          column,
+                                                  AtkObject     *header);
+  void              (* set_row_description)      (AtkTable      *table,
+                                                  gint          row,
+                                                  const gchar   *description);
+  void              (* set_row_header)           (AtkTable      *table,
+                                                  gint          row,
+                                                  AtkObject     *header);
+  void              (* set_summary)              (AtkTable      *table,
+                                                  AtkObject     *accessible);
+  gint              (* get_selected_columns)     (AtkTable      *table,
+                                                  gint          **selected);
+  gint              (* get_selected_rows)        (AtkTable      *table,
+                                                  gint          **selected);
+  gboolean          (* is_column_selected)       (AtkTable      *table,
+                                                  gint          column);
+  gboolean          (* is_row_selected)          (AtkTable      *table,
+                                                  gint          row);
+  gboolean          (* is_selected)              (AtkTable      *table,
+                                                  gint          row,
+                                                  gint          column);
+  gboolean          (* add_row_selection)        (AtkTable      *table,
+                                                  gint          row);
+  gboolean          (* remove_row_selection)     (AtkTable      *table,
+                                                  gint          row);
+  gboolean          (* add_column_selection)     (AtkTable      *table,
+                                                  gint          column);
+  gboolean          (* remove_column_selection)  (AtkTable      *table,
+                                                  gint          column);
+
+  /*
+   * signal handlers
+   */
+  void              (* row_inserted)             (AtkTable      *table,
+                                                  gint          row,
+                                                  gint          num_inserted);
+  void              (* column_inserted)          (AtkTable      *table,
+                                                  gint          column,
+                                                  gint          num_inserted);
+  void              (* row_deleted)              (AtkTable      *table,
+                                                  gint          row,
+                                                  gint          num_deleted);
+  void              (* column_deleted)           (AtkTable      *table,
+                                                  gint          column,
+                                                  gint          num_deleted);
+  void              (* row_reordered)            (AtkTable      *table);
+  void              (* column_reordered)         (AtkTable      *table);
+  void              (* model_changed)            (AtkTable      *table);
+
+  AtkFunction       pad1;
+  AtkFunction       pad2;
+  AtkFunction       pad3;
+  AtkFunction       pad4;
+};
+
+GType atk_table_get_type (void);
+
+AtkObject*        atk_table_ref_at               (AtkTable         *table,
+                                                  gint             row,
+                                                  gint             column);
+gint              atk_table_get_index_at         (AtkTable         *table,
+                                                  gint             row,
+                                                  gint             column);
+gint              atk_table_get_column_at_index  (AtkTable         *table,
+                                                  gint             index_);
+gint              atk_table_get_row_at_index     (AtkTable         *table,
+                                                  gint             index_);
+gint              atk_table_get_n_columns        (AtkTable         *table);
+gint              atk_table_get_n_rows           (AtkTable         *table);
+gint              atk_table_get_column_extent_at (AtkTable         *table,
+                                                  gint             row,
+                                                  gint             column);
+gint              atk_table_get_row_extent_at    (AtkTable         *table,
+                                                  gint             row,
+                                                  gint             column);
+AtkObject*
+                  atk_table_get_caption          (AtkTable         *table);
+G_CONST_RETURN gchar*
+                  atk_table_get_column_description (AtkTable         *table,
+                                                  gint             column);
+AtkObject*        atk_table_get_column_header    (AtkTable         *table,
+						  gint		   column);
+G_CONST_RETURN gchar*
+                  atk_table_get_row_description  (AtkTable         *table,
+                                                  gint             row);
+AtkObject*        atk_table_get_row_header       (AtkTable         *table,
+						  gint		   row);
+AtkObject*        atk_table_get_summary          (AtkTable         *table);
+void              atk_table_set_caption          (AtkTable         *table,
+                                                  AtkObject        *caption);
+void              atk_table_set_column_description 
+                                                 (AtkTable         *table,
+                                                  gint             column,
+                                                  const gchar      *description);
+void              atk_table_set_column_header    (AtkTable         *table,
+                                                  gint             column,
+                                                  AtkObject        *header);
+void              atk_table_set_row_description  (AtkTable         *table,
+                                                  gint             row,
+                                                  const gchar      *description);
+void              atk_table_set_row_header       (AtkTable         *table,
+                                                  gint             row,
+                                                  AtkObject        *header);
+void              atk_table_set_summary          (AtkTable         *table,
+                                                  AtkObject        *accessible);
+gint              atk_table_get_selected_columns (AtkTable         *table,
+                                                  gint             **selected);
+gint              atk_table_get_selected_rows    (AtkTable         *table,
+                                                  gint             **selected);
+gboolean          atk_table_is_column_selected   (AtkTable         *table,
+                                                  gint             column);
+gboolean          atk_table_is_row_selected      (AtkTable         *table,
+                                                  gint             row);
+gboolean          atk_table_is_selected          (AtkTable         *table,
+                                                  gint             row,
+                                                  gint             column);
+gboolean          atk_table_add_row_selection    (AtkTable         *table,
+                                                  gint             row);
+gboolean          atk_table_remove_row_selection (AtkTable         *table,
+                                                  gint             row);
+gboolean          atk_table_add_column_selection (AtkTable         *table,
+                                                  gint             column);
+gboolean          atk_table_remove_column_selection  
+                                                 (AtkTable         *table,
+                                                  gint             column);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_TABLE_H__ */
diff --git a/other-licenses/atk-1.0/atk/atktablecell.h b/other-licenses/atk-1.0/atk/atktablecell.h
new file mode 100644
index 000000000..0e70d69ca
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atktablecell.h
@@ -0,0 +1,104 @@
+/* ATK -  Accessibility Toolkit
+ * Copyright 2014 SUSE LLC.
+ *
+ * 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.
+ */
+
+#if defined(ATK_DISABLE_SINGLE_INCLUDES) && !defined (__ATK_H_INSIDE__) && !defined (ATK_COMPILATION)
+#error "Only <atk/atk.h> can be included directly."
+#endif
+
+#ifndef __ATK_TABLE_CELL_H__
+#define __ATK_TABLE_CELL_H__
+
+#include <atk/atkobject.h>
+
+G_BEGIN_DECLS
+
+#define ATK_TYPE_TABLE_CELL                    (atk_table_cell_get_type ())
+#define ATK_IS_TABLE_CELL(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TABLE_CELL)
+#define ATK_TABLE_CELL(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TABLE_CELL, AtkTableCell)
+#define ATK_TABLE_CELL_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TABLE_CELL, AtkTableCellIface))
+
+#ifndef _TYPEDEF_ATK_TABLE_CELL_
+#define _TYPEDEF_ATK_TABLE_CELL_
+typedef struct _AtkTableCell AtkTableCell;
+#endif
+typedef struct _AtkTableCellIface AtkTableCellIface;
+
+/**
+ * AtkTableCellIface:
+ * @get_column_span: virtual function that returns the number of
+ * columns occupied by this cell accessible. @Since: 2.12
+ * @get_column_header_cells: virtual function that returns the column
+ * headers as an array of cell accessibles. @Since: 2.12
+ * @get_position: virtual function that retrieves the tabular position
+ * of this cell. @Since: 2.12
+ * @get_row_span: virtual function that returns the number of rows
+ * occupied by this cell. @Since: 2.12
+ * @get_row_header_cells: virtual function that returns the row
+ * headers as an array of cell accessibles. @Since: 2.12
+ * @get_row_column_span: virtual function that get the row an column
+ * indexes and span of this cell. @Since: 2.12
+ * @get_table: virtual function that returns a reference to the
+ * accessible of the containing table. @Since: 2.12
+ */
+struct _AtkTableCellIface
+{
+  GTypeInterface parent;
+
+  gint          (*get_column_span)         (AtkTableCell *cell);
+  GPtrArray *   (*get_column_header_cells) (AtkTableCell *cell);
+  gboolean      (*get_position)            (AtkTableCell *cell,
+                                            gint         *row,
+                                            gint         *column);
+  gint          (*get_row_span)            (AtkTableCell *cell);
+  GPtrArray *   (*get_row_header_cells)    (AtkTableCell *cell);
+  gboolean      (*get_row_column_span)     (AtkTableCell *cell,
+                                            gint         *row,
+                                            gint         *column,
+                                            gint         *row_span,
+                                            gint         *column_span);
+  AtkObject *   (*get_table)               (AtkTableCell *cell);
+};
+
+ATK_AVAILABLE_IN_2_12
+GType atk_table_cell_get_type (void);
+
+ATK_AVAILABLE_IN_2_12
+gint        atk_table_cell_get_column_span         (AtkTableCell *cell);
+ATK_AVAILABLE_IN_2_12
+GPtrArray * atk_table_cell_get_column_header_cells (AtkTableCell *cell);
+ATK_AVAILABLE_IN_2_12
+gboolean    atk_table_cell_get_position            (AtkTableCell *cell,
+                                                    gint         *row,
+                                                    gint         *column);
+ATK_AVAILABLE_IN_2_12
+gint        atk_table_cell_get_row_span            (AtkTableCell *cell);
+ATK_AVAILABLE_IN_2_12
+GPtrArray * atk_table_cell_get_row_header_cells    (AtkTableCell *cell);
+ATK_AVAILABLE_IN_2_12
+gboolean    atk_table_cell_get_row_column_span     (AtkTableCell *cell,
+                                                    gint         *row,
+                                                    gint         *column,
+                                                    gint         *row_span,
+                                                    gint         *column_span);
+ATK_AVAILABLE_IN_2_12
+AtkObject * atk_table_cell_get_table               (AtkTableCell *cell);
+
+G_END_DECLS
+
+#endif /* __ATK_TABLE_CELL_H__ */
diff --git a/other-licenses/atk-1.0/atk/atktext.h b/other-licenses/atk-1.0/atk/atktext.h
new file mode 100644
index 000000000..191e231fb
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atktext.h
@@ -0,0 +1,367 @@
+/* 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.
+ */
+
+
+#ifndef __ATK_TEXT_H__
+#define __ATK_TEXT_H__
+
+#include <glib-object.h>
+#include <atk/atkobject.h>
+#include <atk/atkutil.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ *AtkTextAttribute
+ *@ATK_TEXT_ATTR_INVALID: Invalid attribute
+ *@ATK_TEXT_ATTR_LEFT_MARGIN: The pixel width of the left margin
+ *@ATK_TEXT_ATTR_RIGHT_MARGIN: The pixel width of the right margin
+ *@ATK_TEXT_ATTR_INDENT: The number of pixels that the text is indented
+ *@ATK_TEXT_ATTR_INVISIBLE: Either "true" or "false" indicating whether text is visible or not
+ *@ATK_TEXT_ATTR_EDITABLE: Either "true" or "false" indicating whether text is editable or not
+ *@ATK_TEXT_ATTR_PIXELS_ABOVE_LINES: Pixels of blank space to leave above each newline-terminated line. 
+ *@ATK_TEXT_ATTR_PIXELS_BELOW_LINES: Pixels of blank space to leave below each newline-terminated line.
+ *@ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP: Pixels of blank space to leave between wrapped lines inside the same newline-terminated line (paragraph).
+ *@ATK_TEXT_ATTR_BG_FULL_HEIGHT: "true" or "false" whether to make the background color for each character the height of the highest font used on the current line, or the height of the font used for the current character.
+ *@ATK_TEXT_ATTR_RISE: Number of pixels that the characters are risen above the baseline
+ *@ATK_TEXT_ATTR_UNDERLINE: "none", "single", "double" or "low"
+ *@ATK_TEXT_ATTR_STRIKETHROUGH: "true" or "false" whether the text is strikethrough 
+ *@ATK_TEXT_ATTR_SIZE: The size of the characters. 
+ *@ATK_TEXT_ATTR_SCALE: The scale of the characters. The value is a string representation of a double 
+ *@ATK_TEXT_ATTR_WEIGHT: The weight of the characters.
+ *@ATK_TEXT_ATTR_LANGUAGE: The language used
+ *@ATK_TEXT_ATTR_FAMILY_NAME: The font family name
+ *@ATK_TEXT_ATTR_BG_COLOR: The background color. The value is an RGB value of the format "%u,%u,%u"
+ *@ATK_TEXT_ATTR_FG_COLOR:The foreground color. The value is an RGB value of the format "%u,%u,%u"
+ *@ATK_TEXT_ATTR_BG_STIPPLE: "true" if a #GdkBitmap is set for stippling the background color.
+ *@ATK_TEXT_ATTR_FG_STIPPLE: "true" if a #GdkBitmap is set for stippling the foreground color.
+ *@ATK_TEXT_ATTR_WRAP_MODE: The wrap mode of the text, if any. Values are "none", "char" or "word" 
+ *@ATK_TEXT_ATTR_DIRECTION: The direction of the text, if set. Values are "none", "ltr" or "rtl" 
+ *@ATK_TEXT_ATTR_JUSTIFICATION: The justification of the text, if set. Values are "left", "right", "center" or "fill" 
+ *@ATK_TEXT_ATTR_STRETCH: The stretch of the text, if set. Values are "ultra_condensed", "extra_condensed", "condensed", "semi_condensed", "normal", "semi_expanded", "expanded", "extra_expanded" or "ultra_expanded"
+ *@ATK_TEXT_ATTR_VARIANT: The capitalization variant of the text, if set. Values are "normal" or "small_caps"
+ *@ATK_TEXT_ATTR_STYLE: The slant style of the text, if set. Values are "normal", "oblique" or "italic"
+ *@ATK_TEXT_ATTR_LAST_DEFINED: not a valid text attribute, used for finding end of enumeration
+ *
+ * Describes the text attributes supported
+ **/
+typedef enum
+{
+  ATK_TEXT_ATTR_INVALID = 0,
+  ATK_TEXT_ATTR_LEFT_MARGIN,
+  ATK_TEXT_ATTR_RIGHT_MARGIN,
+  ATK_TEXT_ATTR_INDENT,
+  ATK_TEXT_ATTR_INVISIBLE,
+  ATK_TEXT_ATTR_EDITABLE,
+  ATK_TEXT_ATTR_PIXELS_ABOVE_LINES,
+  ATK_TEXT_ATTR_PIXELS_BELOW_LINES,
+  ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP,
+  ATK_TEXT_ATTR_BG_FULL_HEIGHT,
+  ATK_TEXT_ATTR_RISE,
+  ATK_TEXT_ATTR_UNDERLINE,
+  ATK_TEXT_ATTR_STRIKETHROUGH,
+  ATK_TEXT_ATTR_SIZE,
+  ATK_TEXT_ATTR_SCALE,
+  ATK_TEXT_ATTR_WEIGHT,
+  ATK_TEXT_ATTR_LANGUAGE,
+  ATK_TEXT_ATTR_FAMILY_NAME,
+  ATK_TEXT_ATTR_BG_COLOR,
+  ATK_TEXT_ATTR_FG_COLOR,
+  ATK_TEXT_ATTR_BG_STIPPLE,
+  ATK_TEXT_ATTR_FG_STIPPLE,
+  ATK_TEXT_ATTR_WRAP_MODE,
+  ATK_TEXT_ATTR_DIRECTION,
+  ATK_TEXT_ATTR_JUSTIFICATION,
+  ATK_TEXT_ATTR_STRETCH,
+  ATK_TEXT_ATTR_VARIANT,
+  ATK_TEXT_ATTR_STYLE,
+  ATK_TEXT_ATTR_LAST_DEFINED
+} AtkTextAttribute;
+
+AtkTextAttribute         atk_text_attribute_register   (const gchar *name);
+
+
+#define ATK_TYPE_TEXT                    (atk_text_get_type ())
+#define ATK_IS_TEXT(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_TEXT)
+#define ATK_TEXT(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_TEXT, AtkText)
+#define ATK_TEXT_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_TEXT, AtkTextIface))
+
+#ifndef _TYPEDEF_ATK_TEXT_
+#define _TYPEDEF_ATK_TEXT_
+typedef struct _AtkText AtkText;
+#endif
+typedef struct _AtkTextIface AtkTextIface;
+
+/**
+ *AtkTextBoundary:
+ *@ATK_TEXT_BOUNDARY_CHAR: Boundary is the boundary between characters 
+ * (including non-printing characters)
+ *@ATK_TEXT_BOUNDARY_WORD_START: Boundary is the start (i.e. first character) of a word. 
+ *@ATK_TEXT_BOUNDARY_WORD_END: Boundary is the end (i.e. last character) of a word.
+ *@ATK_TEXT_BOUNDARY_SENTENCE_START: Boundary is the first character in a sentence.
+ *@ATK_TEXT_BOUNDARY_SENTENCE_END: Boundary is the last (terminal) character in a sentence; 
+ * in languages which use "sentence stop" punctuation such as English, the boundary is thus the
+ * '.', '?', or similar terminal punctuation character.
+ *@ATK_TEXT_BOUNDARY_LINE_START: Boundary is the initial character of the content or a 
+ * character immediately following a newline, linefeed, or return character.
+ *@ATK_TEXT_BOUNDARY_LINE_END: Boundary is the linefeed, or return character.
+ *
+ *Text boundary types used for specifying boundaries for regions of text
+ **/
+typedef enum {
+  ATK_TEXT_BOUNDARY_CHAR,
+  ATK_TEXT_BOUNDARY_WORD_START,
+  ATK_TEXT_BOUNDARY_WORD_END,
+  ATK_TEXT_BOUNDARY_SENTENCE_START,
+  ATK_TEXT_BOUNDARY_SENTENCE_END,
+  ATK_TEXT_BOUNDARY_LINE_START,
+  ATK_TEXT_BOUNDARY_LINE_END
+} AtkTextBoundary;
+
+/**
+ * AtkTextRectangle:
+ * @x: The horizontal coordinate of a rectangle
+ * @y: The vertical coordinate of a rectangle
+ * @width: The width of a rectangle
+ * @height: The height of a rectangle
+ *
+ * A structure used to store a rectangle used by AtkText.
+ **/
+
+typedef struct _AtkTextRectangle AtkTextRectangle;
+
+struct _AtkTextRectangle {
+  gint x;
+  gint y;
+  gint width;
+  gint height;
+};
+
+/**
+ * AtkTextRange:
+ * @bounds: A rectangle giving the bounds of the text range
+ * @start_offset: The start offset of a AtkTextRange
+ * @end_offset: The end offset of a AtkTextRange
+ * @content: The text in the text range
+ *
+ * A structure used to describe a text range.
+ **/
+typedef struct _AtkTextRange AtkTextRange;
+
+struct _AtkTextRange {
+  AtkTextRectangle bounds;
+  gint start_offset;
+  gint end_offset;
+  gchar* content;
+};
+
+/**
+ *AtkTextClipType
+ *@ATK_TEXT_CLIP_NONE: No clipping to be done
+ *@ATK_TEXT_CLIP_MIN: Text clipped by min coordinate is omitted
+ *@ATK_TEXT_CLIP_MAX: Text clipped by max coordinate is omitted
+ *@ATK_TEXT_CLIP_BOTH: Only text fully within mix/max bound is retained
+ *
+ *Describes the type of clipping required.
+ **/
+typedef enum {
+    ATK_TEXT_CLIP_NONE,
+    ATK_TEXT_CLIP_MIN,
+    ATK_TEXT_CLIP_MAX,
+    ATK_TEXT_CLIP_BOTH
+} AtkTextClipType;
+
+struct _AtkTextIface
+{
+  GTypeInterface parent;
+
+  gchar*         (* get_text)                     (AtkText          *text,
+                                                   gint             start_offset,
+                                                   gint             end_offset);
+  gchar*         (* get_text_after_offset)        (AtkText          *text,
+                                                   gint             offset,
+                                                   AtkTextBoundary  boundary_type,
+						   gint             *start_offset,
+						   gint             *end_offset);
+  gchar*         (* get_text_at_offset)           (AtkText          *text,
+                                                   gint             offset,
+                                                   AtkTextBoundary  boundary_type,
+						   gint             *start_offset,
+						   gint             *end_offset);
+  gunichar       (* get_character_at_offset)      (AtkText          *text,
+                                                   gint             offset);
+  gchar*         (* get_text_before_offset)       (AtkText          *text,
+                                                   gint             offset,
+                                                   AtkTextBoundary  boundary_type,
+ 						   gint             *start_offset,
+						   gint             *end_offset);
+  gint           (* get_caret_offset)             (AtkText          *text);
+  AtkAttributeSet* (* get_run_attributes)         (AtkText	    *text,
+						   gint	  	    offset,
+						   gint             *start_offset,
+						   gint	 	    *end_offset);
+  AtkAttributeSet* (* get_default_attributes)     (AtkText	    *text);
+  void           (* get_character_extents)        (AtkText          *text,
+                                                   gint             offset,
+                                                   gint             *x,
+                                                   gint             *y,
+                                                   gint             *width,
+                                                   gint             *height,
+                                                   AtkCoordType	    coords);
+  gint           (* get_character_count)          (AtkText          *text);
+  gint           (* get_offset_at_point)          (AtkText          *text,
+                                                   gint             x,
+                                                   gint             y,
+                                                   AtkCoordType	    coords);
+  gint		 (* get_n_selections)		  (AtkText          *text);
+  gchar*         (* get_selection)	          (AtkText          *text,
+						   gint		    selection_num,
+						   gint		    *start_offset,
+						   gint		    *end_offset);
+  gboolean       (* add_selection)		  (AtkText          *text,
+						   gint		    start_offset,
+						   gint		    end_offset);
+  gboolean       (* remove_selection)		  (AtkText          *text,
+						   gint             selection_num);
+  gboolean       (* set_selection)		  (AtkText          *text,
+						   gint		    selection_num,
+						   gint		    start_offset,
+						   gint		    end_offset);
+  gboolean       (* set_caret_offset)             (AtkText          *text,
+                                                   gint             offset);
+
+  /*
+   * signal handlers
+   */
+  void		 (* text_changed)                 (AtkText          *text,
+                                                   gint             position,
+                                                   gint             length);
+  void           (* text_caret_moved)             (AtkText          *text,
+                                                   gint             location);
+  void           (* text_selection_changed)       (AtkText          *text);
+
+  void           (* text_attributes_changed)      (AtkText          *text);
+
+
+  void           (* get_range_extents)            (AtkText          *text,
+                                                   gint             start_offset,
+                                                   gint             end_offset,
+                                                   AtkCoordType     coord_type,
+                                                   AtkTextRectangle *rect);
+
+  AtkTextRange** (* get_bounded_ranges)           (AtkText          *text,
+                                                   AtkTextRectangle *rect,
+                                                   AtkCoordType     coord_type,
+                                                   AtkTextClipType  x_clip_type,
+                                                   AtkTextClipType  y_clip_type);
+ 
+
+  AtkFunction    pad4;
+};
+
+GType            atk_text_get_type (void);
+
+
+/*
+ * Additional AtkObject properties used by AtkText:
+ *    "accessible_text" (accessible text has changed)
+ *    "accessible_caret" (accessible text cursor position changed:
+ *                         editable text only)
+ */
+
+gchar*        atk_text_get_text                           (AtkText          *text,
+                                                           gint             start_offset,
+                                                           gint             end_offset);
+gunichar      atk_text_get_character_at_offset            (AtkText          *text,
+                                                           gint             offset);
+gchar*        atk_text_get_text_after_offset              (AtkText          *text,
+                                                           gint             offset,
+                                                           AtkTextBoundary  boundary_type,
+							   gint             *start_offset,
+							   gint	            *end_offset);
+gchar*        atk_text_get_text_at_offset                 (AtkText          *text,
+                                                           gint             offset,
+                                                           AtkTextBoundary  boundary_type,
+							   gint             *start_offset,
+							   gint             *end_offset);
+gchar*        atk_text_get_text_before_offset             (AtkText          *text,
+                                                           gint             offset,
+                                                           AtkTextBoundary  boundary_type,
+							   gint             *start_offset,
+							   gint	            *end_offset);
+gint          atk_text_get_caret_offset                   (AtkText          *text);
+void          atk_text_get_character_extents              (AtkText          *text,
+                                                           gint             offset,
+                                                           gint             *x,
+                                                           gint             *y,
+                                                           gint             *width,
+                                                           gint             *height,
+                                                           AtkCoordType	    coords);
+AtkAttributeSet* atk_text_get_run_attributes              (AtkText	    *text,
+						           gint	  	    offset,
+						           gint             *start_offset,
+						           gint	 	    *end_offset);
+AtkAttributeSet* atk_text_get_default_attributes          (AtkText	    *text);
+gint          atk_text_get_character_count                (AtkText          *text);
+gint          atk_text_get_offset_at_point                (AtkText          *text,
+                                                           gint             x,
+                                                           gint             y,
+                                                           AtkCoordType	    coords);
+gint          atk_text_get_n_selections			  (AtkText          *text);
+gchar*        atk_text_get_selection			  (AtkText          *text,
+							   gint		    selection_num,
+							   gint             *start_offset,
+							   gint             *end_offset);
+gboolean      atk_text_add_selection                      (AtkText          *text,
+							   gint             start_offset,
+							   gint             end_offset);
+gboolean      atk_text_remove_selection                   (AtkText          *text,
+							   gint		    selection_num);
+gboolean      atk_text_set_selection                      (AtkText          *text,
+							   gint		    selection_num,
+							   gint             start_offset,
+							   gint             end_offset);
+gboolean      atk_text_set_caret_offset                   (AtkText          *text,
+                                                           gint             offset);
+void          atk_text_get_range_extents                  (AtkText          *text,
+
+                                                           gint             start_offset,
+                                                           gint             end_offset,
+                                                           AtkCoordType     coord_type,
+                                                           AtkTextRectangle *rect);
+AtkTextRange**  atk_text_get_bounded_ranges               (AtkText          *text,
+                                                           AtkTextRectangle *rect,
+                                                           AtkCoordType     coord_type,
+                                                           AtkTextClipType  x_clip_type,
+                                                           AtkTextClipType  y_clip_type);
+void          atk_text_free_ranges                        (AtkTextRange     **ranges);
+void 	      atk_attribute_set_free                      (AtkAttributeSet  *attrib_set);
+G_CONST_RETURN gchar*  atk_text_attribute_get_name        (AtkTextAttribute attr);
+AtkTextAttribute       atk_text_attribute_for_name        (const gchar      *name);
+G_CONST_RETURN gchar*  atk_text_attribute_get_value       (AtkTextAttribute attr,
+                                                           gint             index_);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_TEXT_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkutil.h b/other-licenses/atk-1.0/atk/atkutil.h
new file mode 100644
index 000000000..57e804e3a
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkutil.h
@@ -0,0 +1,242 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_UTIL_H__
+#define __ATK_UTIL_H__
+
+#include <atk/atkobject.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define ATK_TYPE_UTIL                   (atk_util_get_type ())
+#define ATK_IS_UTIL(obj)                G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_UTIL)
+#define ATK_UTIL(obj)                   G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_UTIL, AtkUtil)
+#define ATK_UTIL_CLASS(klass)                   (G_TYPE_CHECK_CLASS_CAST ((klass), ATK_TYPE_UTIL, AtkUtilClass))
+#define ATK_IS_UTIL_CLASS(klass)                (G_TYPE_CHECK_CLASS_TYPE ((klass), ATK_TYPE_UTIL))
+#define ATK_UTIL_GET_CLASS(obj)                 (G_TYPE_INSTANCE_GET_CLASS ((obj), ATK_TYPE_UTIL, AtkUtilClass))
+
+
+#ifndef _TYPEDEF_ATK_UTIL_
+#define _TYPEDEF_ATK_UTIL_
+typedef struct _AtkUtil      AtkUtil;
+typedef struct _AtkUtilClass AtkUtilClass;
+typedef struct _AtkKeyEventStruct AtkKeyEventStruct;
+#endif
+
+/**
+ * AtkEventListener: 
+ * @obj: An #AtkObject instance for whom the callback will be called when
+ * the specified event (e.g. 'focus:') takes place.
+ *
+ * A function which is called when an object emits a matching event,
+ * as used in #atk_add_focus_tracker.
+ * Currently the only events for which object-specific handlers are
+ * supported are events of type "focus:".  Most clients of ATK will prefer to 
+ * attach signal handlers for the various ATK signals instead.
+ *
+ * @see: atk_add_focus_tracker.
+ **/
+typedef void  (*AtkEventListener) (AtkObject* obj);
+/**
+ * AtkEventListenerInit:
+ *
+ * An #AtkEventListenerInit function is a special function that is
+ * called in order to initialize the per-object event registration system
+ * used by #AtkEventListener, if any preparation is required.  
+ *
+ * @see: atk_focus_tracker_init.
+ **/
+typedef void  (*AtkEventListenerInit) (void);
+/**
+ * AtkKeySnoopFunc:
+ * @event: an AtkKeyEventStruct containing information about the key event for which
+ * notification is being given.
+ * @func_data: a block of data which will be passed to the event listener, on notification.
+ *
+ * An #AtkKeySnoopFunc is a type of callback which is called whenever a key event occurs, 
+ * if registered via atk_add_key_event_listener.  It allows for pre-emptive 
+ * interception of key events via the return code as described below.
+ *
+ * Returns: TRUE (nonzero) if the event emission should be stopped and the event 
+ * discarded without being passed to the normal GUI recipient; FALSE (zero) if the 
+ * event dispatch to the client application should proceed as normal.
+ *
+ * @see: atk_add_key_event_listener.
+ **/
+typedef gint  (*AtkKeySnoopFunc)  (AtkKeyEventStruct *event,
+				   gpointer func_data);
+
+/**
+ * AtkKeyEventStruct:
+ * @type: An AtkKeyEventType, generally one of ATK_KEY_EVENT_PRESS or ATK_KEY_EVENT_RELEASE
+ * @state: A bitmask representing the state of the modifier keys immediately after the event takes place.   
+ * The meaning of the bits is currently defined to match the bitmask used by GDK in
+ * GdkEventType.state, see 
+ * http://developer.gnome.org/doc/API/2.0/gdk/gdk-Event-Structures.html#GdkEventKey
+ * @keyval: A guint representing a keysym value corresponding to those used by GDK and X11: see
+ * /usr/X11/include/keysymdef.h.
+ * @length: The length of member #string.
+ * @string: A string containing one of the following: either a string approximating the text that would 
+ * result from this keypress, if the key is a control or graphic character, or a symbolic name for this keypress.
+ * Alphanumeric and printable keys will have the symbolic key name in this string member, for instance "A". "0", 
+ * "semicolon", "aacute".  Keypad keys have the prefix "KP".
+ * @keycode: The raw hardware code that generated the key event.  This field is raraly useful.
+ * @timestamp: A timestamp in milliseconds indicating when the event occurred.  
+ * These timestamps are relative to a starting point which should be considered arbitrary, 
+ * and only used to compare the dispatch times of events to one another.
+ *
+ * Encapsulates information about a key event.
+ **/
+struct _AtkKeyEventStruct {
+  gint type;
+  guint state;
+  guint keyval;
+  gint length;
+  gchar *string;
+  guint16 keycode;
+  guint32 timestamp;	
+};
+
+/**
+ *AtkKeyEventType:
+ *@ATK_KEY_EVENT_PRESS: specifies a key press event
+ *@ATK_KEY_EVENT_RELEASE: specifies a key release event
+ *@ATK_KEY_EVENT_LAST_DEFINED: Not a valid value; specifies end of enumeration
+ *
+ *Specifies the type of a keyboard evemt.
+ **/
+typedef enum
+{
+  ATK_KEY_EVENT_PRESS,
+  ATK_KEY_EVENT_RELEASE,
+  ATK_KEY_EVENT_LAST_DEFINED
+} AtkKeyEventType;
+
+struct _AtkUtil
+{
+  GObject parent;
+};
+
+struct _AtkUtilClass
+{
+   GObjectClass parent;
+   guint        (* add_global_event_listener)    (GSignalEmissionHook listener,
+						  const gchar        *event_type);
+   void         (* remove_global_event_listener) (guint               listener_id);
+   guint	(* add_key_event_listener) 	 (AtkKeySnoopFunc     listener,
+						  gpointer data);
+   void         (* remove_key_event_listener)    (guint               listener_id);
+   AtkObject*   (* get_root)                     (void);
+   G_CONST_RETURN gchar* (* get_toolkit_name)    (void);
+   G_CONST_RETURN gchar* (* get_toolkit_version) (void);
+};
+GType atk_util_get_type (void);
+
+/**
+ *AtkCoordType:
+ *@ATK_XY_SCREEN: specifies xy coordinates relative to the screen
+ *@ATK_XY_WINDOW: specifies xy coordinates relative to the widget's 
+ * top-level window
+ *
+ *Specifies how xy coordinates are to be interpreted. Used by functions such
+ *as atk_component_get_position() and atk_text_get_character_extents() 
+ **/
+typedef enum {
+  ATK_XY_SCREEN,
+  ATK_XY_WINDOW
+}AtkCoordType;
+
+/*
+ * Adds the specified function to the list of functions to be called
+ * when an object receives focus.
+ */
+guint    atk_add_focus_tracker     (AtkEventListener      focus_tracker);
+
+/*
+ * Removes the specified focus tracker from the list of function
+ * to be called when any object receives focus
+ */
+void     atk_remove_focus_tracker  (guint                tracker_id);
+
+/*
+ * atk_focus_tracker_init:
+ * @init: An #AtkEventListenerInit function to be called
+ * prior to any focus-tracking requests.
+ *
+ * Specifies the function to be called for focus tracker initialization.
+ * removal. This function should be called by an implementation of the
+ * ATK interface if any specific work needs to be done to enable
+ * focus tracking.
+ */
+void     atk_focus_tracker_init    (AtkEventListenerInit  init);
+
+/*
+ * Cause the focus tracker functions which have been specified to be
+ * executed for the object.
+ */
+void     atk_focus_tracker_notify  (AtkObject            *object);
+
+/*
+ * Adds the specified function to the list of functions to be called
+ * when an event of type event_type occurs.
+ */
+guint	atk_add_global_event_listener (GSignalEmissionHook listener,
+				       const gchar        *event_type);
+
+/*
+ * Removes the specified event listener
+ */
+void	atk_remove_global_event_listener (guint listener_id);
+
+/*
+ * Adds the specified function to the list of functions to be called
+ * when an keyboard event occurs.
+ */
+guint	atk_add_key_event_listener (AtkKeySnoopFunc listener, gpointer data);
+
+/*
+ * Removes the specified event listener
+ */
+void	atk_remove_key_event_listener (guint listener_id);
+
+/*
+ * Returns the root accessible container for the current application.
+ */
+AtkObject* atk_get_root(void);
+
+AtkObject* atk_get_focus_object (void);
+
+/*
+ * Returns name string for the GUI toolkit.
+ */
+G_CONST_RETURN gchar *atk_get_toolkit_name (void);
+
+/*
+ * Returns version string for the GUI toolkit.
+ */
+G_CONST_RETURN gchar *atk_get_toolkit_version (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_UTIL_H__ */
diff --git a/other-licenses/atk-1.0/atk/atkvalue.h b/other-licenses/atk-1.0/atk/atkvalue.h
new file mode 100644
index 000000000..f66c01528
--- /dev/null
+++ b/other-licenses/atk-1.0/atk/atkvalue.h
@@ -0,0 +1,95 @@
+/* ATK -  Accessibility Toolkit
+ * 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.
+ */
+
+#ifndef __ATK_VALUE_H__
+#define __ATK_VALUE_H__
+
+#include <atk/atkobject.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ * The AtkValue interface should be supported by any object that 
+ * supports a numerical value (e.g., a scroll bar). This interface 
+ * provides the standard mechanism for an assistive technology to 
+ * determine and set the numerical value as well as get the minimum 
+ * and maximum values.
+ */
+
+#define ATK_TYPE_VALUE                    (atk_value_get_type ())
+#define ATK_IS_VALUE(obj)                 G_TYPE_CHECK_INSTANCE_TYPE ((obj), ATK_TYPE_VALUE)
+#define ATK_VALUE(obj)                    G_TYPE_CHECK_INSTANCE_CAST ((obj), ATK_TYPE_VALUE, AtkValue)
+#define ATK_VALUE_GET_IFACE(obj)          (G_TYPE_INSTANCE_GET_INTERFACE ((obj), ATK_TYPE_VALUE, AtkValueIface))
+
+#ifndef _TYPEDEF_ATK_VALUE_
+#define _TYPEDEF_ATK_VALUE__
+typedef struct _AtkValue AtkValue;
+#endif
+typedef struct _AtkValueIface AtkValueIface;
+
+struct _AtkValueIface
+{
+  GTypeInterface parent;
+
+  void     (* get_current_value) (AtkValue     *obj,
+                                  GValue       *value);
+  void     (* get_maximum_value) (AtkValue     *obj,
+                                  GValue       *value);
+  void     (* get_minimum_value) (AtkValue     *obj,
+                                  GValue       *value);
+  gboolean (* set_current_value) (AtkValue     *obj,
+                                  const GValue *value);
+  void     (* get_minimum_increment) (AtkValue   *obj,
+				      GValue     *value);
+  AtkFunction pad1;
+};
+
+GType            atk_value_get_type (void);
+
+void      atk_value_get_current_value (AtkValue     *obj,
+                                       GValue       *value);
+
+
+void     atk_value_get_maximum_value  (AtkValue     *obj,
+                                       GValue       *value);
+
+void     atk_value_get_minimum_value  (AtkValue     *obj,
+                                       GValue       *value);
+
+gboolean atk_value_set_current_value  (AtkValue     *obj,
+                                       const GValue *value);
+
+void     atk_value_get_minimum_increment  (AtkValue     *obj,
+					   GValue       *value);
+
+/*
+ * Additional GObject properties exported by GaccessibleValue:
+ *    "accessible_value"
+ *       (the accessible value has changed)
+ */
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __ATK_VALUE_H__ */