AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

geez, don't call g_list funcs on GSList

Browse Source 
2001-06-08  Havoc Pennington  <hp@redhat.com>

	* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
	don't call g_list funcs on GSList

	* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
	gtk_container_focus(), since some widgets have focusable locations
	which are not other widgets. These widgets should not have to be
	containers just to manage the focus. For example, GtkHSV is
	currently a container for no good reason. Also, this cleans
	up the "if (is_container && is_sensitive && is_drawable)
	container_focus ()" mess in widget implementations.

	* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
	function, and have it just call gtk_widget_child_focus().

	* gtk/gtkhsv.c: derive from widget not container

	Throughout: fix to reflect GtkContainer::focus change
This commit is contained in:
Havoc Pennington 2001-06-08 18:09:34 +00:00 committed by Havoc Pennington
parent 72ef055bde
commit 74e7da214f
28 changed files with 396 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ChangeLog
View File

@ -1,3 +1,23 @@
2001-06-08 Havoc Pennington <hp@redhat.com>
* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
don't call g_list funcs on GSList
* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
gtk_container_focus(), since some widgets have focusable locations
which are not other widgets. These widgets should not have to be
containers just to manage the focus. For example, GtkHSV is
currently a container for no good reason. Also, this cleans
up the "if (is_container && is_sensitive && is_drawable)
container_focus ()" mess in widget implementations.
* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
function, and have it just call gtk_widget_child_focus().
* gtk/gtkhsv.c: derive from widget not container
Throughout: fix to reflect GtkContainer::focus change
Fri Jun 8 12:38:49 2001 Jonathan Blandford <jrb@redhat.com>
* gtk/gtktable.c (gtk_table_resize): warn if row/cols are out of

20
ChangeLog.pre-2-0
View File

@ -1,3 +1,23 @@
2001-06-08 Havoc Pennington <hp@redhat.com>
* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
don't call g_list funcs on GSList
* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
gtk_container_focus(), since some widgets have focusable locations
which are not other widgets. These widgets should not have to be
containers just to manage the focus. For example, GtkHSV is
currently a container for no good reason. Also, this cleans
up the "if (is_container && is_sensitive && is_drawable)
container_focus ()" mess in widget implementations.
* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
function, and have it just call gtk_widget_child_focus().
* gtk/gtkhsv.c: derive from widget not container
Throughout: fix to reflect GtkContainer::focus change
Fri Jun 8 12:38:49 2001 Jonathan Blandford <jrb@redhat.com>
* gtk/gtktable.c (gtk_table_resize): warn if row/cols are out of

20
ChangeLog.pre-2-10
View File

@ -1,3 +1,23 @@
2001-06-08 Havoc Pennington <hp@redhat.com>
* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
don't call g_list funcs on GSList
* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
gtk_container_focus(), since some widgets have focusable locations
which are not other widgets. These widgets should not have to be
containers just to manage the focus. For example, GtkHSV is
currently a container for no good reason. Also, this cleans
up the "if (is_container && is_sensitive && is_drawable)
container_focus ()" mess in widget implementations.
* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
function, and have it just call gtk_widget_child_focus().
* gtk/gtkhsv.c: derive from widget not container
Throughout: fix to reflect GtkContainer::focus change
Fri Jun 8 12:38:49 2001 Jonathan Blandford <jrb@redhat.com>
* gtk/gtktable.c (gtk_table_resize): warn if row/cols are out of

20
ChangeLog.pre-2-2
View File

@ -1,3 +1,23 @@
2001-06-08 Havoc Pennington <hp@redhat.com>
* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
don't call g_list funcs on GSList
* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
gtk_container_focus(), since some widgets have focusable locations
which are not other widgets. These widgets should not have to be
containers just to manage the focus. For example, GtkHSV is
currently a container for no good reason. Also, this cleans
up the "if (is_container && is_sensitive && is_drawable)
container_focus ()" mess in widget implementations.
* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
function, and have it just call gtk_widget_child_focus().
* gtk/gtkhsv.c: derive from widget not container
Throughout: fix to reflect GtkContainer::focus change
Fri Jun 8 12:38:49 2001 Jonathan Blandford <jrb@redhat.com>
* gtk/gtktable.c (gtk_table_resize): warn if row/cols are out of

20
ChangeLog.pre-2-4
View File

@ -1,3 +1,23 @@
2001-06-08 Havoc Pennington <hp@redhat.com>
* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
don't call g_list funcs on GSList
* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
gtk_container_focus(), since some widgets have focusable locations
which are not other widgets. These widgets should not have to be
containers just to manage the focus. For example, GtkHSV is
currently a container for no good reason. Also, this cleans
up the "if (is_container && is_sensitive && is_drawable)
container_focus ()" mess in widget implementations.
* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
function, and have it just call gtk_widget_child_focus().
* gtk/gtkhsv.c: derive from widget not container
Throughout: fix to reflect GtkContainer::focus change
Fri Jun 8 12:38:49 2001 Jonathan Blandford <jrb@redhat.com>
* gtk/gtktable.c (gtk_table_resize): warn if row/cols are out of

20
ChangeLog.pre-2-6
View File

@ -1,3 +1,23 @@
2001-06-08 Havoc Pennington <hp@redhat.com>
* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
don't call g_list funcs on GSList
* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
gtk_container_focus(), since some widgets have focusable locations
which are not other widgets. These widgets should not have to be
containers just to manage the focus. For example, GtkHSV is
currently a container for no good reason. Also, this cleans
up the "if (is_container && is_sensitive && is_drawable)
container_focus ()" mess in widget implementations.
* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
function, and have it just call gtk_widget_child_focus().
* gtk/gtkhsv.c: derive from widget not container
Throughout: fix to reflect GtkContainer::focus change
Fri Jun 8 12:38:49 2001 Jonathan Blandford <jrb@redhat.com>
* gtk/gtktable.c (gtk_table_resize): warn if row/cols are out of

20
ChangeLog.pre-2-8
View File

