_-prefix most of the get_type functions in a11y/.
There are still some more symbols left.
atk_focus_tracker_init (gail_focus_tracker_init);
focus_tracker_id = atk_add_focus_tracker (gail_focus_tracker);
- gail_util_install ();
+ _gail_util_install ();
atk_misc_instance = g_object_new (GAIL_TYPE_MISC, NULL);
}
#include "gailmisc.h"
-G_DEFINE_TYPE (GailMisc, gail_misc, ATK_TYPE_MISC)
+G_DEFINE_TYPE (GailMisc, _gail_misc, ATK_TYPE_MISC)
static void
gail_misc_threads_enter (AtkMisc *misc)
}
static void
-gail_misc_class_init (GailMiscClass *klass)
+_gail_misc_class_init (GailMiscClass *klass)
{
AtkMiscClass *misc_class = ATK_MISC_CLASS (klass);
}
static void
-gail_misc_init (GailMisc *misc)
+_gail_misc_init (GailMisc *misc)
{
}
G_BEGIN_DECLS
-#define GAIL_TYPE_MISC (gail_misc_get_type ())
+#define GAIL_TYPE_MISC (_gail_misc_get_type ())
#define GAIL_MISC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GAIL_TYPE_MISC, GailMisc))
#define GAIL_MISC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GAIL_TYPE_MISC, GailMiscClass))
#define GAIL_IS_MISC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GAIL_TYPE_MISC))
AtkMiscClass parent_class;
};
-GType gail_misc_get_type (void);
+GType _gail_misc_get_type (void);
G_END_DECLS
}
void
-gail_util_install (void)
+_gail_util_install (void)
{
AtkUtilClass *atk_class = ATK_UTIL_CLASS (g_type_class_ref (ATK_TYPE_UTIL));
G_BEGIN_DECLS
-void gail_util_install (void);
+void _gail_util_install (void);
G_END_DECLS
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkArrowAccessible, gtk_arrow_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkArrowAccessible, _gtk_arrow_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init))
static void
gtk_arrow_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_arrow_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_arrow_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_ICON;
}
g_free (arrow->image_description);
- G_OBJECT_CLASS (gtk_arrow_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_arrow_accessible_parent_class)->finalize (object);
}
static void
-gtk_arrow_accessible_class_init (GtkArrowAccessibleClass *klass)
+_gtk_arrow_accessible_class_init (GtkArrowAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_arrow_accessible_init (GtkArrowAccessible *arrow)
+_gtk_arrow_accessible_init (GtkArrowAccessible *arrow)
{
arrow->image_description = NULL;
}
G_BEGIN_DECLS
-#define GTK_TYPE_ARROW_ACCESSIBLE (gtk_arrow_accessible_get_type ())
+#define GTK_TYPE_ARROW_ACCESSIBLE (_gtk_arrow_accessible_get_type ())
#define GTK_ARROW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ARROW_ACCESSIBLE, GtkArrowAccessible))
#define GTK_ARROW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ARROW_ACCESSIBLE, GtkArrowAccessibleClass))
#define GTK_IS_ARROW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ARROW_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_arrow_accessible_get_type (void);
+GType _gtk_arrow_accessible_get_type (void);
G_END_DECLS
#include "gtkboxaccessible.h"
-G_DEFINE_TYPE (GtkBoxAccessible, gtk_box_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
+G_DEFINE_TYPE (GtkBoxAccessible, _gtk_box_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
static void
gtk_box_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_box_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_box_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_FILLER;
}
static void
-gtk_box_accessible_class_init (GtkBoxAccessibleClass *klass)
+_gtk_box_accessible_class_init (GtkBoxAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_box_accessible_init (GtkBoxAccessible *scale)
+_gtk_box_accessible_init (GtkBoxAccessible *scale)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_BOX_ACCESSIBLE (gtk_box_accessible_get_type ())
+#define GTK_TYPE_BOX_ACCESSIBLE (_gtk_box_accessible_get_type ())
#define GTK_BOX_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BOX_ACCESSIBLE, GtkBoxAccessible))
#define GTK_BOX_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BOX_ACCESSIBLE, GtkBoxAccessibleClass))
#define GTK_IS_BOX_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BOX_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_box_accessible_get_type (void);
+GType _gtk_box_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkButtonAccessible, gtk_button_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkButtonAccessible, _gtk_button_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init))
{
GtkWidget *parent;
- ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_button_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "state-flags-changed", G_CALLBACK (state_changed_cb), NULL);
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (_gtk_button_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (_gtk_button_accessible_parent_class)->ref_state_set (obj);
if ((gtk_widget_get_state_flags (widget) & GTK_STATE_FLAG_ACTIVE) != 0)
atk_state_set_add_state (state_set, ATK_STATE_ARMED);
g_signal_emit_by_name (atk_obj, "visible_data_changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-gtk_button_accessible_class_init (GtkButtonAccessibleClass *klass)
+_gtk_button_accessible_class_init (GtkButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkContainerAccessibleClass *container_class = (GtkContainerAccessibleClass*)klass;
}
static void
-gtk_button_accessible_init (GtkButtonAccessible *button)
+_gtk_button_accessible_init (GtkButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_BUTTON_ACCESSIBLE (gtk_button_accessible_get_type ())
+#define GTK_TYPE_BUTTON_ACCESSIBLE (_gtk_button_accessible_get_type ())
#define GTK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUTTON_ACCESSIBLE, GtkButtonAccessible))
#define GTK_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON_ACCESSIBLE, GtkButtonAccessibleClass))
#define GTK_IS_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUTTON_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_button_accessible_get_type (void);
+GType _gtk_button_accessible_get_type (void);
G_END_DECLS
#include "gtkcheckmenuitemaccessible.h"
-G_DEFINE_TYPE (GtkCheckMenuItemAccessible, gtk_check_menu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE)
+G_DEFINE_TYPE (GtkCheckMenuItemAccessible, _gtk_check_menu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE)
static void
toggled_cb (GtkWidget *widget)
gtk_check_menu_item_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_check_menu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_check_menu_item_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "toggled", G_CALLBACK (toggled_cb), NULL);
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_check_menu_item_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_check_menu_item_accessible_parent_class)->ref_state_set (accessible);
check_menu_item = GTK_CHECK_MENU_ITEM (widget);
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, (sensitive && !inconsistent));
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_check_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_check_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-gtk_check_menu_item_accessible_class_init (GtkCheckMenuItemAccessibleClass *klass)
+_gtk_check_menu_item_accessible_class_init (GtkCheckMenuItemAccessibleClass *klass)
{
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_check_menu_item_accessible_init (GtkCheckMenuItemAccessible *item)
+_gtk_check_menu_item_accessible_init (GtkCheckMenuItemAccessible *item)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE (gtk_check_menu_item_accessible_get_type ())
+#define GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE (_gtk_check_menu_item_accessible_get_type ())
#define GTK_CHECK_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE, GtkCheckMenuItemAccessible))
#define GTK_CHECK_MENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE, GtkCheckMenuItemAccessibleClass))
#define GTK_IS_CHECK_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE))
GtkMenuItemAccessibleClass parent_class;
};
-GType gtk_check_menu_item_accessible_get_type (void);
+GType _gtk_check_menu_item_accessible_get_type (void);
G_END_DECLS
#include "gtkchecksubmenuitemaccessible.h"
-G_DEFINE_TYPE (GtkCheckSubmenuItemAccessible, gtk_check_submenu_item_accessible, GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE)
+G_DEFINE_TYPE (GtkCheckSubmenuItemAccessible, _gtk_check_submenu_item_accessible, GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE)
static void
toggled_cb (GtkWidget *widget)
gtk_check_submenu_item_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_check_submenu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_check_submenu_item_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "toggled", G_CALLBACK (toggled_cb), NULL);
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_check_submenu_item_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_check_submenu_item_accessible_parent_class)->ref_state_set (accessible);
check_menu_item = GTK_CHECK_MENU_ITEM (widget);
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, (sensitive && !inconsistent));
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_check_submenu_item_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_check_submenu_item_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-gtk_check_submenu_item_accessible_class_init (GtkCheckSubmenuItemAccessibleClass *klass)
+_gtk_check_submenu_item_accessible_class_init (GtkCheckSubmenuItemAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-gtk_check_submenu_item_accessible_init (GtkCheckSubmenuItemAccessible *item)
+_gtk_check_submenu_item_accessible_init (GtkCheckSubmenuItemAccessible *item)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_CHECK_SUBMENU_ITEM_ACCESSIBLE (gtk_check_submenu_item_accessible_get_type ())
+#define GTK_TYPE_CHECK_SUBMENU_ITEM_ACCESSIBLE (_gtk_check_submenu_item_accessible_get_type ())
#define GTK_CHECK_SUBMENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_SUBMENU_ITEM_ACCESSIBLE, GtkCheckSubmenuItemAccessible))
#define GTK_CHECK_SUBMENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_SUBMENU_ITEM_ACCESSIBLE, GtkCheckSubmenuItemAccessibleClass))
#define GTK_IS_CHECK_SUBMENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_SUBMENU_ITEM_ACCESSIBLE))
GtkSubmenuItemAccessibleClass parent_class;
};
-GType gtk_check_submenu_item_accessible_get_type (void);
+GType _gtk_check_submenu_item_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkComboBoxAccessible, gtk_combo_box_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkComboBoxAccessible, _gtk_combo_box_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
GtkComboBoxAccessible *accessible;
AtkObject *popup;
- ATK_OBJECT_CLASS (gtk_combo_box_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->initialize (obj, data);
combo_box = GTK_COMBO_BOX (data);
accessible = GTK_COMBO_BOX_ACCESSIBLE (obj);
g_free (combo_box->name);
- G_OBJECT_CLASS (gtk_combo_box_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->finalize (object);
}
-static const gchar*
+static const gchar *
gtk_combo_box_accessible_get_name (AtkObject *obj)
{
GtkWidget *widget;
gint n_columns;
gint i;
- name = ATK_OBJECT_CLASS (gtk_combo_box_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (_gtk_combo_box_accessible_parent_class)->get_name (obj);
if (name)
return name;
}
static void
-gtk_combo_box_accessible_class_init (GtkComboBoxAccessibleClass *klass)
+_gtk_combo_box_accessible_class_init (GtkComboBoxAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_combo_box_accessible_init (GtkComboBoxAccessible *combo_box)
+_gtk_combo_box_accessible_init (GtkComboBoxAccessible *combo_box)
{
combo_box->old_selection = -1;
combo_box->name = NULL;
if (!gtk_widget_get_sensitive (widget) || !gtk_widget_get_visible (widget))
return FALSE;
- if (i == 0)
- {
- combo_box = GTK_COMBO_BOX (widget);
- g_object_get (combo_box, "popup-shown", &popup_shown, NULL);
- if (popup_shown)
- gtk_combo_box_popdown (combo_box);
- else
- gtk_combo_box_popup (combo_box);
- return TRUE;
- }
- else
+ if (i != 0)
return FALSE;
+
+ combo_box = GTK_COMBO_BOX (widget);
+ g_object_get (combo_box, "popup-shown", &popup_shown, NULL);
+ if (popup_shown)
+ gtk_combo_box_popdown (combo_box);
+ else
+ gtk_combo_box_popup (combo_box);
+
+ return TRUE;
}
static gint
G_BEGIN_DECLS
-#define GTK_TYPE_COMBO_BOX_ACCESSIBLE (gtk_combo_box_accessible_get_type ())
+#define GTK_TYPE_COMBO_BOX_ACCESSIBLE (_gtk_combo_box_accessible_get_type ())
#define GTK_COMBO_BOX_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMBO_BOX_ACCESSIBLE, GtkComboBoxAccessible))
#define GTK_COMBO_BOX_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COMBO_BOX_ACCESSIBLE, GtkComboBoxAccessibleClass))
#define GTK_IS_COMBO_BOX_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMBO_BOX_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_combo_box_accessible_get_type (void);
+GType _gtk_combo_box_accessible_get_type (void);
G_END_DECLS
#include "gtkcontaineraccessible.h"
-G_DEFINE_TYPE (GtkContainerAccessible, gtk_container_accessible, GTK_TYPE_WIDGET_ACCESSIBLE)
-
-static void
-gtk_container_accessible_init (GtkContainerAccessible *container)
-{
-}
+G_DEFINE_TYPE (GtkContainerAccessible, _gtk_container_accessible, GTK_TYPE_WIDGET_ACCESSIBLE)
static gint
gtk_container_accessible_get_n_children (AtkObject* obj)
{
GtkContainerAccessible *accessible = GTK_CONTAINER_ACCESSIBLE (obj);
- ATK_OBJECT_CLASS (gtk_container_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_container_accessible_parent_class)->initialize (obj, data);
accessible->children = gtk_container_get_children (GTK_CONTAINER (data));
g_list_free (accessible->children);
- G_OBJECT_CLASS (gtk_container_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_container_accessible_parent_class)->finalize (object);
}
static void
-gtk_container_accessible_class_init (GtkContainerAccessibleClass *klass)
+_gtk_container_accessible_class_init (GtkContainerAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
klass->add_gtk = gtk_container_accessible_real_add_gtk;
klass->remove_gtk = gtk_container_accessible_real_remove_gtk;
}
+
+static void
+_gtk_container_accessible_init (GtkContainerAccessible *container)
+{
+}
+
G_BEGIN_DECLS
-#define GTK_TYPE_CONTAINER_ACCESSIBLE (gtk_container_accessible_get_type ())
+#define GTK_TYPE_CONTAINER_ACCESSIBLE (_gtk_container_accessible_get_type ())
#define GTK_CONTAINER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER_ACCESSIBLE, GtkContainerAccessible))
#define GTK_CONTAINER_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER_ACCESSIBLE, GtkContainerAccessibleClass))
#define GTK_IS_CONTAINER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER_ACCESSIBLE))
gpointer data);
};
-GType gtk_container_accessible_get_type (void);
+GType _gtk_container_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkEntryAccessible, gtk_entry_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkEntryAccessible, _gtk_entry_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_EDITABLE_TEXT, atk_editable_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
-static AtkStateSet*
+static AtkStateSet *
gtk_entry_accessible_ref_state_set (AtkObject *accessible)
{
AtkStateSet *state_set;
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->ref_state_set (accessible);
g_object_get (G_OBJECT (widget), "editable", &value, NULL);
if (value)
AtkAttribute *placeholder_text;
const gchar *text;
- attributes = ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->get_attributes (accessible);
+ attributes = ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->get_attributes (accessible);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
GtkEntryAccessible *gtk_entry_accessible;
gint start_pos, end_pos;
- ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->initialize (obj, data);
gtk_entry_accessible = GTK_ENTRY_ACCESSIBLE (obj);
atk_object_set_role (atk_obj, new_role);
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_entry_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_entry_accessible_parent_class)->notify_gtk (obj, pspec);
}
static gint
if (GTK_IS_COMBO_BOX_ACCESSIBLE (accessible->accessible_parent))
return 1;
- return ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->get_index_in_parent (accessible);
+ return ATK_OBJECT_CLASS (_gtk_entry_accessible_parent_class)->get_index_in_parent (accessible);
}
static void
-gtk_entry_accessible_class_init (GtkEntryAccessibleClass *klass)
+_gtk_entry_accessible_class_init (GtkEntryAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-gtk_entry_accessible_init (GtkEntryAccessible *entry)
+_gtk_entry_accessible_init (GtkEntryAccessible *entry)
{
entry->length_insert = 0;
entry->length_delete = 0;
G_BEGIN_DECLS
-#define GTK_TYPE_ENTRY_ACCESSIBLE (gtk_entry_accessible_get_type ())
+#define GTK_TYPE_ENTRY_ACCESSIBLE (_gtk_entry_accessible_get_type ())
#define GTK_ENTRY_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_ACCESSIBLE, GtkEntryAccessible))
#define GTK_ENTRY_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY_ACCESSIBLE, GtkEntryAccessibleClass))
#define GTK_IS_ENTRY_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_entry_accessible_get_type (void);
+GType _gtk_entry_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkExpanderAccessible, gtk_expander_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkExpanderAccessible, _gtk_expander_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
static const gchar *
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (gtk_expander_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (_gtk_expander_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
if (gtk_expander_get_label_widget (GTK_EXPANDER (widget)))
count -= 1;
- return count;
+ return count;
}
static AtkObject *
gtk_expander_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_expander_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_expander_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_TOGGLE_BUTTON;
}
g_signal_emit_by_name (atk_obj, "visible_data_changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_expander_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_expander_accessible_parent_class)->notify_gtk (obj, pspec);
}
-static AtkStateSet*
+static AtkStateSet *
gtk_expander_accessible_ref_state_set (AtkObject *obj)
{
AtkStateSet *state_set;
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_expander_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (_gtk_expander_accessible_parent_class)->ref_state_set (obj);
expander = GTK_EXPANDER (widget);
}
static void
-gtk_expander_accessible_class_init (GtkExpanderAccessibleClass *klass)
+_gtk_expander_accessible_class_init (GtkExpanderAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-gtk_expander_accessible_init (GtkExpanderAccessible *expander)
+_gtk_expander_accessible_init (GtkExpanderAccessible *expander)
{
}
return FALSE;
if (i != 0)
- return FALSE;
+ return FALSE;
gtk_widget_activate (widget);
return TRUE;
G_BEGIN_DECLS
-#define GTK_TYPE_EXPANDER_ACCESSIBLE (gtk_expander_accessible_get_type ())
+#define GTK_TYPE_EXPANDER_ACCESSIBLE (_gtk_expander_accessible_get_type ())
#define GTK_EXPANDER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EXPANDER_ACCESSIBLE, GtkExpanderAccessible))
#define GTK_EXPANDER_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EXPANDER_ACCESSIBLE, GtkExpanderAccessibleClass))
#define GTK_IS_EXPANDER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EXPANDER_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_expander_accessible_get_type (void);
+GType _gtk_expander_accessible_get_type (void);
G_END_DECLS
#include "gtkframeaccessible.h"
-G_DEFINE_TYPE (GtkFrameAccessible, gtk_frame_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
+G_DEFINE_TYPE (GtkFrameAccessible, _gtk_frame_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
static void
gtk_frame_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_frame_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_frame_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_PANEL;
}
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (gtk_frame_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (_gtk_frame_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
}
static void
-gtk_frame_accessible_class_init (GtkFrameAccessibleClass *klass)
+_gtk_frame_accessible_class_init (GtkFrameAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_frame_accessible_init (GtkFrameAccessible *frame)
+_gtk_frame_accessible_init (GtkFrameAccessible *frame)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_FRAME_ACCESSIBLE (gtk_frame_accessible_get_type ())
+#define GTK_TYPE_FRAME_ACCESSIBLE (_gtk_frame_accessible_get_type ())
#define GTK_FRAME_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FRAME_ACCESSIBLE, GtkFrameAccessible))
#define GTK_FRAME_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FRAME_ACCESSIBLE, GtkFrameAccessibleClass))
#define GTK_IS_FRAME_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FRAME_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_frame_accessible_get_type (void);
+GType _gtk_frame_accessible_get_type (void);
G_END_DECLS
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkImageAccessible, gtk_image_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkImageAccessible, _gtk_image_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init))
static void
gtk_image_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_image_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_image_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_ICON;
}
g_free (aimage->image_description);
g_free (aimage->stock_name);
- G_OBJECT_CLASS (gtk_image_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_image_accessible_parent_class)->finalize (object);
}
static const gchar *
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (gtk_image_accessible_parent_class)->get_name (accessible);
+ name = ATK_OBJECT_CLASS (_gtk_image_accessible_parent_class)->get_name (accessible);
if (name)
return name;
}
static void
-gtk_image_accessible_class_init (GtkImageAccessibleClass *klass)
+_gtk_image_accessible_class_init (GtkImageAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_image_accessible_init (GtkImageAccessible *image)
+_gtk_image_accessible_init (GtkImageAccessible *image)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_IMAGE_ACCESSIBLE (gtk_image_accessible_get_type ())
+#define GTK_TYPE_IMAGE_ACCESSIBLE (_gtk_image_accessible_get_type ())
#define GTK_IMAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE_ACCESSIBLE, GtkImageAccessible))
#define GTK_IMAGE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IMAGE_ACCESSIBLE, GtkImageAccessibleClass))
#define GTK_IS_IMAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_image_accessible_get_type (void);
+GType _gtk_image_accessible_get_type (void);
G_END_DECLS
static void atk_text_interface_init (AtkTextIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkLabelAccessible, gtk_label_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkLabelAccessible, _gtk_label_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init))
static void
-gtk_label_accessible_init (GtkLabelAccessible *label)
+_gtk_label_accessible_init (GtkLabelAccessible *label)
{
}
GtkWidget *widget;
GtkLabelAccessible *accessible;
- ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->initialize (obj, data);
accessible = GTK_LABEL_ACCESSIBLE (obj);
g_signal_emit_by_name (atk_obj, "text_selection_changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_label_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_label_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
g_free (accessible->text);
- G_OBJECT_CLASS (gtk_label_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_label_accessible_parent_class)->finalize (object);
}
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->ref_state_set (accessible);
atk_state_set_add_state (state_set, ATK_STATE_MULTI_LINE);
return state_set;
if (widget == NULL)
return NULL;
- relation_set = ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->ref_relation_set (obj);
if (!atk_relation_set_contains (relation_set, ATK_RELATION_LABEL_FOR))
{
g_return_val_if_fail (GTK_IS_LABEL_ACCESSIBLE (accessible), NULL);
- name = ATK_OBJECT_CLASS (gtk_label_accessible_parent_class)->get_name (accessible);
+ name = ATK_OBJECT_CLASS (_gtk_label_accessible_parent_class)->get_name (accessible);
if (name != NULL)
return name;
else
}
static void
-gtk_label_accessible_class_init (GtkLabelAccessibleClass *klass)
+_gtk_label_accessible_class_init (GtkLabelAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
G_BEGIN_DECLS
-#define GTK_TYPE_LABEL_ACCESSIBLE (gtk_label_accessible_get_type ())
+#define GTK_TYPE_LABEL_ACCESSIBLE (_gtk_label_accessible_get_type ())
#define GTK_LABEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LABEL_ACCESSIBLE, GtkLabelAccessible))
#define GTK_LABEL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LABEL_ACCESSIBLE, GtkLabelAccessibleClass))
#define GTK_IS_LABEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LABEL_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_label_accessible_get_type (void);
+GType _gtk_label_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkLinkButtonAccessibleLink, gtk_link_button_accessible_link, ATK_TYPE_HYPERLINK,
+G_DEFINE_TYPE_WITH_CODE (GtkLinkButtonAccessibleLink, _gtk_link_button_accessible_link, ATK_TYPE_HYPERLINK,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
static AtkHyperlink *
{
GtkLinkButtonAccessibleLink *link;
- link = g_object_new (gtk_link_button_accessible_link_get_type (), NULL);
+ link = g_object_new (_gtk_link_button_accessible_link_get_type (), NULL);
link->button = button;
return ATK_HYPERLINK (link);
static gchar *
gtk_link_button_accessible_link_get_uri (AtkHyperlink *link,
- gint i)
+ gint i)
{
GtkLinkButtonAccessibleLink *l = (GtkLinkButtonAccessibleLink *)link;
GtkWidget *widget;
static AtkObject *
gtk_link_button_accessible_link_get_object (AtkHyperlink *link,
- gint i)
+ gint i)
{
GtkLinkButtonAccessibleLink *l = (GtkLinkButtonAccessibleLink *)link;
}
static void
-gtk_link_button_accessible_link_init (GtkLinkButtonAccessibleLink *link)
+_gtk_link_button_accessible_link_init (GtkLinkButtonAccessibleLink *link)
{
}
static void
-gtk_link_button_accessible_link_class_init (GtkLinkButtonAccessibleLinkClass *class)
+_gtk_link_button_accessible_link_class_init (GtkLinkButtonAccessibleLinkClass *class)
{
AtkHyperlinkClass *hyperlink_class = ATK_HYPERLINK_CLASS (class);
static gboolean
gtk_link_button_accessible_link_do_action (AtkAction *action,
- gint i)
+ gint i)
{
GtkLinkButtonAccessibleLink *link = (GtkLinkButtonAccessibleLink *)action;
GtkWidget *widget;
widget = GTK_WIDGET (link->button);
if (widget == NULL)
- /*
- * State is defunct
- */
+ return FALSE;
+
+ if (i != 0)
return FALSE;
if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_visible (widget))
gtk_link_button_accessible_link_get_name (AtkAction *action,
gint i)
{
- g_return_val_if_fail (i == 0, NULL);
+ if (i != 0)
+ return NULL;
return "activate";
}
}
static gboolean
-activate_link (GtkLinkButton *button, AtkHyperlink *link)
+activate_link (GtkLinkButton *button,
+ AtkHyperlink *link)
{
g_signal_emit_by_name (link, "link-activated");
static void atk_hypertext_impl_interface_init (AtkHyperlinkImplIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkLinkButtonAccessible, gtk_link_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkLinkButtonAccessible, _gtk_link_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_HYPERLINK_IMPL, atk_hypertext_impl_interface_init))
static void
-gtk_link_button_accessible_init (GtkLinkButtonAccessible *button)
+_gtk_link_button_accessible_init (GtkLinkButtonAccessible *button)
{
}
if (button->link)
g_object_unref (button->link);
- G_OBJECT_CLASS (gtk_link_button_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_link_button_accessible_parent_class)->finalize (object);
}
static void
-gtk_link_button_accessible_class_init (GtkLinkButtonAccessibleClass *klass)
+_gtk_link_button_accessible_class_init (GtkLinkButtonAccessibleClass *klass)
{
G_OBJECT_CLASS (klass)->finalize = gtk_link_button_accessible_finalize;
}
G_BEGIN_DECLS
-#define GTK_TYPE_LINK_BUTTON_ACCESSIBLE (gtk_link_button_accessible_get_type ())
+#define GTK_TYPE_LINK_BUTTON_ACCESSIBLE (_gtk_link_button_accessible_get_type ())
#define GTK_LINK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LINK_BUTTON_ACCESSIBLE, GtkLinkButtonAccessible))
#define GTK_LINK_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LINK_BUTTON_ACCESSIBLE, GtkLinkButtonAccessibleClass))
#define GTK_IS_LINK_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LINK_BUTTON_ACCESSIBLE))
GtkButtonAccessibleClass parent_class;
};
-GType gtk_link_button_accessible_get_type (void);
+GType _gtk_link_button_accessible_get_type (void);
G_END_DECLS
#include "gtkmenuaccessible.h"
-G_DEFINE_TYPE (GtkMenuAccessible, gtk_menu_accessible, GTK_TYPE_MENU_SHELL_ACCESSIBLE)
+G_DEFINE_TYPE (GtkMenuAccessible, _gtk_menu_accessible, GTK_TYPE_MENU_SHELL_ACCESSIBLE)
static void
gtk_menu_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_menu_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_menu_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_MENU;
- gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_POPUP);
+ _gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_POPUP);
}
static AtkObject *
if (gtk_menu_get_attach_widget (GTK_MENU (widget)))
return 0;
- return ATK_OBJECT_CLASS (gtk_menu_accessible_parent_class)->get_index_in_parent (accessible);
+ return ATK_OBJECT_CLASS (_gtk_menu_accessible_parent_class)->get_index_in_parent (accessible);
}
static void
-gtk_menu_accessible_class_init (GtkMenuAccessibleClass *klass)
+_gtk_menu_accessible_class_init (GtkMenuAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_menu_accessible_init (GtkMenuAccessible *accessible)
+_gtk_menu_accessible_init (GtkMenuAccessible *accessible)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_MENU_ACCESSIBLE (gtk_menu_accessible_get_type ())
+#define GTK_TYPE_MENU_ACCESSIBLE (_gtk_menu_accessible_get_type ())
#define GTK_MENU_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ACCESSIBLE, GtkMenuAccessible))
#define GTK_MENU_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ACCESSIBLE, GtkMenuAccessibleClass))
#define GTK_IS_MENU_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ACCESSIBLE))
GtkMenuShellAccessibleClass parent_class;
};
-GType gtk_menu_accessible_get_type (void);
+GType _gtk_menu_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkMenuItemAccessible, gtk_menu_item_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkMenuItemAccessible, _gtk_menu_item_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
static void
GtkWidget *widget;
GtkWidget *parent;
- ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "select", G_CALLBACK (menu_item_select), NULL);
g_signal_connect (data, "deselect", G_CALLBACK (menu_item_deselect), NULL);
atk_object_set_parent (obj, gtk_widget_get_accessible (parent_widget));
}
- gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_POPUP);
+ _gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_POPUP);
if (GTK_IS_TEAROFF_MENU_ITEM (data))
obj->role = ATK_ROLE_TEAR_OFF_MENU_ITEM;
AtkObject *menu_item;
AtkStateSet *state_set, *parent_state_set;
- state_set = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->ref_state_set (obj);
menu_item = atk_object_get_parent (obj);
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->get_name (obj);
if (name)
return name;
g_free (accessible->text);
- G_OBJECT_CLASS (gtk_menu_item_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->finalize (object);
}
static void
g_signal_emit_by_name (atk_obj, "visible_data_changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_menu_item_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-gtk_menu_item_accessible_class_init (GtkMenuItemAccessibleClass *klass)
+_gtk_menu_item_accessible_class_init (GtkMenuItemAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_menu_item_accessible_init (GtkMenuItemAccessible *menu_item)
+_gtk_menu_item_accessible_init (GtkMenuItemAccessible *menu_item)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_MENU_ITEM_ACCESSIBLE (gtk_menu_item_accessible_get_type ())
+#define GTK_TYPE_MENU_ITEM_ACCESSIBLE (_gtk_menu_item_accessible_get_type ())
#define GTK_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessible))
#define GTK_MENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessibleClass))
#define GTK_IS_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_menu_item_accessible_get_type (void);
+GType _gtk_menu_item_accessible_get_type (void);
G_END_DECLS
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkMenuShellAccessible, gtk_menu_shell_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkMenuShellAccessible, _gtk_menu_shell_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
static void
gtk_menu_shell_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_menu_shell_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_menu_shell_accessible_parent_class)->initialize (accessible, data);
if (GTK_IS_MENU_BAR (data))
accessible->role = ATK_ROLE_MENU_BAR;
}
static void
-gtk_menu_shell_accessible_class_init (GtkMenuShellAccessibleClass *klass)
+_gtk_menu_shell_accessible_class_init (GtkMenuShellAccessibleClass *klass)
{
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_menu_shell_accessible_init (GtkMenuShellAccessible *menu_shell)
+_gtk_menu_shell_accessible_init (GtkMenuShellAccessible *menu_shell)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_MENU_SHELL_ACCESSIBLE (gtk_menu_shell_accessible_get_type ())
+#define GTK_TYPE_MENU_SHELL_ACCESSIBLE (_gtk_menu_shell_accessible_get_type ())
#define GTK_MENU_SHELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_SHELL_ACCESSIBLE, GtkMenuShellAccessible))
#define GTK_MENU_SHELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_SHELL_ACCESSIBLE, GtkMenuShellAccessibleClass))
#define GTK_IS_MENU_SHELL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_SHELL_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_menu_shell_accessible_get_type (void);
+GType _gtk_menu_shell_accessible_get_type (void);
G_END_DECLS
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkNotebookAccessible, gtk_notebook_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkNotebookAccessible, _gtk_notebook_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
static gboolean
{
AtkObject *obj;
- obj = gtk_notebook_page_accessible_new (accessible, child);
+ obj = _gtk_notebook_page_accessible_new (accessible, child);
g_hash_table_insert (accessible->pages, child, obj);
atk_object_set_parent (obj, ATK_OBJECT (accessible));
g_signal_emit_by_name (accessible, "children_changed::add", page_num, obj, NULL);
g_return_if_fail (obj);
g_signal_emit_by_name (accessible, "children_changed::remove",
page_num, obj, NULL);
- gtk_notebook_page_accessible_invalidate (GTK_NOTEBOOK_PAGE_ACCESSIBLE (obj));
+ _gtk_notebook_page_accessible_invalidate (GTK_NOTEBOOK_PAGE_ACCESSIBLE (obj));
g_hash_table_remove (accessible->pages, widget);
}
GtkNotebook *notebook;
gint i;
- ATK_OBJECT_CLASS (gtk_notebook_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_notebook_accessible_parent_class)->initialize (obj, data);
accessible = GTK_NOTEBOOK_ACCESSIBLE (obj);
notebook = GTK_NOTEBOOK (data);
if (accessible->idle_focus_id)
g_source_remove (accessible->idle_focus_id);
- G_OBJECT_CLASS (gtk_notebook_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_notebook_accessible_parent_class)->finalize (object);
}
static AtkObject *
}
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_notebook_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_notebook_accessible_parent_class)->notify_gtk (obj, pspec);
}
/*
}
static void
-gtk_notebook_accessible_class_init (GtkNotebookAccessibleClass *klass)
+_gtk_notebook_accessible_class_init (GtkNotebookAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_notebook_accessible_init (GtkNotebookAccessible *notebook)
+_gtk_notebook_accessible_init (GtkNotebookAccessible *notebook)
{
notebook->pages = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
G_BEGIN_DECLS
-#define GTK_TYPE_NOTEBOOK_ACCESSIBLE (gtk_notebook_accessible_get_type ())
+#define GTK_TYPE_NOTEBOOK_ACCESSIBLE (_gtk_notebook_accessible_get_type ())
#define GTK_NOTEBOOK_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessible))
#define GTK_NOTEBOOK_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessibleClass))
#define GTK_IS_NOTEBOOK_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_notebook_accessible_get_type (void);
+GType _gtk_notebook_accessible_get_type (void);
G_END_DECLS
static void atk_component_interface_init (AtkComponentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkNotebookPageAccessible, gtk_notebook_page_accessible, ATK_TYPE_OBJECT,
+G_DEFINE_TYPE_WITH_CODE (GtkNotebookPageAccessible, _gtk_notebook_page_accessible, ATK_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init))
AtkObject *atk_label;
GtkWidget *label;
- state_set = ATK_OBJECT_CLASS (gtk_notebook_page_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_notebook_page_accessible_parent_class)->ref_state_set (accessible);
label = get_label_from_notebook_page (GTK_NOTEBOOK_PAGE_ACCESSIBLE (accessible));
if (label)
}
static void
-gtk_notebook_page_accessible_class_init (GtkNotebookPageAccessibleClass *klass)
+_gtk_notebook_page_accessible_class_init (GtkNotebookPageAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_notebook_page_accessible_init (GtkNotebookPageAccessible *page)
+_gtk_notebook_page_accessible_init (GtkNotebookPageAccessible *page)
{
}
}
AtkObject *
-gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
- GtkWidget *child)
+_gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
+ GtkWidget *child)
{
GObject *object;
AtkObject *atk_object;
}
void
-gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page)
+_gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page)
{
AtkObject *obj = ATK_OBJECT (page);
GtkWidget *notebook;
*
* 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
+ * 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
G_BEGIN_DECLS
-#define GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE (gtk_notebook_page_accessible_get_type ())
+#define GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE (_gtk_notebook_page_accessible_get_type ())
#define GTK_NOTEBOOK_PAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE, GtkNotebookPageAccessible))
#define GTK_NOTEBOOK_PAGE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE, GtkNotebookPageAccessibleClass))
#define GTK_IS_NOTEBOOK_PAGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE))
AtkObjectClass parent_class;
};
-GType gtk_notebook_page_accessible_get_type (void);
+GType _gtk_notebook_page_accessible_get_type (void);
-AtkObject *gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
- GtkWidget *child);
+AtkObject *_gtk_notebook_page_accessible_new (GtkNotebookAccessible *notebook,
+ GtkWidget *child);
-void gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page);
+void _gtk_notebook_page_accessible_invalidate (GtkNotebookPageAccessible *page);
G_END_DECLS
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkPanedAccessible, gtk_paned_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkPanedAccessible, _gtk_paned_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
static void
gtk_paned_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_paned_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_paned_accessible_parent_class)->initialize (obj, data);
- g_signal_connect (data,
- "size_allocate",
- G_CALLBACK (gtk_paned_accessible_size_allocate_gtk),
- NULL);
+ g_signal_connect (data, "size_allocate",
+ G_CALLBACK (gtk_paned_accessible_size_allocate_gtk), NULL);
obj->role = ATK_ROLE_SPLIT_PANE;
}
static void
-gtk_paned_accessible_class_init (GtkPanedAccessibleClass *klass)
+_gtk_paned_accessible_class_init (GtkPanedAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_paned_accessible_init (GtkPanedAccessible *paned)
+_gtk_paned_accessible_init (GtkPanedAccessible *paned)
{
}
g_value_set_int (value, minimum_value);
}
-/*
- * Calling atk_value_set_current_value() is no guarantee that the value
+/* Calling atk_value_set_current_value() is no guarantee that the value
* is acceptable; it is necessary to listen for accessible-value signals
* and check whether the current value has been changed or check what the
* maximum and minimum values are.
*/
-
static gboolean
gtk_paned_accessible_set_current_value (AtkValue *obj,
const GValue *value)
G_BEGIN_DECLS
-#define GTK_TYPE_PANED_ACCESSIBLE (gtk_paned_accessible_get_type ())
+#define GTK_TYPE_PANED_ACCESSIBLE (_gtk_paned_accessible_get_type ())
#define GTK_PANED_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PANED_ACCESSIBLE, GtkPanedAccessible))
#define GTK_PANED_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PANED_ACCESSIBLE, GtkPanedAccessibleClass))
#define GTK_IS_PANED_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PANED_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_paned_accessible_get_type (void);
+GType _gtk_paned_accessible_get_type (void);
G_END_DECLS
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkProgressBarAccessible, gtk_progress_bar_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkProgressBarAccessible, _gtk_progress_bar_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
static void
gtk_progress_bar_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_progress_bar_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_progress_bar_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_PROGRESS_BAR;
}
if (strcmp (pspec->name, "fraction") == 0)
g_object_notify (G_OBJECT (accessible), "accessible-value");
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_progress_bar_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_progress_bar_accessible_parent_class)->notify_gtk (obj, pspec);
}
+
static void
-gtk_progress_bar_accessible_class_init (GtkProgressBarAccessibleClass *klass)
+_gtk_progress_bar_accessible_class_init (GtkProgressBarAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-gtk_progress_bar_accessible_init (GtkProgressBarAccessible *bar)
+_gtk_progress_bar_accessible_init (GtkProgressBarAccessible *bar)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_PROGRESS_BAR_ACCESSIBLE (gtk_progress_bar_accessible_get_type ())
+#define GTK_TYPE_PROGRESS_BAR_ACCESSIBLE (_gtk_progress_bar_accessible_get_type ())
#define GTK_PROGRESS_BAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE, GtkProgressBarAccessible))
#define GTK_PROGRESS_BAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE, GtkProgressBarAccessibleClass))
#define GTK_IS_PROGRESS_BAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_progress_bar_accessible_get_type (void);
+GType _gtk_progress_bar_accessible_get_type (void);
G_END_DECLS
#include "gtkradiobuttonaccessible.h"
-G_DEFINE_TYPE (GtkRadioButtonAccessible, gtk_radio_button_accessible, GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE)
+G_DEFINE_TYPE (GtkRadioButtonAccessible, _gtk_radio_button_accessible, GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE)
static void
gtk_radio_button_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_radio_button_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_radio_button_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_RADIO_BUTTON;
}
radio_button = GTK_RADIO_BUTTON_ACCESSIBLE (obj);
- relation_set = ATK_OBJECT_CLASS (gtk_radio_button_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (_gtk_radio_button_accessible_parent_class)->ref_relation_set (obj);
/* If the radio button'group has changed remove the relation */
list = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
}
static void
-gtk_radio_button_accessible_class_init (GtkRadioButtonAccessibleClass *klass)
+_gtk_radio_button_accessible_class_init (GtkRadioButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_radio_button_accessible_init (GtkRadioButtonAccessible *radio_button)
+_gtk_radio_button_accessible_init (GtkRadioButtonAccessible *radio_button)
{
radio_button->old_group = NULL;
}
-
G_BEGIN_DECLS
-#define GTK_TYPE_RADIO_BUTTON_ACCESSIBLE (gtk_radio_button_accessible_get_type ())
+#define GTK_TYPE_RADIO_BUTTON_ACCESSIBLE (_gtk_radio_button_accessible_get_type ())
#define GTK_RADIO_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE, GtkRadioButtonAccessible))
#define GTK_RADIO_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE, GtkRadioButtonAccessibleClass))
#define GTK_IS_RADIO_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE))
GtkToggleButtonAccessibleClass parent_class;
};
-GType gtk_radio_button_accessible_get_type (void);
+GType _gtk_radio_button_accessible_get_type (void);
G_END_DECLS
#include "gtkradiosubmenuitemaccessible.h"
-G_DEFINE_TYPE (GtkRadioMenuItemAccessible, gtk_radio_menu_item_accessible, GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE)
+G_DEFINE_TYPE (GtkRadioMenuItemAccessible, _gtk_radio_menu_item_accessible, GTK_TYPE_CHECK_MENU_ITEM_ACCESSIBLE)
static AtkRelationSet *
gtk_radio_menu_item_accessible_ref_relation_set (AtkObject *obj)
radio_menu_item = GTK_RADIO_MENU_ITEM_ACCESSIBLE (obj);
- relation_set = ATK_OBJECT_CLASS (gtk_radio_menu_item_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (_gtk_radio_menu_item_accessible_parent_class)->ref_relation_set (obj);
/* If the radio menu_item'group has changed remove the relation */
list = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (widget));
gtk_radio_menu_item_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_radio_menu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_radio_menu_item_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_RADIO_MENU_ITEM;
}
static void
-gtk_radio_menu_item_accessible_class_init (GtkRadioMenuItemAccessibleClass *klass)
+_gtk_radio_menu_item_accessible_class_init (GtkRadioMenuItemAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_radio_menu_item_accessible_init (GtkRadioMenuItemAccessible *radio_menu_item)
+_gtk_radio_menu_item_accessible_init (GtkRadioMenuItemAccessible *radio_menu_item)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE (gtk_radio_menu_item_accessible_get_type ())
+#define GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE (_gtk_radio_menu_item_accessible_get_type ())
#define GTK_RADIO_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE, GtkRadioMenuItemAccessible))
#define GTK_RADIO_MENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE, GtkRadioMenuItemAccessibleClass))
#define GTK_IS_RADIO_MENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE))
GtkCheckMenuItemAccessibleClass parent_class;
};
-GType gtk_radio_menu_item_accessible_get_type (void);
+GType _gtk_radio_menu_item_accessible_get_type (void);
G_END_DECLS
#include "gtkradiosubmenuitemaccessible.h"
-G_DEFINE_TYPE (GtkRadioSubmenuItemAccessible, gtk_radio_submenu_item_accessible, GTK_TYPE_CHECK_SUBMENU_ITEM_ACCESSIBLE)
+G_DEFINE_TYPE (GtkRadioSubmenuItemAccessible, _gtk_radio_submenu_item_accessible, GTK_TYPE_CHECK_SUBMENU_ITEM_ACCESSIBLE)
static AtkRelationSet *
radio_menu_item = GTK_RADIO_SUBMENU_ITEM_ACCESSIBLE (obj);
- relation_set = ATK_OBJECT_CLASS (gtk_radio_submenu_item_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (_gtk_radio_submenu_item_accessible_parent_class)->ref_relation_set (obj);
/* If the radio menu_item's group has changed remove the relation */
list = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (widget));
gtk_radio_submenu_item_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_radio_submenu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_radio_submenu_item_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_RADIO_MENU_ITEM;
}
static void
-gtk_radio_submenu_item_accessible_class_init (GtkRadioSubmenuItemAccessibleClass *klass)
+_gtk_radio_submenu_item_accessible_class_init (GtkRadioSubmenuItemAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_radio_submenu_item_accessible_init (GtkRadioSubmenuItemAccessible *radio_menu_item)
+_gtk_radio_submenu_item_accessible_init (GtkRadioSubmenuItemAccessible *radio_menu_item)
{
radio_menu_item->old_group = NULL;
}
G_BEGIN_DECLS
-#define GTK_TYPE_RADIO_SUBMENU_ITEM_ACCESSIBLE (gtk_radio_submenu_item_accessible_get_type ())
+#define GTK_TYPE_RADIO_SUBMENU_ITEM_ACCESSIBLE (_gtk_radio_submenu_item_accessible_get_type ())
#define GTK_RADIO_SUBMENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_SUBMENU_ITEM_ACCESSIBLE, GtkRadioSubmenuItemAccessible))
#define GTK_RADIO_SUBMENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_SUBMENU_ITEM_ACCESSIBLE, GtkRadioSubmenuItemAccessibleClass))
#define GTK_IS_RADIO_SUBMENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_SUBMENU_ITEM_ACCESSIBLE))
GtkCheckSubmenuItemAccessibleClass parent_class;
};
-GType gtk_radio_submenu_item_accessible_get_type (void);
+GType _gtk_radio_submenu_item_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkRangeAccessible, gtk_range_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkRangeAccessible, _gtk_range_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
GtkAdjustment *adj;
GtkRange *gtk_range;
- ATK_OBJECT_CLASS (gtk_range_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_range_accessible_parent_class)->initialize (obj, data);
gtk_range = GTK_RANGE (data);
/*
*/
adj = gtk_range_get_adjustment (gtk_range);
if (adj)
- {
- g_signal_connect (adj,
- "value-changed",
- G_CALLBACK (gtk_range_accessible_value_changed),
- range);
- }
+ g_signal_connect (adj, "value-changed",
+ G_CALLBACK (gtk_range_accessible_value_changed),
+ range);
obj->role = ATK_ROLE_SLIDER;
}
range);
}
- G_OBJECT_CLASS (gtk_range_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_range_accessible_parent_class)->finalize (object);
}
static void
{
range = gtk_widget_get_accessible (widget);
adj = gtk_range_get_adjustment (GTK_RANGE (widget));
- g_signal_connect (adj,
- "value-changed",
+ g_signal_connect (adj, "value-changed",
G_CALLBACK (gtk_range_accessible_value_changed),
range);
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_range_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_range_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-gtk_range_accessible_class_init (GtkRangeAccessibleClass *klass)
+_gtk_range_accessible_class_init (GtkRangeAccessibleClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_range_accessible_init (GtkRangeAccessible *range)
+_gtk_range_accessible_init (GtkRangeAccessible *range)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_RANGE_ACCESSIBLE (gtk_range_accessible_get_type ())
+#define GTK_TYPE_RANGE_ACCESSIBLE (_gtk_range_accessible_get_type ())
#define GTK_RANGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RANGE_ACCESSIBLE, GtkRangeAccessible))
#define GTK_RANGE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RANGE_ACCESSIBLE, GtkRangeAccessibleClass))
#define GTK_IS_RANGE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RANGE_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_range_accessible_get_type (void);
+GType _gtk_range_accessible_get_type (void);
G_END_DECLS
#include <gtk/gtk.h>
#include "gtkscaleaccessible.h"
-G_DEFINE_TYPE (GtkScaleAccessible, gtk_scale_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
+G_DEFINE_TYPE (GtkScaleAccessible, _gtk_scale_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
static const gchar *
gtk_scale_accessible_get_description (AtkObject *object)
if (layout)
return pango_layout_get_text (layout);
- return ATK_OBJECT_CLASS (gtk_scale_accessible_parent_class)->get_description (object);
+ return ATK_OBJECT_CLASS (_gtk_scale_accessible_parent_class)->get_description (object);
}
static void
-gtk_scale_accessible_class_init (GtkScaleAccessibleClass *klass)
+_gtk_scale_accessible_class_init (GtkScaleAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_scale_accessible_init (GtkScaleAccessible *scale)
+_gtk_scale_accessible_init (GtkScaleAccessible *scale)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SCALE_ACCESSIBLE (gtk_scale_accessible_get_type ())
+#define GTK_TYPE_SCALE_ACCESSIBLE (_gtk_scale_accessible_get_type ())
#define GTK_SCALE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_ACCESSIBLE, GtkScaleAccessible))
#define GTK_SCALE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_ACCESSIBLE, GtkScaleAccessibleClass))
#define GTK_IS_SCALE_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_ACCESSIBLE))
GtkRangeAccessibleClass parent_class;
};
-GType gtk_scale_accessible_get_type (void);
+GType _gtk_scale_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkScaleButtonAccessible, gtk_scale_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkScaleButtonAccessible, _gtk_scale_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init));
{
GtkAdjustment *adjustment;
- ATK_OBJECT_CLASS (gtk_scale_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_scale_button_accessible_parent_class)->initialize (obj, data);
adjustment = gtk_scale_button_get_adjustment (GTK_SCALE_BUTTON (data));
if (adjustment)
}
else
{
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_scale_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_scale_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
}
static void
-gtk_scale_button_accessible_class_init (GtkScaleButtonAccessibleClass *klass)
+_gtk_scale_button_accessible_class_init (GtkScaleButtonAccessibleClass *klass)
{
AtkObjectClass *atk_object_class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = GTK_WIDGET_ACCESSIBLE_CLASS (klass);
}
static void
-gtk_scale_button_accessible_init (GtkScaleButtonAccessible *button)
+_gtk_scale_button_accessible_init (GtkScaleButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SCALE_BUTTON_ACCESSIBLE (gtk_scale_button_accessible_get_type ())
+#define GTK_TYPE_SCALE_BUTTON_ACCESSIBLE (_gtk_scale_button_accessible_get_type ())
#define GTK_SCALE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE, GtkScaleButtonAccessible))
#define GTK_SCALE_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE, GtkScaleButtonAccessibleClass))
#define GTK_IS_SCALE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE))
GtkButtonAccessibleClass parent_class;
};
-GType gtk_scale_button_accessible_get_type (void);
+GType _gtk_scale_button_accessible_get_type (void);
G_END_DECLS
#include "gtkscrollbaraccessible.h"
-G_DEFINE_TYPE (GtkScrollbarAccessible, gtk_scrollbar_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
+G_DEFINE_TYPE (GtkScrollbarAccessible, _gtk_scrollbar_accessible, GTK_TYPE_RANGE_ACCESSIBLE)
static void
-gtk_scrollbar_accessible_init (GtkScrollbarAccessible *accessible)
+_gtk_scrollbar_accessible_init (GtkScrollbarAccessible *accessible)
{
}
static void
gtk_scrollbar_accessible_initialize (AtkObject *accessible,
- gpointer data)
+ gpointer data)
{
- ATK_OBJECT_CLASS (gtk_scrollbar_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_scrollbar_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_SCROLL_BAR;
}
parent = gtk_widget_get_parent (widget);
if (!GTK_IS_SCROLLED_WINDOW (parent))
- return ATK_OBJECT_CLASS (gtk_scrollbar_accessible_parent_class)->get_index_in_parent (accessible);
+ return ATK_OBJECT_CLASS (_gtk_scrollbar_accessible_parent_class)->get_index_in_parent (accessible);
scrolled_window = GTK_SCROLLED_WINDOW (parent);
id = 0;
}
static void
-gtk_scrollbar_accessible_class_init (GtkScrollbarAccessibleClass *klass)
+_gtk_scrollbar_accessible_class_init (GtkScrollbarAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
G_BEGIN_DECLS
-#define GTK_TYPE_SCROLLBAR_ACCESSIBLE (gtk_scrollbar_accessible_get_type ())
+#define GTK_TYPE_SCROLLBAR_ACCESSIBLE (_gtk_scrollbar_accessible_get_type ())
#define GTK_SCROLLBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessible))
#define GTK_SCROLLBAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessibleClass))
#define GTK_IS_SCROLLBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE))
GtkRangeAccessibleClass parent_class;
};
-GType gtk_scrollbar_accessible_get_type (void);
+GType _gtk_scrollbar_accessible_get_type (void);
G_END_DECLS
#include "gtkscrolledwindowaccessible.h"
-G_DEFINE_TYPE (GtkScrolledWindowAccessible, gtk_scrolled_window_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
+G_DEFINE_TYPE (GtkScrolledWindowAccessible, _gtk_scrolled_window_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE)
static void
visibility_changed (GObject *object,
}
}
+
static void
gtk_scrolled_window_accessible_initialize (AtkObject *obj,
gpointer data)
{
GtkScrolledWindow *window;
- ATK_OBJECT_CLASS (gtk_scrolled_window_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_scrolled_window_accessible_parent_class)->initialize (obj, data);
window = GTK_SCROLLED_WINDOW (data);
}
static void
-gtk_scrolled_window_accessible_class_init (GtkScrolledWindowAccessibleClass *klass)
+_gtk_scrolled_window_accessible_class_init (GtkScrolledWindowAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_scrolled_window_accessible_init (GtkScrolledWindowAccessible *window)
+_gtk_scrolled_window_accessible_init (GtkScrolledWindowAccessible *window)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE (gtk_scrolled_window_accessible_get_type ())
+#define GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE (_gtk_scrolled_window_accessible_get_type ())
#define GTK_SCROLLED_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessible))
#define GTK_SCROLLED_WINDOW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessibleClass))
#define GTK_IS_SCROLLED_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_scrolled_window_accessible_get_type (void);
+GType _gtk_scrolled_window_accessible_get_type (void);
G_END_DECLS
static void atk_value_interface_init (AtkValueIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkSpinButtonAccessible, gtk_spin_button_accessible, GTK_TYPE_ENTRY_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkSpinButtonAccessible, _gtk_spin_button_accessible, GTK_TYPE_ENTRY_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
static void
{
GtkAdjustment *adjustment;
- ATK_OBJECT_CLASS (gtk_spin_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_spin_button_accessible_parent_class)->initialize (obj, data);
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (data));
if (adjustment)
GtkAdjustment* adjustment;
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
- g_signal_connect (adjustment,
- "value-changed",
+ g_signal_connect (adjustment, "value-changed",
G_CALLBACK (gtk_spin_button_accessible_value_changed),
spin_button);
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_spin_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_spin_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
-gtk_spin_button_accessible_class_init (GtkSpinButtonAccessibleClass *klass)
+_gtk_spin_button_accessible_class_init (GtkSpinButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-gtk_spin_button_accessible_init (GtkSpinButtonAccessible *button)
+_gtk_spin_button_accessible_init (GtkSpinButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SPIN_BUTTON_ACCESSIBLE (gtk_spin_button_accessible_get_type ())
+#define GTK_TYPE_SPIN_BUTTON_ACCESSIBLE (_gtk_spin_button_accessible_get_type ())
#define GTK_SPIN_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE, GtkSpinButtonAccessible))
#define GTK_SPIN_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE, GtkSpinButtonAccessibleClass))
#define GTK_IS_SPIN_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE))
GtkEntryAccessibleClass parent_class;
};
-GType gtk_spin_button_accessible_get_type (void);
+GType _gtk_spin_button_accessible_get_type (void);
G_END_DECLS
static void atk_image_interface_init (AtkImageIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkSpinnerAccessible, gtk_spinner_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkSpinnerAccessible, _gtk_spinner_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMAGE, atk_image_interface_init));
static void
gtk_spinner_accessible_initialize (AtkObject *accessible,
gpointer widget)
{
- ATK_OBJECT_CLASS (gtk_spinner_accessible_parent_class)->initialize (accessible, widget);
+ ATK_OBJECT_CLASS (_gtk_spinner_accessible_parent_class)->initialize (accessible, widget);
atk_object_set_name (accessible, C_("throbbing progress animation widget", "Spinner"));
atk_object_set_description (accessible, _("Provides visual indication of progress"));
}
static void
-gtk_spinner_accessible_class_init (GtkSpinnerAccessibleClass *klass)
+_gtk_spinner_accessible_class_init (GtkSpinnerAccessibleClass *klass)
{
AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_spinner_accessible_init (GtkSpinnerAccessible *self)
+_gtk_spinner_accessible_init (GtkSpinnerAccessible *self)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SPINNER_ACCESSIBLE (gtk_spinner_accessible_get_type ())
+#define GTK_TYPE_SPINNER_ACCESSIBLE (_gtk_spinner_accessible_get_type ())
#define GTK_SPINNER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPINNER_ACCESSIBLE, GtkSpinnerAccessible))
#define GTK_SPINNER_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPINNER_ACCESSIBLE, GtkSpinnerAccessibleClass))
#define GTK_IS_SPINNER_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPINNER_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_spinner_accessible_get_type (void);
+GType _gtk_spinner_accessible_get_type (void);
G_END_DECLS
#include "gtkstatusbaraccessible.h"
-G_DEFINE_TYPE (GtkStatusbarAccessible, gtk_statusbar_accessible, GTK_TYPE_BOX_ACCESSIBLE)
+G_DEFINE_TYPE (GtkStatusbarAccessible, _gtk_statusbar_accessible, GTK_TYPE_BOX_ACCESSIBLE)
static void
text_changed (GtkStatusbar *statusbar,
{
GtkWidget *statusbar = data;
- ATK_OBJECT_CLASS (gtk_statusbar_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_statusbar_accessible_parent_class)->initialize (obj, data);
g_signal_connect_after (statusbar, "text-pushed",
G_CALLBACK (text_changed), obj);
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (gtk_statusbar_accessible_parent_class)->get_name (obj);
+ name = ATK_OBJECT_CLASS (_gtk_statusbar_accessible_parent_class)->get_name (obj);
if (name != NULL)
return name;
}
static void
-gtk_statusbar_accessible_class_init (GtkStatusbarAccessibleClass *klass)
+_gtk_statusbar_accessible_class_init (GtkStatusbarAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkContainerAccessibleClass *container_class = (GtkContainerAccessibleClass*)klass;
}
static void
-gtk_statusbar_accessible_init (GtkStatusbarAccessible *bar)
+_gtk_statusbar_accessible_init (GtkStatusbarAccessible *bar)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_STATUSBAR_ACCESSIBLE (gtk_statusbar_accessible_get_type ())
+#define GTK_TYPE_STATUSBAR_ACCESSIBLE (_gtk_statusbar_accessible_get_type ())
#define GTK_STATUSBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STATUSBAR_ACCESSIBLE, GtkStatusbarAccessible))
#define GTK_STATUSBAR_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STATUSBAR_ACCESSIBLE, GtkStatusbarAccessibleClass))
#define GTK_IS_STATUSBAR_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STATUSBAR_ACCESSIBLE))
GtkBoxAccessibleClass parent_class;
};
-GType gtk_statusbar_accessible_get_type (void);
+GType _gtk_statusbar_accessible_get_type (void);
G_END_DECLS
static void atk_selection_interface_init (AtkSelectionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkSubmenuItemAccessible, gtk_submenu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkSubmenuItemAccessible, _gtk_submenu_item_accessible, GTK_TYPE_MENU_ITEM_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init))
static void
{
GtkWidget *submenu;
- ATK_OBJECT_CLASS (gtk_submenu_item_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_submenu_item_accessible_parent_class)->initialize (obj, data);
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (data));
if (submenu)
}
static void
-gtk_submenu_item_accessible_class_init (GtkSubmenuItemAccessibleClass *klass)
+_gtk_submenu_item_accessible_class_init (GtkSubmenuItemAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_submenu_item_accessible_init (GtkSubmenuItemAccessible *item)
+_gtk_submenu_item_accessible_init (GtkSubmenuItemAccessible *item)
{
}
child = g_list_nth_data (kids, i);
g_list_free (kids);
- g_return_val_if_fail (GTK_IS_MENU_ITEM(child), FALSE);
+ g_return_val_if_fail (GTK_IS_MENU_ITEM (child), FALSE);
gtk_menu_shell_select_item (shell, GTK_WIDGET (child));
return TRUE;
}
G_BEGIN_DECLS
-#define GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE (gtk_submenu_item_accessible_get_type ())
+#define GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE (_gtk_submenu_item_accessible_get_type ())
#define GTK_SUBMENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE, GtkSubmenuItemAccessible))
#define GTK_SUBMENU_ITEM_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE, GtkSubmenuItemAccessibleClass))
#define GTK_IS_SUBMENU_ITEM_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SUBMENU_ITEM_ACCESSIBLE))
GtkMenuItemAccessibleClass parent_class;
};
-GType gtk_submenu_item_accessible_get_type (void);
+GType _gtk_submenu_item_accessible_get_type (void);
G_END_DECLS
static void atk_action_interface_init (AtkActionIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkSwitchAccessible, gtk_switch_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkSwitchAccessible, _gtk_switch_accessible, GTK_TYPE_WIDGET_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION, atk_action_interface_init))
static AtkStateSet *
AtkStateSet *state_set;
GtkWidget *widget;
- state_set = ATK_OBJECT_CLASS (gtk_switch_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_switch_accessible_parent_class)->ref_state_set (accessible);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
gtk_switch_accessible_initialize (AtkObject *accessible,
gpointer widget)
{
- ATK_OBJECT_CLASS (gtk_switch_accessible_parent_class)->initialize (accessible, widget);
+ ATK_OBJECT_CLASS (_gtk_switch_accessible_parent_class)->initialize (accessible, widget);
atk_object_set_role (accessible, ATK_ROLE_TOGGLE_BUTTON);
atk_object_set_name (accessible, C_("light switch widget", "Switch"));
}
static void
-gtk_switch_accessible_class_init (GtkSwitchAccessibleClass *klass)
+_gtk_switch_accessible_class_init (GtkSwitchAccessibleClass *klass)
{
AtkObjectClass *atk_class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_switch_accessible_init (GtkSwitchAccessible *self)
+_gtk_switch_accessible_init (GtkSwitchAccessible *self)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_SWITCH_ACCESSIBLE (gtk_switch_accessible_get_type ())
+#define GTK_TYPE_SWITCH_ACCESSIBLE (_gtk_switch_accessible_get_type ())
#define GTK_SWITCH_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SWITCH_ACCESSIBLE, GtkSwitchAccessible))
#define GTK_SWITCH_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SWITCH_ACCESSIBLE, GtkSwitchAccessibleClass))
#define GTK_IS_SWITCH_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SWITCH_ACCESSIBLE))
GtkWidgetAccessibleClass parent_class;
};
-GType gtk_switch_accessible_get_type (void);
+GType _gtk_switch_accessible_get_type (void);
G_END_DECLS
static void atk_text_interface_init (AtkTextIface *iface);
static void atk_streamable_content_interface_init (AtkStreamableContentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkTextViewAccessible, gtk_text_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkTextViewAccessible, _gtk_text_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_EDITABLE_TEXT, atk_editable_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_TEXT, atk_text_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_STREAMABLE_CONTENT, atk_streamable_content_interface_init))
gtk_text_view_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_text_view_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_text_view_accessible_parent_class)->initialize (obj, data);
setup_buffer (GTK_TEXT_VIEW (data), GTK_TEXT_VIEW_ACCESSIBLE (obj));
setup_buffer (GTK_TEXT_VIEW (obj), GTK_TEXT_VIEW_ACCESSIBLE (atk_obj));
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_text_view_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_text_view_accessible_parent_class)->notify_gtk (obj, pspec);
}
static AtkStateSet*
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_text_view_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_text_view_accessible_parent_class)->ref_state_set (accessible);
if (gtk_text_view_get_editable (GTK_TEXT_VIEW (widget)))
atk_state_set_add_state (state_set, ATK_STATE_EDITABLE);
}
static void
-gtk_text_view_accessible_class_init (GtkTextViewAccessibleClass *klass)
+_gtk_text_view_accessible_class_init (GtkTextViewAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-gtk_text_view_accessible_init (GtkTextViewAccessible *accessible)
+_gtk_text_view_accessible_init (GtkTextViewAccessible *accessible)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_TEXT_VIEW_ACCESSIBLE (gtk_text_view_accessible_get_type ())
+#define GTK_TYPE_TEXT_VIEW_ACCESSIBLE (_gtk_text_view_accessible_get_type ())
#define GTK_TEXT_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_VIEW_ACCESSIBLE, GtkTextViewAccessible))
#define GTK_TEXT_VIEW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW_ACCESSIBLE, GtkTextViewAccessibleClass))
#define GTK_IS_TEXT_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_VIEW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_text_view_accessible_get_type (void);
+GType _gtk_text_view_accessible_get_type (void);
G_END_DECLS
#include "gtktogglebuttonaccessible.h"
-G_DEFINE_TYPE (GtkToggleButtonAccessible, gtk_toggle_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE)
+G_DEFINE_TYPE (GtkToggleButtonAccessible, _gtk_toggle_button_accessible, GTK_TYPE_BUTTON_ACCESSIBLE)
static void
gtk_toggle_button_accessible_toggled (GtkWidget *widget)
gtk_toggle_button_accessible_initialize (AtkObject *obj,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_toggle_button_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_toggle_button_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "toggled",
G_CALLBACK (gtk_toggle_button_accessible_toggled), NULL);
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, (sensitive && !inconsistent));
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_toggle_button_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_toggle_button_accessible_parent_class)->notify_gtk (obj, pspec);
}
static AtkStateSet*
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_toggle_button_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_toggle_button_accessible_parent_class)->ref_state_set (accessible);
toggle_button = GTK_TOGGLE_BUTTON (widget);
if (gtk_toggle_button_get_active (toggle_button))
}
static void
-gtk_toggle_button_accessible_class_init (GtkToggleButtonAccessibleClass *klass)
+_gtk_toggle_button_accessible_class_init (GtkToggleButtonAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
}
static void
-gtk_toggle_button_accessible_init (GtkToggleButtonAccessible *button)
+_gtk_toggle_button_accessible_init (GtkToggleButtonAccessible *button)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE (gtk_toggle_button_accessible_get_type ())
+#define GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE (_gtk_toggle_button_accessible_get_type ())
#define GTK_TOGGLE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE, GtkToggleButtonAccessible))
#define GTK_TOGGLE_BUTTON_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE, GtkToggleButtonAccessibleClass))
#define GTK_IS_TOGGLE_BUTTON_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE))
GtkButtonAccessibleClass parent_class;
};
-GType gtk_toggle_button_accessible_get_type (void);
+GType _gtk_toggle_button_accessible_get_type (void);
G_END_DECLS
#include "gtktoplevelaccessible.h"
-G_DEFINE_TYPE (GtkToplevelAccessible, gtk_toplevel_accessible, ATK_TYPE_OBJECT)
+G_DEFINE_TYPE (GtkToplevelAccessible, _gtk_toplevel_accessible, ATK_TYPE_OBJECT)
static void
gtk_toplevel_accessible_initialize (AtkObject *accessible,
gpointer data)
{
- ATK_OBJECT_CLASS (gtk_toplevel_accessible_parent_class)->initialize (accessible, data);
+ ATK_OBJECT_CLASS (_gtk_toplevel_accessible_parent_class)->initialize (accessible, data);
accessible->role = ATK_ROLE_APPLICATION;
accessible->name = g_get_prgname ();
if (toplevel->window_list)
g_list_free (toplevel->window_list);
- G_OBJECT_CLASS (gtk_toplevel_accessible_parent_class)->finalize (obj);
+ G_OBJECT_CLASS (_gtk_toplevel_accessible_parent_class)->finalize (obj);
}
static gint
}
static void
-gtk_toplevel_accessible_class_init (GtkToplevelAccessibleClass *klass)
+_gtk_toplevel_accessible_class_init (GtkToplevelAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS(klass);
GObjectClass *g_object_class = G_OBJECT_CLASS(klass);
}
static void
-gtk_toplevel_accessible_init (GtkToplevelAccessible *toplevel)
+_gtk_toplevel_accessible_init (GtkToplevelAccessible *toplevel)
{
GtkWindow *window;
GtkWidget *widget;
G_BEGIN_DECLS
-#define GTK_TYPE_TOPLEVEL_ACCESSIBLE (gtk_toplevel_accessible_get_type ())
+#define GTK_TYPE_TOPLEVEL_ACCESSIBLE (_gtk_toplevel_accessible_get_type ())
#define GTK_TOPLEVEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOPLEVEL_ACCESSIBLE, GtkToplevelAccessible))
#define GTK_TOPLEVEL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOPLEVEL_ACCESSIBLE, GtkToplevelAccessibleClass))
#define GTK_IS_TOPLEVEL_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOPLEVEL_ACCESSIBLE))
AtkObjectClass parent_class;
};
-GType gtk_toplevel_accessible_get_type (void);
+GType _gtk_toplevel_accessible_get_type (void);
G_END_DECLS
static void atk_component_interface_init (AtkComponentIface *iface);
static void gail_cell_parent_interface_init (GailCellParentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkTreeViewAccessible, gtk_tree_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkTreeViewAccessible, _gtk_tree_view_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_TABLE, atk_table_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION, atk_selection_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init)
GtkWidget *widget;
GtkTreeSelection *selection;
- ATK_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_tree_view_accessible_parent_class)->initialize (obj, data);
accessible = GTK_TREE_VIEW_ACCESSIBLE (obj);
accessible->col_data = NULL;
g_array_free (array, TRUE);
}
- G_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_tree_view_accessible_parent_class)->finalize (object);
}
static void
g_signal_connect (adj, "value-changed", G_CALLBACK (adjustment_changed), tree_view);
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_tree_view_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_tree_view_accessible_parent_class)->notify_gtk (obj, pspec);
}
static void
g_signal_connect_after (widget, "destroy",
G_CALLBACK (gtk_tree_view_accessible_destroyed), accessible);
- GTK_ACCESSIBLE_CLASS (gtk_tree_view_accessible_parent_class)->connect_widget_destroyed (accessible);
+ GTK_ACCESSIBLE_CLASS (_gtk_tree_view_accessible_parent_class)->connect_widget_destroyed (accessible);
}
static gint
AtkStateSet *state_set;
GtkWidget *widget;
- state_set = ATK_OBJECT_CLASS (gtk_tree_view_accessible_parent_class)->ref_state_set (obj);
+ state_set = ATK_OBJECT_CLASS (_gtk_tree_view_accessible_parent_class)->ref_state_set (obj);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget != NULL)
}
static void
-gtk_tree_view_accessible_class_init (GtkTreeViewAccessibleClass *klass)
+_gtk_tree_view_accessible_class_init (GtkTreeViewAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
}
static void
-gtk_tree_view_accessible_init (GtkTreeViewAccessible *view)
+_gtk_tree_view_accessible_init (GtkTreeViewAccessible *view)
{
}
/* This function returns a reference to the accessible object
* for the cell in the treeview which has focus, if any
*/
-AtkObject *
+static AtkObject *
gtk_tree_view_accessible_ref_focus_cell (GtkTreeView *tree_view)
{
AtkObject *focus_cell = NULL;
G_BEGIN_DECLS
-#define GTK_TYPE_TREE_VIEW_ACCESSIBLE (gtk_tree_view_accessible_get_type ())
+#define GTK_TYPE_TREE_VIEW_ACCESSIBLE (_gtk_tree_view_accessible_get_type ())
#define GTK_TREE_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW_ACCESSIBLE, GtkTreeViewAccessible))
#define GTK_TREE_VIEW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW_ACCESSIBLE, GtkTreeViewAccessibleClass))
#define GTK_IS_TREE_VIEW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_tree_view_accessible_get_type (void);
-AtkObject *gtk_tree_view_accessible_ref_focus_cell (GtkTreeView *treeview);
+GType _gtk_tree_view_accessible_get_type (void);
G_END_DECLS
static void atk_component_interface_init (AtkComponentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkWidgetAccessible, gtk_widget_accessible, GTK_TYPE_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkWidgetAccessible, _gtk_widget_accessible, GTK_TYPE_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init))
/* Translate GtkWidget::focus-in/out-event to the focus_gtk vfunc */
if (widget == NULL)
return NULL;
- relation_set = ATK_OBJECT_CLASS (gtk_widget_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (_gtk_widget_accessible_parent_class)->ref_relation_set (obj);
if (GTK_IS_BOX (widget))
return relation_set;
GtkWidget *widget;
AtkStateSet *state_set;
- state_set = ATK_OBJECT_CLASS (gtk_widget_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_widget_accessible_parent_class)->ref_state_set (accessible);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
}
static void
-gtk_widget_accessible_class_init (GtkWidgetAccessibleClass *klass)
+_gtk_widget_accessible_class_init (GtkWidgetAccessibleClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GtkAccessibleClass *accessible_class = GTK_ACCESSIBLE_CLASS (klass);
}
static void
-gtk_widget_accessible_init (GtkWidgetAccessible *accessible)
+_gtk_widget_accessible_init (GtkWidgetAccessible *accessible)
{
}
}
void
-gtk_widget_accessible_set_layer (GtkWidgetAccessible *accessible,
+_gtk_widget_accessible_set_layer (GtkWidgetAccessible *accessible,
AtkLayer layer)
{
g_object_set_data (G_OBJECT (accessible), "atk-component-layer", GINT_TO_POINTER (layer));
G_BEGIN_DECLS
-#define GTK_TYPE_WIDGET_ACCESSIBLE (gtk_widget_accessible_get_type ())
+#define GTK_TYPE_WIDGET_ACCESSIBLE (_gtk_widget_accessible_get_type ())
#define GTK_WIDGET_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WIDGET_ACCESSIBLE, GtkWidgetAccessible))
#define GTK_WIDGET_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET_ACCESSIBLE, GtkWidgetAccessibleClass))
#define GTK_IS_WIDGET_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WIDGET_ACCESSIBLE))
};
-GType gtk_widget_accessible_get_type (void);
+GType _gtk_widget_accessible_get_type (void);
-void gtk_widget_accessible_set_layer (GtkWidgetAccessible *obj,
- AtkLayer layer);
+void _gtk_widget_accessible_set_layer (GtkWidgetAccessible *obj,
+ AtkLayer layer);
G_END_DECLS
static void atk_component_interface_init (AtkComponentIface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkWindowAccessible, gtk_window_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
+G_DEFINE_TYPE_WITH_CODE (GtkWindowAccessible, _gtk_window_accessible, GTK_TYPE_CONTAINER_ACCESSIBLE,
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init))
g_signal_emit_by_name (atk_obj, "visible_data_changed");
}
else
- GTK_WIDGET_ACCESSIBLE_CLASS (gtk_window_accessible_parent_class)->notify_gtk (obj, pspec);
+ GTK_WIDGET_ACCESSIBLE_CLASS (_gtk_window_accessible_parent_class)->notify_gtk (obj, pspec);
}
static gboolean
if (!GTK_IS_WINDOW (widget) && !GTK_IS_HANDLE_BOX (widget))
return;
- ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->initialize (obj, data);
+ ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "window_state_event", G_CALLBACK (window_state_event_cb), NULL);
- gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_WINDOW);
+ _gtk_widget_accessible_set_layer (GTK_WIDGET_ACCESSIBLE (obj), ATK_LAYER_WINDOW);
if (GTK_IS_FILE_CHOOSER_DIALOG (widget))
obj->role = ATK_ROLE_FILE_CHOOSER;
if (widget == NULL)
return NULL;
- name = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_name (accessible);
+ name = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->get_name (accessible);
if (name != NULL)
return name;
if (widget == NULL)
return -1;
- index = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->get_index_in_parent (accessible);
+ index = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->get_index_in_parent (accessible);
if (index != -1)
return index;
if (widget == NULL)
return NULL;
- relation_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_relation_set (obj);
+ relation_set = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->ref_relation_set (obj);
if (atk_object_get_role (obj) == ATK_ROLE_TOOL_TIP)
{
if (widget == NULL)
return NULL;
- state_set = ATK_OBJECT_CLASS (gtk_window_accessible_parent_class)->ref_state_set (accessible);
+ state_set = ATK_OBJECT_CLASS (_gtk_window_accessible_parent_class)->ref_state_set (accessible);
window = GTK_WINDOW (widget);
}
static void
-gtk_window_accessible_class_init (GtkWindowAccessibleClass *klass)
+_gtk_window_accessible_class_init (GtkWindowAccessibleClass *klass)
{
GtkWidgetAccessibleClass *widget_class = (GtkWidgetAccessibleClass*)klass;
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
}
static void
-gtk_window_accessible_init (GtkWindowAccessible *accessible)
+_gtk_window_accessible_init (GtkWindowAccessible *accessible)
{
}
G_BEGIN_DECLS
-#define GTK_TYPE_WINDOW_ACCESSIBLE (gtk_window_accessible_get_type ())
+#define GTK_TYPE_WINDOW_ACCESSIBLE (_gtk_window_accessible_get_type ())
#define GTK_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WINDOW_ACCESSIBLE, GtkWindowAccessible))
#define GTK_WINDOW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW_ACCESSIBLE, GtkWindowAccessibleClass))
#define GTK_IS_WINDOW_ACCESSIBLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WINDOW_ACCESSIBLE))
GtkContainerAccessibleClass parent_class;
};
-GType gtk_window_accessible_get_type (void);
+GType _gtk_window_accessible_get_type (void);
G_END_DECLS
projects / ~andy / gtk / commitdiff