geez, don't call g_list funcs on GSList

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

28 files changed, 396 insertions, 226 deletions

diff --git a/ChangeLog b/ChangeLog
index b1581cf34..84930924a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -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
diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0
index b1581cf34..84930924a 100644
--- a/ChangeLog.pre-2-0
+++ b/ChangeLog.pre-2-0
@@ -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
diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10
index b1581cf34..84930924a 100644
--- a/ChangeLog.pre-2-10
+++ b/ChangeLog.pre-2-10
@@ -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
diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2
index b1581cf34..84930924a 100644
--- a/ChangeLog.pre-2-2
+++ b/ChangeLog.pre-2-2
@@ -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
diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4
index b1581cf34..84930924a 100644
--- a/ChangeLog.pre-2-4
+++ b/ChangeLog.pre-2-4
@@ -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
diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6
index b1581cf34..84930924a 100644
--- a/ChangeLog.pre-2-6
+++ b/ChangeLog.pre-2-6
@@ -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
diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8
index b1581cf34..84930924a 100644
--- a/ChangeLog.pre-2-8
+++ b/ChangeLog.pre-2-8
@@ -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
diff --git a/docs/Changes-2.0.txt b/docs/Changes-2.0.txt
index 6175d38a7..69e791761 100644
--- a/docs/Changes-2.0.txt
+++ b/docs/Changes-2.0.txt
@@ -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.
+ 
+ 
\ No newline at end of file
diff --git a/docs/reference/gtk/tmpl/gtk-unused.sgml b/docs/reference/gtk/tmpl/gtk-unused.sgml
index 6eb4e0cae..85536fc79 100644
--- a/docs/reference/gtk/tmpl/gtk-unused.sgml
+++ b/docs/reference/gtk/tmpl/gtk-unused.sgml
@@ -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>
 
diff --git a/docs/reference/gtk/tmpl/gtkcontainer.sgml b/docs/reference/gtk/tmpl/gtkcontainer.sgml
index 81b031484..c3e926c6e 100644
--- a/docs/reference/gtk/tmpl/gtkcontainer.sgml
+++ b/docs/reference/gtk/tmpl/gtkcontainer.sgml
@@ -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>
 
diff --git a/docs/reference/gtk/tmpl/gtkwidget.sgml b/docs/reference/gtk/tmpl/gtkwidget.sgml
index e8e745731..8d5161e33 100644
--- a/docs/reference/gtk/tmpl/gtkwidget.sgml
+++ b/docs/reference/gtk/tmpl/gtkwidget.sgml
@@ -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>
 
diff --git a/gtk/gtkclist.c b/gtk/gtkclist.c
index c48364718..a6352ae21 100644
--- a/gtk/gtkclist.c
+++ b/gtk/gtkclist.c
@@ -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;
     }
diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c
index 2029e7f16..c69d1c79e 100644
--- a/gtk/gtkcontainer.c
+++ b/gtk/gtkcontainer.c
@@ -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;
         }
     }
 
diff --git a/gtk/gtkcontainer.h b/gtk/gtkcontainer.h
index fa1c03add..051276965 100644
--- a/gtk/gtkcontainer.h
+++ b/gtk/gtkcontainer.h
@@ -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 */
 
diff --git a/gtk/gtkhsv.c b/gtk/gtkhsv.c
index 6eecde7c3..d710debce 100644
--- a/gtk/gtkhsv.c
+++ b/gtk/gtkhsv.c
@@ -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))
     {
diff --git a/gtk/gtkhsv.h b/gtk/gtkhsv.h
index 6a9808593..3fa6c8b08 100644
--- a/gtk/gtkhsv.h
+++ b/gtk/gtkhsv.h
@@ -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;
diff --git a/gtk/gtklist.c b/gtk/gtklist.c
index 30dd3aeaf..189dd633f 100644
--- a/gtk/gtklist.c
+++ b/gtk/gtklist.c
@@ -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)
diff --git a/gtk/gtkmarshal.list b/gtk/gtkmarshal.list
index fe6148542..0de93619d 100644
--- a/gtk/gtkmarshal.list
+++ b/gtk/gtkmarshal.list
@@ -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
diff --git a/gtk/gtkmarshalers.list b/gtk/gtkmarshalers.list
index fe6148542..0de93619d 100644
--- a/gtk/gtkmarshalers.list
+++ b/gtk/gtkmarshalers.list
@@ -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
diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c
index c18b22833..5775fb3ff 100644
--- a/gtk/gtknotebook.c
+++ b/gtk/gtknotebook.c
@@ -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;
 }
diff --git a/gtk/gtkplug.c b/gtk/gtkplug.c
index 78d9d5128..1f7319b39 100644
--- a/gtk/gtkplug.c
+++ b/gtk/gtkplug.c
@@ -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
diff --git a/gtk/gtksocket.c b/gtk/gtksocket.c
index 42eb0e67a..754ca0e0f 100644
--- a/gtk/gtksocket.c
+++ b/gtk/gtksocket.c
@@ -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;
       }
diff --git a/gtk/gtktextbuffer.c b/gtk/gtktextbuffer.c
index c014ba4b2..4de2827fc 100644
--- a/gtk/gtktextbuffer.c
+++ b/gtk/gtktextbuffer.c
@@ -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);
 }
diff --git a/gtk/gtktoolbar.c b/gtk/gtktoolbar.c
index 93dbadc39..9b5836410 100644
--- a/gtk/gtktoolbar.c
+++ b/gtk/gtktoolbar.c
@@ -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)
 {
diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index c17b6f93b..87abccca7 100644
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -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;
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index f8c4a58c1..790476875 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -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().
  */
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index 2fa125fa5..a1107e955 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -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);
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index 99c7e2f09..0880b3a89 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -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;