@ -1,3 +1,23 @@
2001-06-08 Havoc Pennington <hp@redhat.com>
* gtk/gtktextbuffer.c (gtk_text_buffer_remove_all_tags): geez,
don't call g_list funcs on GSList
* gtk/gtkwidget.c (gtk_widget_child_focus): replaces
gtk_container_focus(), since some widgets have focusable locations
which are not other widgets. These widgets should not have to be
containers just to manage the focus. For example, GtkHSV is
currently a container for no good reason. Also, this cleans
up the "if (is_container && is_sensitive && is_drawable)
container_focus ()" mess in widget implementations.
* gtk/gtkcontainer.c (gtk_container_focus): deprecate this
function, and have it just call gtk_widget_child_focus().
* gtk/gtkhsv.c: derive from widget not container
Throughout: fix to reflect GtkContainer::focus change
Fri Jun 8 12:38:49 2001 Jonathan Blandford <jrb@redhat.com>
* gtk/gtktable.c (gtk_table_resize): warn if row/cols are out of

13
docs/Changes-2.0.txt
View File

@ -352,3 +352,16 @@ Incompatible Changes from GTK+-1.2 to GTK+-2.0:
these widgets will need a rewrite (though if you could figure out
how to subclass the old version of GtkRange, you have our
respect). Also, GtkTroughType is gone.
* The GtkContainer::focus signal/virtualfunction and
gtk_container_focus() call were replaced by
GtkWidget::focus and gtk_widget_child_focus().
The semantics are the same, so you should be able to just
replace "container_class->focus = mywidget_focus" with
"widget_class->focus = mywidget_focus" and replace
gtk_container_focus() calls with gtk_widget_child_focus() calls.
The purpose of this change was to allow non-containers to have
focusable elements.

9
docs/reference/gtk/tmpl/gtk-unused.sgml
View File

@ -361,6 +361,15 @@ Define a function pointer. Deprecated.
@arg:
@arg_id:
<!-- ##### SIGNAL GtkContainer::focus ##### -->
<para>
</para>
@container: the object which received the signal.
@direction:
@Returns:
<!-- ##### ARG GtkContainer:reallocate-redraws ##### -->
<para>

9
docs/reference/gtk/tmpl/gtkcontainer.sgml
View File

@ -382,15 +382,6 @@ GtkContainer
@container: the object which received the signal.
<!-- ##### SIGNAL GtkContainer::focus ##### -->
<para>
</para>
@container: the object which received the signal.
@direction:
@Returns:
<!-- ##### SIGNAL GtkContainer::remove ##### -->
<para>

9
docs/reference/gtk/tmpl/gtkwidget.sgml
View File

@ -1530,6 +1530,15 @@ GtkWidget
@event:
@Returns:
<!-- ##### SIGNAL GtkWidget::focus ##### -->
<para>
</para>
@widget: the object which received the signal.
@arg1:
@Returns:
<!-- ##### SIGNAL GtkWidget::focus-in-event ##### -->
<para>

24
gtk/gtkclist.c
View File

