static void
flip (GtkButton *button)
{
GSList *l;
gtk_orientable_set_orientation (GTK_ORIENTABLE (flipbox), 1 - gtk_orientable_get_orientation (GTK_ORIENTABLE (flipbox)));
for (l = scales; l; l = l->next)
{
GtkOrientable *o = l->data;
gtk_orientable_set_orientation (o, 1 - gtk_orientable_get_orientation (o));
}
}
int
_gtk_paned_get_position2 (GtkPaned *paned)
{
int pos;
GtkWidget *w;
GtkRequisition requisition;
int size;
if (! GTK_WIDGET_VISIBLE (paned))
return 0;
pos = gtk_paned_get_position (paned);
if (pos == 0)
return 0;
w = gtk_widget_get_toplevel (GTK_WIDGET (paned));
if (! GTK_WIDGET_TOPLEVEL (w))
return 0;
gtk_window_get_size (GTK_WINDOW (w), &(requisition.width), &(requisition.height));
if (gtk_orientable_get_orientation (GTK_ORIENTABLE (paned)) == GTK_ORIENTATION_HORIZONTAL)
size = requisition.width;
else
size = requisition.height;
if (size == 0)
return 0;
return size - pos;
}
/**
* gucharmap_charmap_get_orientation:
* @charmap:
*
* Deprecated: 2.25.0
*/
GtkOrientation
gucharmap_charmap_get_orientation (GucharmapCharmap *charmap)
{
g_return_val_if_fail (GUCHARMAP_IS_CHARMAP (charmap), GTK_ORIENTATION_HORIZONTAL);
return gtk_orientable_get_orientation (GTK_ORIENTABLE (charmap));
}
cpufreq_applet_size_request (GtkWidget *widget, GtkRequisition *requisition)
#endif
{
CPUFreqApplet *applet;
gint labels_width = 0;
gint width;
applet = CPUFREQ_APPLET (widget);
#if !GTK_CHECK_VERSION (3, 0, 0)
GTK_WIDGET_CLASS (cpufreq_applet_parent_class)->size_request (widget, requisition);
#endif
if (applet->orient == MATE_PANEL_APPLET_ORIENT_LEFT ||
applet->orient == MATE_PANEL_APPLET_ORIENT_RIGHT)
return;
if (applet->show_freq) {
labels_width += cpufreq_applet_get_max_label_width (applet) + 2;
}
if (applet->show_perc) {
labels_width += cpufreq_applet_get_max_perc_width (applet);
}
if (applet->show_unit) {
labels_width += cpufreq_applet_get_max_unit_width (applet);
}
if (applet->show_icon) {
#if GTK_CHECK_VERSION (3, 0, 0)
gint icon_width;
gtk_widget_get_preferred_width (applet->icon, &icon_width, NULL);
width = gtk_orientable_get_orientation (GTK_ORIENTABLE (applet->box)) == GTK_ORIENTATION_HORIZONTAL ?
labels_width + icon_width + 2 :
MAX (labels_width, icon_width + 2);
#else
GtkRequisition req;
gtk_widget_size_request (applet->icon, &req);
width = GTK_IS_HBOX (applet->box) ?
labels_width + req.width + 2 :
MAX (labels_width, req.width + 2);
#endif
} else {
width = labels_width;
}
#if GTK_CHECK_VERSION (3, 0, 0)
*minimum_width = *natural_width = width;
#else
requisition->width = width;
#endif
}
/* This function is the default implementation for the notify_gtk
* vfunc which gets called when a property changes value on the
* GtkWidget associated with a GtkWidgetAccessible. It constructs
* an AtkPropertyValues structure and emits a "property_changed"
* signal which causes the user specified AtkPropertyChangeHandler
* to be called.
*/
static void
gtk_widget_accessible_notify_gtk (GObject *obj,
GParamSpec *pspec)
{
GtkWidget* widget = GTK_WIDGET (obj);
AtkObject* atk_obj = gtk_widget_get_accessible (widget);
AtkState state;
gboolean value;
if (g_strcmp0 (pspec->name, "has-focus") == 0)
/*
* We use focus-in-event and focus-out-event signals to catch
* focus changes so we ignore this.
*/
return;
else if (g_strcmp0 (pspec->name, "tooltip-text") == 0)
{
gtk_widget_accessible_update_tooltip (GTK_WIDGET_ACCESSIBLE (atk_obj),
widget);
return;
}
else if (g_strcmp0 (pspec->name, "visible") == 0)
{
state = ATK_STATE_VISIBLE;
value = gtk_widget_get_visible (widget);
}
else if (g_strcmp0 (pspec->name, "sensitive") == 0)
{
state = ATK_STATE_SENSITIVE;
value = gtk_widget_get_sensitive (widget);
}
else if (g_strcmp0 (pspec->name, "orientation") == 0 &&
GTK_IS_ORIENTABLE (widget))
{
GtkOrientable *orientable;
orientable = GTK_ORIENTABLE (widget);
state = ATK_STATE_HORIZONTAL;
value = (gtk_orientable_get_orientation (orientable) == GTK_ORIENTATION_HORIZONTAL);
}
else
return;
atk_object_notify_state_change (atk_obj, state, value);
if (state == ATK_STATE_SENSITIVE)
atk_object_notify_state_change (atk_obj, ATK_STATE_ENABLED, value);
if (state == ATK_STATE_HORIZONTAL)
atk_object_notify_state_change (atk_obj, ATK_STATE_VERTICAL, !value);
}
static int orientation_member(lua_State *L)
{
lua_box box;
luaA_to(L,lua_box,&box,1);
dt_lua_orientation_t orientation;
if(lua_gettop(L) > 2) {
luaA_to(L,dt_lua_orientation_t,&orientation,3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(box->widget),orientation);
return 0;
}
orientation = gtk_orientable_get_orientation(GTK_ORIENTABLE(box->widget));
luaA_push(L,dt_lua_orientation_t,&orientation);
return 1;
}
/* test that g_object_new keeps the provided area */
static void
test_iconview_object_new (void)
{
GtkWidget *view;
GtkCellArea *area;
area = gtk_cell_area_box_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (area), GTK_ORIENTATION_HORIZONTAL);
view = g_object_new (GTK_TYPE_ICON_VIEW, "cell-area", area, NULL);
g_assert (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (view)) == area);
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == gtk_icon_view_get_item_orientation (GTK_ICON_VIEW (view)));
g_object_ref_sink (view);
g_object_unref (view);
}
/* test that we have a cell area after new() */
static void
test_iconview_new (void)
{
GtkWidget *view;
GtkCellArea *area;
view = gtk_icon_view_new ();
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (view));
g_assert (GTK_IS_CELL_AREA_BOX (area));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == gtk_icon_view_get_item_orientation (GTK_ICON_VIEW (view)));
g_object_ref_sink (view);
g_object_unref (view);
}
/* test we can access the area in subclass init */
static void
test_completion_subclass2 (void)
{
GtkEntryCompletion *c;
GtkCellArea *area;
subclass_init = 1;
c = g_object_new (my_entry_completion_get_type (), NULL);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (c));
g_assert (GTK_IS_CELL_AREA_BOX (area));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_VERTICAL);
g_object_ref_sink (c);
g_object_unref (c);
}
/* test that a completion subclass keeps the provided area */
static void
test_completion_subclass1 (void)
{
GtkEntryCompletion *c;
GtkCellArea *area;
subclass_init = 0;
area = gtk_cell_area_box_new ();
c = g_object_new (my_entry_completion_get_type (), "cell-area", area, NULL);
g_assert (area == gtk_cell_layout_get_area (GTK_CELL_LAYOUT (c)));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_HORIZONTAL);
g_object_ref_sink (c);
g_object_unref (c);
}
/* test we can access the area in subclass init */
static void
test_column_subclass2 (void)
{
GtkTreeViewColumn *col;
GtkCellArea *area;
subclass_init = 1;
col = g_object_new (my_tree_view_column_get_type (), NULL);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (col));
g_assert (GTK_IS_CELL_AREA_BOX (area));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_VERTICAL);
g_object_ref_sink (col);
g_object_unref (col);
}
/* test that a column subclass keeps the provided area */
static void
test_column_subclass1 (void)
{
GtkTreeViewColumn *col;
GtkCellArea *area;
subclass_init = 0;
area = gtk_cell_area_box_new ();
col = g_object_new (my_tree_view_column_get_type (), "cell-area", area, NULL);
g_assert (area == gtk_cell_layout_get_area (GTK_CELL_LAYOUT (col)));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_HORIZONTAL);
g_object_ref_sink (col);
g_object_unref (col);
}
/* test we can access the area in subclass init */
static void
test_cellview_subclass2 (void)
{
GtkWidget *view;
GtkCellArea *area;
subclass_init = 1;
view = g_object_new (my_cell_view_get_type (), NULL);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (view));
g_assert (GTK_IS_CELL_AREA_BOX (area));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_VERTICAL);
g_object_ref_sink (view);
g_object_unref (view);
}
/* test that a cellview subclass keeps the provided area */
static void
test_cellview_subclass1 (void)
{
GtkWidget *view;
GtkCellArea *area;
subclass_init = 0;
area = gtk_cell_area_box_new ();
view = g_object_new (my_cell_view_get_type (), "cell-area", area, NULL);
g_assert (area == gtk_cell_layout_get_area (GTK_CELL_LAYOUT (view)));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_HORIZONTAL);
g_object_ref_sink (view);
g_object_unref (view);
}
static void
my_icon_view_init (MyIconView *view)
{
GtkCellArea *area;
if (subclass_init == 0)
{
/* do nothing to area */
}
else if (subclass_init == 1)
{
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (view));
g_assert (GTK_IS_CELL_AREA_BOX (area));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_VERTICAL);
gtk_orientable_set_orientation (GTK_ORIENTABLE (area), GTK_ORIENTATION_HORIZONTAL);
}
}
void
_gtk_paned_set_position2 (GtkPaned *paned,
int pos)
{
GtkWidget *top_level;
int size;
top_level = gtk_widget_get_toplevel (GTK_WIDGET (paned));
if (! GTK_WIDGET_TOPLEVEL (top_level))
return;
if (gtk_orientable_get_orientation (GTK_ORIENTABLE (paned)) == GTK_ORIENTATION_HORIZONTAL)
size = top_level->allocation.width;
else
size = top_level->allocation.height;
if (pos > 0)
gtk_paned_set_position (paned, size - pos);
}
static void
brasero_file_chooser_find_pane (GtkWidget *child,
gpointer footer)
{
if (GTK_IS_PANED (child)) {
GList *children_vbox;
GList *iter_vbox;
GtkWidget *vbox;
vbox = gtk_paned_get_child2 (GTK_PANED (child));
children_vbox = gtk_container_get_children (GTK_CONTAINER (vbox));
for (iter_vbox = children_vbox; iter_vbox; iter_vbox = iter_vbox->next) {
if (GTK_IS_BOX (iter_vbox->data) &&
gtk_orientable_get_orientation (GTK_ORIENTABLE (iter_vbox->data)) == GTK_ORIENTATION_HORIZONTAL) {
GtkPackType packing;
gtk_box_query_child_packing (GTK_BOX (vbox),
GTK_WIDGET (iter_vbox->data),
NULL,
NULL,
NULL,
&packing);
if (packing == GTK_PACK_START) {
GtkRequisition total_request, footer_request;
gtk_widget_get_preferred_size (GTK_WIDGET (vbox),
&total_request, NULL);
gtk_widget_get_preferred_size (GTK_WIDGET (iter_vbox->data),
&footer_request, NULL);
*((gint *) footer) = total_request.height - footer_request.height;
break;
}
}
}
g_list_free (children_vbox);
}
else if (GTK_IS_CONTAINER (child)) {
gtk_container_foreach (GTK_CONTAINER (child),
brasero_file_chooser_find_pane,
footer);
}
}
/* panel_window_get_orientation */
GtkOrientation panel_window_get_orientation(PanelWindow * panel)
{
#if GTK_CHECK_VERSION(2, 16, 0)
if(panel->box != NULL)
return gtk_orientable_get_orientation(GTK_ORIENTABLE(
panel->box));
#endif
switch(panel->position)
{
case PANEL_WINDOW_POSITION_LEFT:
case PANEL_WINDOW_POSITION_RIGHT:
return GTK_ORIENTATION_VERTICAL;
case PANEL_WINDOW_POSITION_BOTTOM:
case PANEL_WINDOW_POSITION_CENTER:
case PANEL_WINDOW_POSITION_FLOATING:
case PANEL_WINDOW_POSITION_MANAGED:
case PANEL_WINDOW_POSITION_TOP:
default:
return GTK_ORIENTATION_HORIZONTAL;
}
}
static void
cpufreq_applet_get_preferred_width (GtkWidget *widget,
gint *minimum_width,
gint *natural_width)
{
CPUFreqApplet *applet;
gint labels_width = 0;
gint width;
applet = CPUFREQ_APPLET (widget);
if (applet->orient == PANEL_APPLET_ORIENT_LEFT ||
applet->orient == PANEL_APPLET_ORIENT_RIGHT)
return;
if (applet->show_freq) {
labels_width += cpufreq_applet_get_max_label_width (applet) + 2;
}
if (applet->show_perc) {
labels_width += cpufreq_applet_get_max_perc_width (applet);
}
if (applet->show_unit) {
labels_width += cpufreq_applet_get_max_unit_width (applet);
}
if (applet->show_icon) {
gint icon_width;
gtk_widget_get_preferred_width (applet->icon, &icon_width, NULL);
width = gtk_orientable_get_orientation (GTK_ORIENTABLE (applet->box)) == GTK_ORIENTATION_HORIZONTAL ?
labels_width + icon_width + 2 :
MAX (labels_width, icon_width + 2);
} else {
width = labels_width;
}
*minimum_width = *natural_width = width;
}
/* test we get a warning if an area is provided, but ignored */
static void
test_completion_subclass3 (void)
{
subclass_init = 1;
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
{
GtkEntryCompletion *c;
GtkCellArea *area;
area = gtk_cell_area_box_new ();
c = g_object_new (my_entry_completion_get_type (), "cell-area", area, NULL);
g_assert (area == gtk_cell_layout_get_area (GTK_CELL_LAYOUT (c)));
g_assert (gtk_orientable_get_orientation (GTK_ORIENTABLE (area)) == GTK_ORIENTATION_VERTICAL);
g_object_ref_sink (c);
g_object_unref (c);
exit (0);
}
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*ignoring construct property*");
}
static void
gth_auto_paned_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GthAutoPaned *self = GTH_AUTO_PANED (widget);
GtkWidget *child1;
GtkWidget *child2;
gboolean reset_position;
child1 = gtk_paned_get_child1 (GTK_PANED (self));
child2 = gtk_paned_get_child2 (GTK_PANED (self));
reset_position = FALSE;
if ((self->priv->child1_visible != _gtk_widget_get_visible (child1))
|| (self->priv->child2_visible != _gtk_widget_get_visible (child2)))
{
reset_position = TRUE;
self->priv->child1_visible = _gtk_widget_get_visible (child1);
self->priv->child2_visible = _gtk_widget_get_visible (child2);
}
if (reset_position) {
int position;
switch (gtk_orientable_get_orientation (GTK_ORIENTABLE (self))) {
case GTK_ORIENTATION_HORIZONTAL:
position = allocation->width / 2;
break;
case GTK_ORIENTATION_VERTICAL:
position = allocation->height / 2;
break;
}
gtk_paned_set_position (GTK_PANED (self), position);
}
GTK_WIDGET_CLASS (gth_auto_paned_parent_class)->size_allocate (widget, allocation);
}
static gboolean
glade_gtk_box_configure_child (GladeFixed * fixed,
GladeWidget * child,
GdkRectangle * rect, GtkWidget * box)
{
GList *list, *children;
GtkWidget *bchild;
GtkAllocation allocation, bchild_allocation;
gint point, trans_point, span,
iter_span, position, old_position, offset, orig_offset;
gboolean found = FALSE;
gtk_widget_get_allocation (GTK_WIDGET (glade_widget_get_object (child)), &allocation);
if (gtk_orientable_get_orientation (GTK_ORIENTABLE (box)) == GTK_ORIENTATION_HORIZONTAL)
{
point = fixed->mouse_x;
span = allocation.width;
offset = rect->x;
orig_offset = fixed->child_x_origin;
}
else
{
point = fixed->mouse_y;
span = allocation.height;
offset = rect->y;
orig_offset = fixed->child_y_origin;
}
glade_widget_pack_property_get (child, "position", &old_position);
children = gtk_container_get_children (GTK_CONTAINER (box));
for (list = children; list; list = list->next)
{
bchild = list->data;
if (bchild == GTK_WIDGET (glade_widget_get_object (child)))
continue;
/* Find the widget in the box where the center of
* this rectangle fits... and set the position to that
* position.
*/
gtk_widget_get_allocation (GTK_WIDGET (bchild), &bchild_allocation);
if (gtk_orientable_get_orientation (GTK_ORIENTABLE (box)) == GTK_ORIENTATION_HORIZONTAL)
{
gtk_widget_translate_coordinates
(GTK_WIDGET (box), bchild, point, 0, &trans_point, NULL);
iter_span = bchild_allocation.width;
}
else
{
gtk_widget_translate_coordinates
(GTK_WIDGET (box), bchild, 0, point, NULL, &trans_point);
iter_span = bchild_allocation.height;
}
#if 0
gtk_container_child_get (GTK_CONTAINER (box),
bchild, "position", &position, NULL);
g_print ("widget: %p pos %d, point %d, trans_point %d, iter_span %d\n",
bchild, position, point, trans_point, iter_span);
#endif
if (iter_span <= span)
{
found = trans_point >= 0 && trans_point < iter_span;
}
else
{
if (offset > orig_offset)
found = trans_point >= iter_span - span && trans_point < iter_span;
else if (offset < orig_offset)
found = trans_point >= 0 && trans_point < span;
}
if (found)
{
gtk_container_child_get (GTK_CONTAINER (box),
bchild, "position", &position, NULL);
#if 0
g_print ("setting position of %s from %d to %d, "
"(point %d iter_span %d)\n",
glade_widget_get_name (child), old_position, position, trans_point, iter_span);
#endif
glade_widget_pack_property_set (child, "position", position);
break;
}
}
g_list_free (children);
return TRUE;
}
static void
task_manager_dalog_disp_preview (TaskManagerDialog *dialog)
{
gint height;
gint width;
gint data_length;
gint win_x,win_y,win_width,win_height;
GtkAllocation allocation;
GList * iter = NULL;
gint win_count = 0;
int i = 0;
TaskManagerDialogPrivate * priv = GET_PRIVATE (dialog);
GtkPositionType pos_type = awn_applet_get_pos_type (priv->applet);
GtkOrientation current_orientation;
gdouble scale;
glong total_width = 0;
glong screen_width = gdk_screen_get_width (gdk_screen_get_default ());
glong screen_height = gdk_screen_get_height (gdk_screen_get_default ());
current_orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->items_box));
if ( (current_orientation == GTK_ORIENTATION_VERTICAL) &&
(( pos_type == GTK_POS_BOTTOM) || (pos_type == GTK_POS_TOP)) )
{
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->items_box),GTK_ORIENTATION_HORIZONTAL);
}
else if ( (current_orientation == GTK_ORIENTATION_HORIZONTAL)&&
(( pos_type == GTK_POS_LEFT) || (pos_type == GTK_POS_RIGHT)) )
{
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->items_box),GTK_ORIENTATION_VERTICAL);
}
for (iter = g_list_first(priv->children); iter; iter=iter->next)
{
if (TASK_IS_WINDOW(iter->data))
{
win_count++;
}
}
if (priv->data)
{
g_free (priv->data);
}
data_length = win_count*6 +1;
priv->data = g_new0 (long, data_length);
priv->data[0] = (long) win_count;
scale = priv->dialog_scale;
scaled_down:
total_width = 0;
if (screen_width && screen_height)
{
for (iter = g_list_first(priv->children); iter; iter=iter->next)
{
if (TASK_IS_WINDOW(iter->data))
{
wnck_window_get_geometry (task_window_get_window (iter->data),
&win_x,
&win_y,
&win_width,
&win_height);
gtk_widget_get_allocation (GTK_WIDGET(iter->data), &allocation);
if ((pos_type == GTK_POS_TOP) || (pos_type == GTK_POS_BOTTOM))
{
/*conditional operator alert*/
height = gdk_screen_height () / (win_count?1.0/scale:1.0/scale+(win_count-2));
width = ((float)win_width) / ((float)win_height) * height;
total_width = total_width + width;
if (total_width > screen_width * 0.9)
{
scale = scale * 0.9;
goto scaled_down;
}
}
else
{
/*conditional operator alert*/
width = gdk_screen_width () / (win_count<4?1.0/scale+1:1.0/scale+1+(win_count-3));
height = ((float)win_height) / ((float)win_width) * width;
total_width = total_width + height;
if (total_width > screen_height * 0.9)
{
scale = scale * 0.9;
goto scaled_down;
}
}
}
}
}
for (iter = g_list_first(priv->children); iter; iter=iter->next)
{
if (TASK_IS_WINDOW(iter->data))
{
wnck_window_get_geometry (task_window_get_window (iter->data),
&win_x,
&win_y,
&win_width,
&win_height);
gtk_widget_get_allocation (GTK_WIDGET(iter->data), &allocation);
gtk_widget_set_tooltip_text (GTK_WIDGET (iter->data),
task_window_get_name(TASK_WINDOW(iter->data)));
/* Change these calculations. Ultimately we can be much smarter about
layout. After a certain point it will involve adding some more
containers in our container....*/
if ((pos_type == GTK_POS_TOP) || (pos_type == GTK_POS_BOTTOM))
{
/*conditional operator alert*/
height = gdk_screen_height () / (win_count?1.0/scale:1.0/scale+(win_count-2));
width = ((float)win_width) / ((float)win_height) * height;
gtk_widget_set_size_request (GTK_WIDGET(iter->data), width, height);
}
else
{
/*conditional operator alert*/
width = gdk_screen_width () / (win_count<4?1.0/scale+1:1.0/scale+1+(win_count-3));
height = ((float)win_height) / ((float)win_width) * width;
gtk_widget_set_size_request (GTK_WIDGET(iter->data), width, height);
}
priv->data[i*6+1] = (long) 5;
priv->data[i*6+2] = (long) task_window_get_xid (TASK_WINDOW(iter->data));
priv->data[i*6+3] = (long) allocation.x+4;
priv->data[i*6+4] = (long) allocation.y+4;
priv->data[i*6+5] = (long) width-8;
priv->data[i*6+6] = (long) height-8;
i++;
}
}
gdk_property_change ((GTK_WIDGET(dialog))->window,
priv->kde_a,
priv->kde_a,
32,
GDK_PROP_MODE_REPLACE,
(guchar*) priv->data,
data_length);
}
static AtkStateSet *
gtk_widget_accessible_ref_state_set (AtkObject *accessible)
{
GtkWidget *widget;
AtkStateSet *state_set;
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)
atk_state_set_add_state (state_set, ATK_STATE_DEFUNCT);
else
{
if (gtk_widget_is_sensitive (widget))
{
atk_state_set_add_state (state_set, ATK_STATE_SENSITIVE);
atk_state_set_add_state (state_set, ATK_STATE_ENABLED);
}
if (gtk_widget_get_can_focus (widget))
{
atk_state_set_add_state (state_set, ATK_STATE_FOCUSABLE);
}
/*
* We do not currently generate notifications when an ATK object
* corresponding to a GtkWidget changes visibility by being scrolled
* on or off the screen. The testcase for this is the main window
* of the testgtk application in which a set of buttons in a GtkVBox
* is in a scrolled window with a viewport.
*
* To generate the notifications we would need to do the following:
* 1) Find the GtkViewport among the ancestors of the objects
* 2) Create an accessible for the viewport
* 3) Connect to the value-changed signal on the viewport
* 4) When the signal is received we need to traverse the children
* of the viewport and check whether the children are visible or not
* visible; we may want to restrict this to the widgets for which
* accessible objects have been created.
* 5) We probably need to store a variable on_screen in the
* GtkWidgetAccessible data structure so we can determine whether
* the value has changed.
*/
if (gtk_widget_get_visible (widget))
{
atk_state_set_add_state (state_set, ATK_STATE_VISIBLE);
if (gtk_widget_accessible_on_screen (widget) &&
gtk_widget_get_mapped (widget) &&
gtk_widget_accessible_all_parents_visible (widget))
atk_state_set_add_state (state_set, ATK_STATE_SHOWING);
}
if (gtk_widget_has_focus (widget) && (widget == _focus_widget))
{
AtkObject *focus_obj;
focus_obj = g_object_get_data (G_OBJECT (accessible), "gail-focus-object");
if (focus_obj == NULL)
atk_state_set_add_state (state_set, ATK_STATE_FOCUSED);
}
if (gtk_widget_has_default (widget))
atk_state_set_add_state (state_set, ATK_STATE_DEFAULT);
if (GTK_IS_ORIENTABLE (widget))
{
if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL)
atk_state_set_add_state (state_set, ATK_STATE_HORIZONTAL);
else
atk_state_set_add_state (state_set, ATK_STATE_VERTICAL);
}
}
return state_set;
}