@ -216,7 +216,7 @@ static gint gtk_clist_focus_in (GtkWidget *widget,
GdkEventFocus *event);
static gint gtk_clist_focus_out (GtkWidget *widget,
GdkEventFocus *event);
static gint gtk_clist_focus (GtkContainer *container,
static gint gtk_clist_focus (GtkWidget *widget,
GtkDirectionType direction);
static void gtk_clist_set_focus_child (GtkContainer *container,
GtkWidget *child);
@ -530,12 +530,12 @@ gtk_clist_class_init (GtkCListClass *klass)
widget_class->drag_drop = gtk_clist_drag_drop;
widget_class->drag_data_get = gtk_clist_drag_data_get;
widget_class->drag_data_received = gtk_clist_drag_data_received;
widget_class->focus = gtk_clist_focus;
/* container_class->add = NULL; use the default GtkContainerClass warning */
/* container_class->remove=NULL; use the default GtkContainerClass warning */
container_class->forall = gtk_clist_forall;
container_class->focus = gtk_clist_focus;
container_class->set_focus_child = gtk_clist_set_focus_child;
klass->set_scroll_adjustments = gtk_clist_set_scroll_adjustments;
@ -6402,23 +6402,22 @@ gtk_clist_focus_content_area (GtkCList *clist)
}
static gboolean
gtk_clist_focus (GtkContainer *container,
gtk_clist_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkCList *clist = GTK_CLIST (container);
GtkWidget *focus_child = container->focus_child;
GtkCList *clist = GTK_CLIST (widget);
GtkWidget *focus_child;
gboolean is_current_focus;
if (!GTK_WIDGET_IS_SENSITIVE (container))
if (!GTK_WIDGET_IS_SENSITIVE (widget))
return FALSE;
focus_child = GTK_CONTAINER (widget)->focus_child;
is_current_focus = gtk_widget_is_focus (GTK_WIDGET (clist));
if (focus_child &&
GTK_IS_CONTAINER (focus_child) &&
GTK_WIDGET_DRAWABLE (focus_child) &&
GTK_WIDGET_IS_SENSITIVE (focus_child) &&
gtk_container_focus (GTK_CONTAINER (focus_child), direction))
gtk_widget_child_focus (focus_child, direction))
return TRUE;
switch (direction)
@ -6562,8 +6561,7 @@ focus_column (GtkCList *clist, gint column, gint dir)
{
GtkWidget *child = clist->column[column].button;
if (GTK_IS_CONTAINER (child) &&
gtk_container_focus (GTK_CONTAINER (child), dir))
if (gtk_widget_child_focus (child, dir))
{
return TRUE;
}

59
gtk/gtkcontainer.c
View File

@ -39,7 +39,6 @@ enum {
ADD,
REMOVE,
CHECK_RESIZE,
FOCUS,
SET_FOCUS_CHILD,
LAST_SIGNAL
};
@ -79,7 +78,7 @@ static void gtk_container_add_unimplemented (GtkContainer *container
static void gtk_container_remove_unimplemented (GtkContainer *container,
GtkWidget *widget);
static void gtk_container_real_check_resize (GtkContainer *container);
static gboolean gtk_container_real_focus (GtkContainer *container,
static gboolean gtk_container_focus (GtkWidget *widget,
GtkDirectionType direction);
static void gtk_container_real_set_focus_child (GtkContainer *container,
GtkWidget *widget);
@ -205,12 +204,12 @@ gtk_container_class_init (GtkContainerClass *class)
widget_class->show_all = gtk_container_show_all;
widget_class->hide_all = gtk_container_hide_all;
widget_class->expose_event = gtk_container_expose;
widget_class->focus = gtk_container_focus;
class->add = gtk_container_add_unimplemented;
class->remove = gtk_container_remove_unimplemented;
class->check_resize = gtk_container_real_check_resize;
class->forall = NULL;
class->focus = gtk_container_real_focus;
class->set_focus_child = gtk_container_real_set_focus_child;
class->child_type = NULL;
class->composite_name = gtk_container_child_default_composite_name;
@ -238,14 +237,6 @@ gtk_container_class_init (GtkContainerClass *class)
GTK_SIGNAL_OFFSET (GtkContainerClass, check_resize),
gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
container_signals[FOCUS] =
gtk_signal_new ("focus",
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkContainerClass, focus),
gtk_marshal_ENUM__ENUM,
GTK_TYPE_DIRECTION_TYPE, 1,
GTK_TYPE_DIRECTION_TYPE);
container_signals[SET_FOCUS_CHILD] =
gtk_signal_new ("set-focus-child",
GTK_RUN_FIRST,
@ -1282,22 +1273,6 @@ gtk_container_foreach_full (GtkContainer *container,
notify (callback_data);
}
gboolean
gtk_container_focus (GtkContainer *container,
GtkDirectionType direction)
{
gint return_val;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
gtk_signal_emit (GTK_OBJECT (container),
container_signals[FOCUS],
direction, &return_val);
return return_val;
}
void
gtk_container_set_focus_child (GtkContainer *container,
GtkWidget *widget)
@ -1480,20 +1455,16 @@ filter_unfocusable (GtkContainer *container,
}
static gboolean
gtk_container_real_focus (GtkContainer *container,
GtkDirectionType direction)
gtk_container_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GList *children;
gint return_val;
GtkContainer *container;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
g_return_val_if_fail (GTK_IS_CONTAINER (widget), FALSE);
/* Fail if the container is inappropriate for focus movement
*/
if (!GTK_WIDGET_DRAWABLE (container) ||
!GTK_WIDGET_IS_SENSITIVE (container))
return FALSE;
container = GTK_CONTAINER (widget);
return_val = FALSE;
@ -1936,25 +1907,15 @@ gtk_container_focus_move (GtkContainer *container,
{
focus_child = NULL;
if (GTK_WIDGET_DRAWABLE (child) &&
GTK_IS_CONTAINER (child))
if (gtk_container_focus (GTK_CONTAINER (child), direction))
if (gtk_widget_child_focus (child, direction))
return TRUE;
}
}
else if (GTK_WIDGET_DRAWABLE (child) &&
gtk_widget_is_ancestor (child, GTK_WIDGET (container)))
{
if (GTK_IS_CONTAINER (child))
{
if (gtk_container_focus (GTK_CONTAINER (child), direction))
return TRUE;
}
else if (GTK_WIDGET_CAN_FOCUS (child))
{
gtk_widget_grab_focus (child);
return TRUE;
}
if (gtk_widget_child_focus (child, direction))
return TRUE;
}
}

9
gtk/gtkcontainer.h
View File

@ -83,9 +83,7 @@ struct _GtkContainerClass
void (* forall) (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callbabck_data);
gboolean (* focus) (GtkContainer *container,
GtkDirectionType direction);
gpointer callback_data);
void (* set_focus_child) (GtkContainer *container,
GtkWidget *widget);
GtkType (*child_type) (GtkContainer *container);
@ -129,8 +127,6 @@ void gtk_container_foreach_full (GtkContainer *container,
gpointer callback_data,
GtkDestroyNotify notify);
GList* gtk_container_children (GtkContainer *container);
gboolean gtk_container_focus (GtkContainer *container,
GtkDirectionType direction);
void gtk_container_propagate_expose (GtkContainer *container,
GtkWidget *child,
GdkEventExpose *event);
@ -203,8 +199,7 @@ void gtk_container_addv (GtkContainer *container,
void gtk_container_child_set (GtkContainer *container,
GtkWidget *child,
const gchar *first_arg_name,
...);
...);
/* Non-public methods */

17
gtk/gtkhsv.c
View File

@ -103,7 +103,7 @@ static gint gtk_hsv_motion (GtkWidget *widget,
GdkEventMotion *event);
static gint gtk_hsv_expose (GtkWidget *widget,
GdkEventExpose *event);
static gboolean gtk_hsv_focus (GtkContainer *container,
static gboolean gtk_hsv_focus (GtkWidget *widget,
GtkDirectionType direction);
static void gtk_hsv_move (GtkHSV *hsv,
@ -139,7 +139,7 @@ gtk_hsv_get_type (void)
(GtkClassInitFunc) NULL
};
hsv_type = gtk_type_unique (GTK_TYPE_CONTAINER, &hsv_info);
hsv_type = gtk_type_unique (GTK_TYPE_WIDGET, &hsv_info);
}
return hsv_type;
@ -151,13 +151,11 @@ gtk_hsv_class_init (GtkHSVClass *class)
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
GtkHSVClass *hsv_class;
GtkBindingSet *binding_set;
object_class = (GtkObjectClass *) class;
widget_class = (GtkWidgetClass *) class;
container_class = GTK_CONTAINER_CLASS (class);
hsv_class = GTK_HSV_CLASS (class);
parent_class = gtk_type_class (GTK_TYPE_WIDGET);
@ -174,8 +172,7 @@ gtk_hsv_class_init (GtkHSVClass *class)
widget_class->button_release_event = gtk_hsv_button_release;
widget_class->motion_notify_event = gtk_hsv_motion;
widget_class->expose_event = gtk_hsv_expose;
container_class->focus = gtk_hsv_focus;
widget_class->focus = gtk_hsv_focus;
hsv_class->move = gtk_hsv_move;
@ -1357,18 +1354,14 @@ gtk_hsv_expose (GtkWidget *widget,
}
static gboolean
gtk_hsv_focus (GtkContainer *container,
gtk_hsv_focus (GtkWidget *widget,
GtkDirectionType dir)
{
GtkHSV *hsv;
HSVPrivate *priv;
hsv = GTK_HSV (container);
hsv = GTK_HSV (widget);
priv = hsv->priv;
if (!GTK_WIDGET_DRAWABLE (container) ||
!GTK_WIDGET_IS_SENSITIVE (container))
return FALSE;
if (!GTK_WIDGET_HAS_FOCUS (hsv))
{

3
gtk/gtkhsv.h
View File

@ -50,8 +50,7 @@ typedef struct _GtkHSVClass GtkHSVClass;
struct _GtkHSV
{
/* we derive from container purely so we can have a _focus method */
GtkContainer parent_instance;
GtkWidget parent_instance;
/* Private data */
gpointer priv;

25
gtk/gtklist.c
View File

@ -75,6 +75,9 @@ static gint gtk_list_button_press (GtkWidget *widget,
static gint gtk_list_button_release (GtkWidget *widget,
GdkEventButton *event);
static gboolean gtk_list_focus (GtkWidget *widget,
GtkDirectionType direction);
/*** GtkContainer Methods ***/
static void gtk_list_add (GtkContainer *container,
GtkWidget *widget);
@ -87,8 +90,6 @@ static void gtk_list_forall (GtkContainer *container,
static GtkType gtk_list_child_type (GtkContainer *container);
static void gtk_list_set_focus_child (GtkContainer *container,
GtkWidget *widget);
static gint gtk_list_focus (GtkContainer *container,
GtkDirectionType direction);
/*** GtkList Private Functions ***/
static void gtk_list_move_focus_child (GtkList *list,
@ -228,13 +229,13 @@ gtk_list_class_init (GtkListClass *class)
widget_class->size_request = gtk_list_size_request;
widget_class->size_allocate = gtk_list_size_allocate;
widget_class->drag_begin = gtk_list_drag_begin;
widget_class->focus = gtk_list_focus;
container_class->add = gtk_list_add;
container_class->remove = gtk_list_remove;
container_class->forall = gtk_list_forall;
container_class->child_type = gtk_list_child_type;
container_class->set_focus_child = gtk_list_set_focus_child;
container_class->focus = gtk_list_focus;
class->selection_changed = NULL;
class->select_child = gtk_real_list_select_child;
@ -973,15 +974,15 @@ gtk_list_set_focus_child (GtkContainer *container,
}
}
static gint
gtk_list_focus (GtkContainer *container,
static gboolean
gtk_list_focus (GtkWidget *widget,
GtkDirectionType direction)
{
gint return_val = FALSE;
GtkContainer *container;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_LIST (container), FALSE);
container = GTK_CONTAINER (widget);
if (container->focus_child == NULL ||
!GTK_WIDGET_HAS_FOCUS (container->focus_child))
{
@ -989,9 +990,9 @@ gtk_list_focus (GtkContainer *container,
gtk_container_set_focus_child
(container, GTK_LIST (container)->last_focus_child);
if (GTK_CONTAINER_CLASS (parent_class)->focus)
return_val = GTK_CONTAINER_CLASS (parent_class)->focus (container,
direction);
if (GTK_WIDGET_CLASS (parent_class)->focus)
return_val = GTK_WIDGET_CLASS (parent_class)->focus (widget,
direction);
}
if (!return_val)

1
gtk/gtkmarshal.list
View File

@ -23,6 +23,7 @@
BOOLEAN:BOXED
BOOLEAN:BOXED,BOXED
BOOLEAN:ENUM
BOOLEAN:OBJECT,INT,INT,UINT
BOOLEAN:OBJECT,STRING,STRING,BOXED
BOOLEAN:OBJECT,BOXED,BOXED

1
gtk/gtkmarshalers.list
View File

@ -23,6 +23,7 @@
BOOLEAN:BOXED
BOOLEAN:BOXED,BOXED
BOOLEAN:ENUM
BOOLEAN:OBJECT,INT,INT,UINT
BOOLEAN:OBJECT,STRING,STRING,BOXED
BOOLEAN:OBJECT,BOXED,BOXED

67
gtk/gtknotebook.c
View File

@ -156,6 +156,8 @@ static gint gtk_notebook_focus_in (GtkWidget *widget,
static void gtk_notebook_draw_focus (GtkWidget *widget);
static void gtk_notebook_style_set (GtkWidget *widget,
GtkStyle *previous_style);
static gint gtk_notebook_focus (GtkWidget *widget,
GtkDirectionType direction);
/*** GtkContainer Methods ***/
static void gtk_notebook_set_child_arg (GtkContainer *container,
@ -170,8 +172,6 @@ static void gtk_notebook_add (GtkContainer *container,
GtkWidget *widget);
static void gtk_notebook_remove (GtkContainer *container,
GtkWidget *widget);
static gint gtk_notebook_focus (GtkContainer *container,
GtkDirectionType direction);
static void gtk_notebook_set_focus_child (GtkContainer *container,
GtkWidget *child);
static GtkType gtk_notebook_child_type (GtkContainer *container);
@ -310,11 +310,11 @@ gtk_notebook_class_init (GtkNotebookClass *class)
widget_class->motion_notify_event = gtk_notebook_motion_notify;
widget_class->focus_in_event = gtk_notebook_focus_in;
widget_class->style_set = gtk_notebook_style_set;
widget_class->focus = gtk_notebook_focus;
container_class->add = gtk_notebook_add;
container_class->remove = gtk_notebook_remove;
container_class->forall = gtk_notebook_forall;
container_class->focus = gtk_notebook_focus;
container_class->set_focus_child = gtk_notebook_set_focus_child;
container_class->get_child_arg = gtk_notebook_get_child_arg;
container_class->set_child_arg = gtk_notebook_set_child_arg;
@ -1190,7 +1190,7 @@ gtk_notebook_arrow_button_press (GtkNotebook *notebook,
dir = (arrow == GTK_ARROW_LEFT) ? GTK_DIR_UP : GTK_DIR_DOWN;
else
dir = (arrow == GTK_ARROW_LEFT) ? GTK_DIR_LEFT : GTK_DIR_RIGHT;
gtk_container_focus (GTK_CONTAINER (notebook), dir);
gtk_widget_child_focus (widget, dir);
}
if (!notebook->timer)
@ -1677,28 +1677,14 @@ static gboolean
focus_child_in (GtkNotebook *notebook,
GtkDirectionType direction)
{
if (GTK_WIDGET_DRAWABLE (notebook->cur_page->child) &&
GTK_WIDGET_IS_SENSITIVE (notebook->cur_page->child))
{
if (GTK_IS_CONTAINER (notebook->cur_page->child))
{
if (gtk_container_focus (GTK_CONTAINER (notebook->cur_page->child), direction))
return TRUE;
}
else if (GTK_WIDGET_CAN_FOCUS (notebook->cur_page->child))
{
gtk_widget_grab_focus (notebook->cur_page->child);
return TRUE;
}
}
return FALSE;
return gtk_widget_child_focus (notebook->cur_page->child, direction);
}
/* Focus in the notebook can either be on the pages, or on
* the tabs.
*/
static gint
gtk_notebook_focus (GtkContainer *container,
gtk_notebook_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkWidget *old_focus_child;
@ -1720,26 +1706,23 @@ gtk_notebook_focus (GtkContainer *container,
#undef D
gboolean widget_is_focus;
GtkContainer *container;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_NOTEBOOK (container), FALSE);
g_return_val_if_fail (GTK_IS_NOTEBOOK (widget), FALSE);
container = GTK_CONTAINER (widget);
notebook = GTK_NOTEBOOK (container);
widget_is_focus = gtk_widget_is_focus (GTK_WIDGET (container));
widget_is_focus = gtk_widget_is_focus (widget);
old_focus_child = container->focus_child;
effective_direction = translate_direction[notebook->tab_pos][direction];
if (old_focus_child &&
GTK_IS_CONTAINER (old_focus_child) &&
GTK_WIDGET_DRAWABLE (old_focus_child) &&
GTK_WIDGET_IS_SENSITIVE (old_focus_child) &&
gtk_container_focus (GTK_CONTAINER (old_focus_child), direction))
return TRUE;
if (old_focus_child) /* Focus on page child */
{
if (gtk_widget_child_focus (old_focus_child, direction))
return TRUE;
switch (effective_direction)
{
case GTK_DIR_TAB_BACKWARD:
@ -2041,14 +2024,14 @@ gtk_notebook_timer (GtkNotebook *notebook)
if (!notebook->focus_tab ||
gtk_notebook_search_page (notebook, notebook->focus_tab,
STEP_PREV, TRUE))
gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_LEFT);
gtk_widget_child_focus (GTK_WIDGET (notebook), GTK_DIR_LEFT);
}
else if (notebook->click_child == GTK_ARROW_RIGHT)
{
if (!notebook->focus_tab ||
gtk_notebook_search_page (notebook, notebook->focus_tab,
STEP_NEXT, TRUE))
gtk_container_focus (GTK_CONTAINER (notebook), GTK_DIR_RIGHT);
gtk_widget_child_focus (GTK_WIDGET (notebook), GTK_DIR_RIGHT);
}
if (notebook->need_timer)
{
@ -3491,21 +3474,9 @@ gtk_notebook_page_select (GtkNotebook *notebook,
dir = GTK_DIR_LEFT;
break;
}
if (GTK_WIDGET_VISIBLE (page->child))
{
if (GTK_IS_CONTAINER (page->child))
{
if (gtk_container_focus (GTK_CONTAINER (page->child),
dir))
return TRUE;
}
else if (GTK_WIDGET_CAN_FOCUS (page->child))
{
gtk_widget_grab_focus (page->child);
return TRUE;
}
}
if (gtk_widget_child_focus (page->child, dir))
return TRUE;
}
return FALSE;
}

38
gtk/gtkplug.c
View File

@ -43,7 +43,7 @@ static void gtk_plug_forward_key_press (GtkPlug *plug,
GdkEventKey *event);
static void gtk_plug_set_focus (GtkWindow *window,
GtkWidget *focus);
static gboolean gtk_plug_focus (GtkContainer *container,
static gboolean gtk_plug_focus (GtkWidget *widget,
GtkDirectionType direction);
static void gtk_plug_accel_entries_changed (GtkWindow *window);
static GdkFilterReturn gtk_plug_filter_func (GdkXEvent *gdk_xevent,
@ -94,7 +94,6 @@ static void
gtk_plug_class_init (GtkPlugClass *class)
{
GtkWidgetClass *widget_class = (GtkWidgetClass *)class;
GtkContainerClass *container_class = (GtkContainerClass *)class;
GtkWindowClass *window_class = (GtkWindowClass *)class;
parent_class = gtk_type_class (GTK_TYPE_WINDOW);
@ -103,7 +102,7 @@ gtk_plug_class_init (GtkPlugClass *class)
widget_class->unrealize = gtk_plug_unrealize;
widget_class->key_press_event = gtk_plug_key_press_event;
container_class->focus = gtk_plug_focus;
widget_class->focus = gtk_plug_focus;
window_class->set_focus = gtk_plug_set_focus;
#if 0
@ -441,12 +440,13 @@ gtk_plug_accel_entries_changed (GtkWindow *window)
#endif
static gboolean
gtk_plug_focus (GtkContainer *container,
gtk_plug_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkBin *bin = GTK_BIN (container);
GtkPlug *plug = GTK_PLUG (container);
GtkWindow *window = GTK_WINDOW (container);
GtkBin *bin = GTK_BIN (widget);
GtkPlug *plug = GTK_PLUG (widget);
GtkWindow *window = GTK_WINDOW (widget);
GtkContainer *container = GTK_CONTAINER (widget);
GtkWidget *old_focus_child = container->focus_child;
GtkWidget *parent;
@ -454,10 +454,7 @@ gtk_plug_focus (GtkContainer *container,
*/
if (old_focus_child)
{
if (GTK_IS_CONTAINER (old_focus_child) &&
GTK_WIDGET_DRAWABLE (old_focus_child) &&
GTK_WIDGET_IS_SENSITIVE (old_focus_child) &&
gtk_container_focus (GTK_CONTAINER (old_focus_child), direction))
if (gtk_widget_child_focus (old_focus_child, direction))
return TRUE;
if (window->focus_widget)
@ -513,20 +510,9 @@ gtk_plug_focus (GtkContainer *container,
else
{
/* Try to focus the first widget in the window */
if (GTK_WIDGET_DRAWABLE (bin->child) &&
GTK_WIDGET_IS_SENSITIVE (bin->child))
{
if (GTK_IS_CONTAINER (bin->child))
{
if (gtk_container_focus (GTK_CONTAINER (bin->child), direction))
return TRUE;
}
else if (GTK_WIDGET_CAN_FOCUS (bin->child))
{
gtk_widget_grab_focus (bin->child);
return TRUE;
}
}
if (gtk_widget_child_focus (bin->child, direction))
return TRUE;
}
return FALSE;
@ -582,7 +568,7 @@ focus_first_last (GtkPlug *plug,
gtk_window_set_focus (GTK_WINDOW (plug), NULL);
}
gtk_container_focus (GTK_CONTAINER (plug), direction);
gtk_widget_child_focus (GTK_WIDGET (plug), direction);
}
static void

24
gtk/gtksocket.c
View File

@ -57,7 +57,7 @@ static void gtk_socket_claim_focus (GtkSocket *socket
static gboolean gtk_socket_focus_out_event (GtkWidget *widget,
GdkEventFocus *event);
static void gtk_socket_send_configure_event (GtkSocket *socket);
static gboolean gtk_socket_focus (GtkContainer *container,
static gboolean gtk_socket_focus (GtkWidget *widget,
GtkDirectionType direction);
static GdkFilterReturn gtk_socket_filter_func (GdkXEvent *gdk_xevent,
GdkEvent *event,
@ -126,7 +126,7 @@ gtk_socket_class_init (GtkSocketClass *class)
widget_class->focus_in_event = gtk_socket_focus_in_event;
widget_class->focus_out_event = gtk_socket_focus_out_event;
container_class->focus = gtk_socket_focus;
widget_class->focus = gtk_socket_focus;
}
static void
@ -702,16 +702,16 @@ gtk_socket_claim_focus (GtkSocket *socket)
}
static gboolean
gtk_socket_focus (GtkContainer *container, GtkDirectionType direction)
gtk_socket_focus (GtkWidget *widget, GtkDirectionType direction)
{
GtkSocket *socket;
gint detail = -1;
g_return_val_if_fail (GTK_IS_SOCKET (container), FALSE);
g_return_val_if_fail (GTK_IS_SOCKET (widget), FALSE);
socket = GTK_SOCKET (container);
socket = GTK_SOCKET (widget);
if (!GTK_WIDGET_HAS_FOCUS (container))
if (!GTK_WIDGET_HAS_FOCUS (widget))
{
switch (direction)
{
@ -730,8 +730,8 @@ gtk_socket_focus (GtkContainer *container, GtkDirectionType direction)
send_xembed_message (socket, XEMBED_FOCUS_IN, detail, 0, 0,
gtk_get_current_event_time ());
GTK_WIDGET_SET_FLAGS (container, GTK_HAS_FOCUS);
gtk_widget_grab_focus (GTK_WIDGET (container));
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
gtk_widget_grab_focus (widget);
return TRUE;
}
@ -935,11 +935,11 @@ handle_xembed_message (GtkSocket *socket,
case XEMBED_FOCUS_PREV:
{
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (socket));
if (toplevel && GTK_IS_CONTAINER (toplevel))
if (toplevel)
{
gtk_container_focus (GTK_CONTAINER (toplevel),
(message == XEMBED_FOCUS_NEXT ?
GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD));
gtk_widget_child_focus (toplevel,
(message == XEMBED_FOCUS_NEXT ?
GTK_DIR_TAB_FORWARD : GTK_DIR_TAB_BACKWARD));
}
break;
}

4
gtk/gtktextbuffer.c
View File

@ -2210,7 +2210,7 @@ gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer,
}
}
g_list_foreach (tags, (GFunc) g_object_ref, NULL);
g_slist_foreach (tags, (GFunc) g_object_ref, NULL);
tmp_list = tags;
while (tmp_list != NULL)
@ -2222,7 +2222,7 @@ gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer,
tmp_list = tmp_list->next;
}
g_list_foreach (tags, (GFunc) g_object_unref, NULL);
g_slist_foreach (tags, (GFunc) g_object_unref, NULL);
g_slist_free (tags);
}

14
gtk/gtktoolbar.c
View File

@ -91,6 +91,8 @@ static void gtk_toolbar_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void gtk_toolbar_style_set (GtkWidget *widget,
GtkStyle *prev_style);
static gboolean gtk_toolbar_focus (GtkWidget *widget,
GtkDirectionType dir);
static void gtk_toolbar_show_all (GtkWidget *widget);
static void gtk_toolbar_add (GtkContainer *container,
GtkWidget *widget);
@ -100,6 +102,7 @@ static void gtk_toolbar_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_real_toolbar_orientation_changed (GtkToolbar *toolbar,
GtkOrientation orientation);
static void gtk_real_toolbar_style_changed (GtkToolbar *toolbar,
@ -192,11 +195,11 @@ gtk_toolbar_class_init (GtkToolbarClass *class)
widget_class->size_allocate = gtk_toolbar_size_allocate;
widget_class->style_set = gtk_toolbar_style_set;
widget_class->show_all = gtk_toolbar_show_all;
widget_class->focus = gtk_toolbar_focus;
container_class->add = gtk_toolbar_add;
container_class->remove = gtk_toolbar_remove;
container_class->forall = gtk_toolbar_forall;
container_class->focus = NULL;
class->orientation_changed = gtk_real_toolbar_orientation_changed;
class->style_changed = gtk_real_toolbar_style_changed;
@ -834,6 +837,15 @@ gtk_toolbar_style_set (GtkWidget *widget,
gtk_toolbar_update_button_relief (GTK_TOOLBAR (widget));
}
static gboolean
gtk_toolbar_focus (GtkWidget *widget,
GtkDirectionType dir)
{
/* Focus can't go in toolbars */
return FALSE;
}
static void
child_show_all (GtkWidget *widget)
{

18
gtk/gtktreeview.c
View File

@ -164,7 +164,7 @@ static gint gtk_tree_view_focus_in (GtkWidget *widget,
GdkEventFocus *event);
static gint gtk_tree_view_focus_out (GtkWidget *widget,
GdkEventFocus *event);
static gint gtk_tree_view_focus (GtkContainer *container,
static gint gtk_tree_view_focus (GtkWidget *widget,
GtkDirectionType direction);
/* container signals */
@ -418,11 +418,11 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
widget_class->drag_motion = gtk_tree_view_drag_motion;
widget_class->drag_drop = gtk_tree_view_drag_drop;
widget_class->drag_data_received = gtk_tree_view_drag_data_received;
widget_class->focus = gtk_tree_view_focus;
/* GtkContainer signals */
container_class->remove = gtk_tree_view_remove;
container_class->forall = gtk_tree_view_forall;
container_class->focus = gtk_tree_view_focus;
container_class->set_focus_child = gtk_tree_view_set_focus_child;
class->set_scroll_adjustments = gtk_tree_view_set_adjustments;
@ -3784,7 +3784,7 @@ gtk_tree_view_header_focus (GtkTreeView *tree_view,
break;
}
if (gtk_container_focus (GTK_CONTAINER (focus_child), dir))
if (gtk_widget_child_focus (focus_child, dir))
{
/* The focus moves inside the button. */
/* This is probably a great example of bad UI */
@ -3880,7 +3880,7 @@ gtk_tree_view_header_focus (GtkTreeView *tree_view,
* handling scrolling by keyboard, such that in cases.
*/
static gint
gtk_tree_view_focus (GtkContainer *container,
gtk_tree_view_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkTreeView *tree_view;
@ -3889,11 +3889,13 @@ gtk_tree_view_focus (GtkContainer *container,
GtkRBTree *cursor_tree;
GtkRBNode *cursor_node;
GtkTreePath *cursor_path;
GtkContainer *container;
g_return_val_if_fail (GTK_IS_TREE_VIEW (container), FALSE);
g_return_val_if_fail (GTK_WIDGET_VISIBLE (container), FALSE);
g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
g_return_val_if_fail (GTK_WIDGET_VISIBLE (widget), FALSE);
tree_view = GTK_TREE_VIEW (container);
container = GTK_CONTAINER (widget);
tree_view = GTK_TREE_VIEW (widget);
if (!GTK_WIDGET_IS_SENSITIVE (container))
return FALSE;

90
gtk/gtkwidget.c
View File

@ -69,6 +69,7 @@ enum {
REMOVE_ACCELERATOR,
ACTIVATE_MNEMONIC,
GRAB_FOCUS,
FOCUS,
EVENT,
BUTTON_PRESS_EVENT,
BUTTON_RELEASE_EVENT,
@ -179,6 +180,8 @@ static void gtk_widget_style_set (GtkWidget *widget,
static void gtk_widget_direction_changed (GtkWidget *widget,
GtkTextDirection previous_direction);
static void gtk_widget_real_grab_focus (GtkWidget *focus_widget);
static gboolean gtk_widget_real_focus (GtkWidget *widget,
GtkDirectionType direction);
static GdkColormap* gtk_widget_peek_colormap (void);
static GtkStyle* gtk_widget_peek_style (void);
@ -323,6 +326,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
klass->mnemonic_activate = gtk_widget_real_mnemonic_activate;
klass->grab_focus = gtk_widget_real_grab_focus;
klass->focus = gtk_widget_real_focus;
klass->event = NULL;
klass->button_press_event = NULL;
klass->button_release_event = NULL;
@ -650,6 +654,15 @@ gtk_widget_class_init (GtkWidgetClass *klass)
GTK_SIGNAL_OFFSET (GtkWidgetClass, grab_focus),
gtk_marshal_VOID__VOID,
GTK_TYPE_NONE, 0);
widget_signals[FOCUS] =
g_signal_newc ("focus",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWidgetClass, focus),
_gtk_boolean_handled_accumulator, NULL,
gtk_marshal_BOOLEAN__ENUM,
G_TYPE_BOOLEAN, 1,
GTK_TYPE_DIRECTION_TYPE);
widget_signals[EVENT] =
g_signal_newc ("event",
G_TYPE_FROM_CLASS(object_class),
@ -3021,6 +3034,23 @@ gtk_widget_real_grab_focus (GtkWidget *focus_widget)
}
}
static gboolean
gtk_widget_real_focus (GtkWidget *widget,
GtkDirectionType direction)
{
if (!GTK_WIDGET_CAN_FOCUS (widget))
return FALSE;
if (!GTK_WIDGET_HAS_FOCUS (widget))
{
gtk_widget_grab_focus (widget);
return TRUE;
}
else
return FALSE;
}
/**
* gtk_widget_is_focus:
* @widget: a #GtkWidget
@ -4120,6 +4150,66 @@ gtk_widget_get_parent_window (GtkWidget *widget)
return (parent_window != NULL) ? parent_window : widget->parent->window;
}
/**
* gtk_widget_child_focus:
* @widget: a #GtkWidget
* @direction: direction of focus movement
*
* This function is used by custom widget implementations; if you're
* writing an app, you'd use gtk_widget_grab_focus() to move the focus
* to a particular widget, and gtk_container_set_focus_chain() to
* change the focus tab order. So you may want to investigate those
* functions instead.
*
* gtk_widget_child_focus() is called by containers as the user moves
* around the window using keyboard shortcuts. @direction indicates
* what kind of motion is taking place (up, down, left, right, tab
* forward, tab backward). gtk_widget_child_focus() invokes the
* "focus" signal on #GtkWidget; widgets override the default handler
* for this signal in order to implement appropriate focus behavior.
*
* The "focus" default handler for a widget should return %TRUE if
* moving in @direction left the focus on a focusable location inside
* that widget, and %FALSE if moving in @direction moved the focus
* outside the widget. If returning %TRUE, widgets normally
* call gtk_widget_grab_focus() to place the focus accordingly;
* if returning %FALSE, they don't modify the current focus location.
*
* This function replaces gtk_container_focus() from GTK+ 1.2. It was
* necessary to check that the child was visible, sensitive, and
* focusable before calling
* gtk_container_focus(). gtk_widget_child_focus() returns %FALSE if
* the widget is not currently in a focusable state, so there's no
* need for those checks.
*
* Return value: %TRUE if focus ended up inside @widget
**/
gboolean
gtk_widget_child_focus (GtkWidget *widget,
GtkDirectionType direction)
{
gboolean return_val;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
if (!GTK_WIDGET_VISIBLE (widget) ||
!GTK_WIDGET_IS_SENSITIVE (widget))
return FALSE;
/* child widgets must set CAN_FOCUS, containers
* don't have to though.
*/
if (!GTK_IS_CONTAINER (widget) &&
!GTK_WIDGET_CAN_FOCUS (widget))
return FALSE;
gtk_signal_emit (GTK_OBJECT (widget),
widget_signals[FOCUS],
direction, &return_val);
return return_val;
}
/* Update the position from aux_info. Used from gtk_widget_set_uposition
* and gtk_widget_set_property().
*/

6
gtk/gtkwidget.h
View File

@ -276,7 +276,9 @@ struct _GtkWidgetClass
gboolean group_cycling);
/* explicit focus */
void (* grab_focus) (GtkWidget *widget);
void (* grab_focus) (GtkWidget *widget);
gboolean (* focus) (GtkWidget *widget,
GtkDirectionType direction);
/* events */
gboolean (* event) (GtkWidget *widget,
@ -523,6 +525,8 @@ void gtk_widget_set_parent (GtkWidget *widget,
void gtk_widget_set_parent_window (GtkWidget *widget,
GdkWindow *parent_window);
GdkWindow *gtk_widget_get_parent_window (GtkWidget *widget);
gboolean gtk_widget_child_focus (GtkWidget *widget,
GtkDirectionType direction);
void gtk_widget_set_uposition (GtkWidget *widget,
gint x,
gint y);

42
gtk/gtkwindow.c
View File

@ -143,7 +143,7 @@ static gint gtk_window_focus_out_event (GtkWidget *widget,
static gint gtk_window_client_event (GtkWidget *widget,
GdkEventClient *event);
static void gtk_window_check_resize (GtkContainer *container);
static gint gtk_window_focus (GtkContainer *container,
static gint gtk_window_focus (GtkWidget *widget,
GtkDirectionType direction);
static void gtk_window_real_set_focus (GtkWindow *window,
GtkWidget *focus);
@ -301,11 +301,11 @@ gtk_window_class_init (GtkWindowClass *klass)
widget_class->focus_in_event = gtk_window_focus_in_event;
widget_class->focus_out_event = gtk_window_focus_out_event;
widget_class->client_event = gtk_window_client_event;
widget_class->focus = gtk_window_focus;
widget_class->expose_event = gtk_window_expose;
container_class->check_resize = gtk_window_check_resize;
container_class->focus = gtk_window_focus;
klass->set_focus = gtk_window_real_set_focus;
klass->frame_event = gtk_window_frame_event;
@ -2190,7 +2190,7 @@ static void
gtk_window_move_focus (GtkWindow *window,
GtkDirectionType dir)
{
gtk_container_focus (GTK_CONTAINER (window), dir);
gtk_widget_child_focus (GTK_WIDGET (window), dir);
if (!GTK_CONTAINER (window)->focus_child)
gtk_window_set_focus (window, NULL);
@ -2382,13 +2382,20 @@ gtk_window_check_resize (GtkContainer *container)
}
static gboolean
gtk_window_focus (GtkContainer *container,
gtk_window_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkBin *bin = GTK_BIN (container);
GtkWindow *window = GTK_WINDOW (container);
GtkWidget *old_focus_child = container->focus_child;
GtkBin *bin;
GtkWindow *window;
GtkContainer *container;
GtkWidget *old_focus_child;
GtkWidget *parent;
container = GTK_CONTAINER (widget);
window = GTK_WINDOW (widget);
bin = GTK_BIN (widget);
old_focus_child = container->focus_child;
/* We need a special implementation here to deal properly with wrapping
* around in the tab chain without the danger of going into an
@ -2396,10 +2403,7 @@ gtk_window_focus (GtkContainer *container,
*/
if (old_focus_child)
{
if (GTK_IS_CONTAINER (old_focus_child) &&
GTK_WIDGET_DRAWABLE (old_focus_child) &&
GTK_WIDGET_IS_SENSITIVE (old_focus_child) &&
gtk_container_focus (GTK_CONTAINER (old_focus_child), direction))
if (gtk_widget_child_focus (old_focus_child, direction))
return TRUE;
}
@ -2417,20 +2421,10 @@ gtk_window_focus (GtkContainer *container,
}
/* Now try to focus the first widget in the window */
if (bin->child &&
GTK_WIDGET_DRAWABLE (bin->child) &&
GTK_WIDGET_IS_SENSITIVE (bin->child))
if (bin->child)
{
if (GTK_IS_CONTAINER (bin->child))
{
if (gtk_container_focus (GTK_CONTAINER (bin->child), direction))
return TRUE;
}
else if (GTK_WIDGET_CAN_FOCUS (bin->child))
{
gtk_widget_grab_focus (bin->child);
return TRUE;
}
if (gtk_widget_child_focus (bin->child, direction))
return TRUE;
}
return FALSE;