Add a combo box cell renderer.

ChangeLog

+2004-07-16  Matthias Clasen  <mclasen@redhat.com>
+
+	Add a combo box cell renderer (#139347, Lorenzo Gil Sanchez)
+	
+	* gtk/gtkcellrenderercombo.[hc]: New Files.
+
+	* gtk/gtk.h: 
+	* gtk/Makefile.am (gtk_public_h_sources, gtk_c_sources): 
+	Add the new files.
+
+	* gtk/gtkcombobox.[hc]: Implement GtkCellEditable, add a 
+	:has-frame property for suppressing the frame around 
+	the child and redo the size allocation logic to take 
+	focus width into account.
+
+	* gtk/gtkcomboboxentry.c (gtk_combo_box_entry_init): 
+	Acknowledge the GtkComboBox:has-frame property and make
+	the entry fill its allocation vertically.
+
+	* gtk/gtkmarshalers.list: Add BOOLEAN:STRING.
+		
+	* gtk/gtktreeview.c (gtk_tree_view_remove_widget): Queue
+	a draw here to keep non-widget windows from leaving 
+	shadows behind.
+
 2004-07-16  Matthias Clasen  <mclasen@redhat.com>
 
 	* gtk/gtkcombobox.c (gtk_combo_box_forall): Don't iterate

ChangeLog.pre-2-10

+2004-07-16  Matthias Clasen  <mclasen@redhat.com>
+
+	Add a combo box cell renderer (#139347, Lorenzo Gil Sanchez)
+	
+	* gtk/gtkcellrenderercombo.[hc]: New Files.
+
+	* gtk/gtk.h: 
+	* gtk/Makefile.am (gtk_public_h_sources, gtk_c_sources): 
+	Add the new files.
+
+	* gtk/gtkcombobox.[hc]: Implement GtkCellEditable, add a 
+	:has-frame property for suppressing the frame around 
+	the child and redo the size allocation logic to take 
+	focus width into account.
+
+	* gtk/gtkcomboboxentry.c (gtk_combo_box_entry_init): 
+	Acknowledge the GtkComboBox:has-frame property and make
+	the entry fill its allocation vertically.
+
+	* gtk/gtkmarshalers.list: Add BOOLEAN:STRING.
+		
+	* gtk/gtktreeview.c (gtk_tree_view_remove_widget): Queue
+	a draw here to keep non-widget windows from leaving 
+	shadows behind.
+
 2004-07-16  Matthias Clasen  <mclasen@redhat.com>
 
 	* gtk/gtkcombobox.c (gtk_combo_box_forall): Don't iterate

ChangeLog.pre-2-6

+2004-07-16  Matthias Clasen  <mclasen@redhat.com>
+
+	Add a combo box cell renderer (#139347, Lorenzo Gil Sanchez)
+	
+	* gtk/gtkcellrenderercombo.[hc]: New Files.
+
+	* gtk/gtk.h: 
+	* gtk/Makefile.am (gtk_public_h_sources, gtk_c_sources): 
+	Add the new files.
+
+	* gtk/gtkcombobox.[hc]: Implement GtkCellEditable, add a 
+	:has-frame property for suppressing the frame around 
+	the child and redo the size allocation logic to take 
+	focus width into account.
+
+	* gtk/gtkcomboboxentry.c (gtk_combo_box_entry_init): 
+	Acknowledge the GtkComboBox:has-frame property and make
+	the entry fill its allocation vertically.
+
+	* gtk/gtkmarshalers.list: Add BOOLEAN:STRING.
+		
+	* gtk/gtktreeview.c (gtk_tree_view_remove_widget): Queue
+	a draw here to keep non-widget windows from leaving 
+	shadows behind.
+
 2004-07-16  Matthias Clasen  <mclasen@redhat.com>
 
 	* gtk/gtkcombobox.c (gtk_combo_box_forall): Don't iterate

ChangeLog.pre-2-8

+2004-07-16  Matthias Clasen  <mclasen@redhat.com>
+
+	Add a combo box cell renderer (#139347, Lorenzo Gil Sanchez)
+	
+	* gtk/gtkcellrenderercombo.[hc]: New Files.
+
+	* gtk/gtk.h: 
+	* gtk/Makefile.am (gtk_public_h_sources, gtk_c_sources): 
+	Add the new files.
+
+	* gtk/gtkcombobox.[hc]: Implement GtkCellEditable, add a 
+	:has-frame property for suppressing the frame around 
+	the child and redo the size allocation logic to take 
+	focus width into account.
+
+	* gtk/gtkcomboboxentry.c (gtk_combo_box_entry_init): 
+	Acknowledge the GtkComboBox:has-frame property and make
+	the entry fill its allocation vertically.
+
+	* gtk/gtkmarshalers.list: Add BOOLEAN:STRING.
+		
+	* gtk/gtktreeview.c (gtk_tree_view_remove_widget): Queue
+	a draw here to keep non-widget windows from leaving 
+	shadows behind.
+
 2004-07-16  Matthias Clasen  <mclasen@redhat.com>
 
 	* gtk/gtkcombobox.c (gtk_combo_box_forall): Don't iterate

gtk/Makefile.am

@@ -118,6 +118,7 @@ gtk_public_h_sources =          \
 	gtkcelleditable.h	\
 	gtkcelllayout.h		\
 	gtkcellrenderer.h	\
+	gtkcellrenderercombo.h	\
 	gtkcellrendererpixbuf.h	\
 	gtkcellrendererprogress.h \
 	gtkcellrenderertext.h	\
@@ -324,6 +325,7 @@ gtk_c_sources =                 \
 	gtkcelleditable.c	\
 	gtkcelllayout.c		\
 	gtkcellrenderer.c	\
+	gtkcellrenderercombo.c	\
 	gtkcellrendererpixbuf.c	\
 	gtkcellrendererprogress.c \
 	gtkcellrendererseptext.c\

gtk/gtk.h

@@ -48,6 +48,7 @@
 #include <gtk/gtkcalendar.h>
 #include <gtk/gtkcelllayout.h>
 #include <gtk/gtkcellrenderer.h>
+#include <gtk/gtkcellrenderercombo.h>
 #include <gtk/gtkcellrendererpixbuf.h>
 #include <gtk/gtkcellrendererprogress.h>
 #include <gtk/gtkcellrenderertext.h>

gtk/gtkcellrenderercombo.c

+/* GtkCellRendererCombo
+ * Copyright (C) 2004 Lorenzo Gil Sanchez
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include "gtkintl.h"
+#include "gtkbin.h"
+#include "gtkentry.h"
+#include "gtkcelllayout.h"
+#include "gtkcellrenderercombo.h"
+#include "gtkcellrenderertext.h"
+#include "gtkcombobox.h"
+#include "gtkcomboboxentry.h"
+
+static void gtk_cell_renderer_combo_class_init (GtkCellRendererComboClass *klass);
+static void gtk_cell_renderer_combo_init       (GtkCellRendererCombo      *self);
+static void gtk_cell_renderer_combo_get_property (GObject      *object,
+						  guint         prop_id,
+						  GValue       *value,
+						  GParamSpec   *pspec);
+
+static void gtk_cell_renderer_combo_set_property (GObject      *object,
+						  guint         prop_id,
+						  const GValue *value,
+						  GParamSpec   *pspec);
+
+static GtkCellEditable *gtk_cell_renderer_combo_start_editing (GtkCellRenderer     *cell,
+							       GdkEvent            *event,
+							       GtkWidget           *widget,
+							       const gchar         *path,
+							       GdkRectangle        *background_area,
+							       GdkRectangle        *cell_area,
+							       GtkCellRendererState flags);
+
+enum {
+  PROP_0,
+  PROP_MODEL,
+  PROP_TEXT_COLUMN,
+  PROP_HAS_ENTRY
+};
+
+static GObjectClass *parent_class = NULL;
+
+#define GTK_CELL_RENDERER_COMBO_PATH "gtk-cell-renderer-combo-path"
+
+GType
+gtk_cell_renderer_combo_get_type (void)
+{
+  static GType gtk_cell_renderer_combo_type = 0;
+
+  if (!gtk_cell_renderer_combo_type)
+    {
+      static const GTypeInfo gtk_cell_renderer_combo_info = 
+	{
+	  sizeof (GtkCellRendererComboClass),
+	  (GBaseInitFunc)     NULL,
+	  (GBaseFinalizeFunc) NULL,
+	  (GClassInitFunc)    gtk_cell_renderer_combo_class_init,
+	  NULL,
+	  NULL,
+	  sizeof (GtkCellRendererCombo),
+	  0,
+	  (GInstanceInitFunc) gtk_cell_renderer_combo_init
+	};
+      gtk_cell_renderer_combo_type =
+	g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT,
+				"GtkCellRendererCombo",
+				&gtk_cell_renderer_combo_info,
+				0);
+    }
+  return gtk_cell_renderer_combo_type;
+}
+
+static void
+gtk_cell_renderer_combo_class_init (GtkCellRendererComboClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->get_property = gtk_cell_renderer_combo_get_property;
+  object_class->set_property = gtk_cell_renderer_combo_set_property;
+
+  cell_class->start_editing = gtk_cell_renderer_combo_start_editing;
+
+  /**
+   * GtkCellRendererCombo:model:
+   *
+   * The :model property holds a tree model containing the possible
+   * values for the combo box. Use the :text_column property to specify
+   * the column holding the values.
+   * 
+   * Since: 2.6
+   */
+  g_object_class_install_property (object_class,
+				   PROP_MODEL,
+				   g_param_spec_object ("model",
+							P_("Model"),
+							P_("The model containing the possible values for the combo box"),
+							GTK_TYPE_TREE_MODEL,
+							G_PARAM_READWRITE));
+
+  /**
+   * GtkCellRendererCombo:text_column:
+   *
+   * The :text_column property specifies the model column which
+   * holds the possible values for the combo box. Note that this
+   * refers to the model specified in the :model property, 
+   * <emphasis>not</emphasis> the model backing the tree view to 
+   * which this cell renderer is attached.
+   * 
+   * Since: 2.6
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_TEXT_COLUMN,
+                                   g_param_spec_int ("text_column",
+                                                     P_("Text Column"),
+                                                     P_("A column in the data source model to get the strings from"),
+                                                     -1,
+                                                     G_MAXINT,
+                                                     -1,
+                                                     G_PARAM_READWRITE));
+
+  /** 
+   * GtkCellRendererCombo:has_entry:
+   *
+   * If the :has_entry property is %TRUe, the cell renderer will 
+   * include an entry and allow to enter values other than the ones 
+   * in the popup list. 
+   *
+   * Since: 2.6
+   */
+  g_object_class_install_property (object_class,
+                                   PROP_HAS_ENTRY,
+                                   g_param_spec_boolean ("has_entry",
+							 P_("Has Entry"),
+							 P_("If %FALSE, don't allow to enter strings other than the chosen ones"),
+							 TRUE,
+							 G_PARAM_READWRITE));
+
+}
+
+static void
+gtk_cell_renderer_combo_init (GtkCellRendererCombo *self)
+{
+  self->model = NULL;
+  self->text_column = -1;
+  self->focus_out_id = 0;
+}
+
+/**
+ * gtk_cell_renderer_combo_new: 
+ * 
+ * Creates a new #GtkCellRendererCombo 
+ * Adjust how text is drawn using object properties. 
+ * Object properties can be set globally (with g_object_set()). 
+ * Also, with #GtkTreeViewColumn, you can bind a property to a value 
+ * in a #GtkTreeModel. For example, you can bind the "text" property 
+ * on the cell renderer to a string value in the model, thus rendering 
+ * a different string in each row of the #GtkTreeView.
+ * 
+ * Returns: the new cell renderer
+ *
+ * Since: 2.6
+ */
+GtkCellRenderer *
+gtk_cell_renderer_combo_new (void)
+{
+  return g_object_new (GTK_TYPE_CELL_RENDERER_COMBO, NULL); 
+}
+
+static void
+gtk_cell_renderer_combo_get_property (GObject    *object,
+				      guint       prop_id,
+				      GValue     *value,
+				      GParamSpec *pspec)
+{
+  GtkCellRendererCombo *cell;
+ 
+  g_return_if_fail (GTK_IS_CELL_RENDERER_COMBO (object));
+
+  cell = GTK_CELL_RENDERER_COMBO (object);
+
+  switch (prop_id)
+    {
+    case PROP_MODEL:
+      g_value_set_object (value, cell->model);
+      break; 
+    case PROP_TEXT_COLUMN:
+      g_value_set_int (value, cell->text_column);
+      break;
+    case PROP_HAS_ENTRY:
+      g_value_set_boolean (value, cell->has_entry);
+      break;
+   default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtk_cell_renderer_combo_set_property (GObject      *object,
+				      guint         prop_id,
+				      const GValue *value,
+				      GParamSpec   *pspec)
+{
+  GtkCellRendererCombo *cell;
+  
+  g_return_if_fail (GTK_IS_CELL_RENDERER_COMBO (object));
+
+  cell = GTK_CELL_RENDERER_COMBO (object);
+
+  switch (prop_id)
+    {
+    case PROP_MODEL:
+      cell->model = g_value_get_object (value);
+      break;
+    case PROP_TEXT_COLUMN:
+      cell->text_column = g_value_get_int (value);
+      break;
+    case PROP_HAS_ENTRY:
+      cell->has_entry = g_value_get_boolean (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+gtk_cell_renderer_combo_editing_done (GtkCellEditable *combo,
+				      gpointer         data)
+{
+  const gchar *path;
+  gchar *new_text = NULL;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+  GtkCellRendererCombo *cell;
+  GtkEntry *entry;
+
+  cell = GTK_CELL_RENDERER_COMBO (data);
+
+  if (cell->focus_out_id > 0)
+    {
+      g_signal_handler_disconnect (combo, cell->focus_out_id);
+      cell->focus_out_id = 0;
+    }
+
+  if (_gtk_combo_box_editing_canceled (GTK_COMBO_BOX (combo)))
+    {
+      gtk_cell_renderer_editing_canceled (GTK_CELL_RENDERER (data));
+      return;
+    }
+
+  if (GTK_IS_COMBO_BOX_ENTRY (combo))
+    {
+      entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo)));
+      new_text = g_strdup (gtk_entry_get_text (entry));
+    }
+  else 
+    {
+      model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
+      if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
+	gtk_tree_model_get (model, &iter, cell->text_column, &new_text, -1);
+    }
+
+  path = g_object_get_data (G_OBJECT (combo), GTK_CELL_RENDERER_COMBO_PATH);
+  g_signal_emit_by_name (cell, "edited", path, new_text);
+
+  g_free (new_text);
+}
+
+static gboolean
+gtk_cell_renderer_combo_focus_out_event (GtkWidget *widget,
+					 GdkEvent  *event,
+					 gpointer   data)
+{
+  
+  gtk_cell_renderer_combo_editing_done (GTK_CELL_EDITABLE (widget), data);
+
+  return FALSE;
+}
+
+typedef struct 
+{
+  GtkCellRendererCombo *cell;
+  gboolean found;
+  GtkTreeIter iter;
+} SearchData;
+
+static gboolean 
+find_text (GtkTreeModel *model, 
+	   GtkTreePath  *path, 
+	   GtkTreeIter  *iter, 
+	   gpointer      data)
+{
+  SearchData *search_data = (SearchData *)data;
+  gchar *text;
+  
+  gtk_tree_model_get (model, iter, search_data->cell->text_column, &text, -1);
+  if (text && GTK_CELL_RENDERER_TEXT (search_data->cell)->text &&
+      strcmp (text, GTK_CELL_RENDERER_TEXT (search_data->cell)->text) == 0)
+    {
+      search_data->iter = *iter;
+      search_data->found = TRUE;
+    }
+  
+  return search_data->found;
+}
+
+static GtkCellEditable *
+gtk_cell_renderer_combo_start_editing (GtkCellRenderer     *cell,
+				       GdkEvent            *event,
+				       GtkWidget           *widget,
+				       const gchar         *path,
+				       GdkRectangle        *background_area,
+				       GdkRectangle        *cell_area,
+				       GtkCellRendererState flags)
+{
+  GtkCellRendererCombo *cell_combo;
+  GtkCellRendererText *cell_text;
+  GtkWidget *combo;
+  SearchData search_data;
+
+  cell_text = GTK_CELL_RENDERER_TEXT (cell);
+  if (cell_text->editable == FALSE)
+    return NULL;
+
+  cell_combo = GTK_CELL_RENDERER_COMBO (cell);
+  if (cell_combo->model == NULL || cell_combo->text_column < 0)
+    return NULL;
+
+  if (cell_combo->has_entry) 
+    {
+      combo = gtk_combo_box_entry_new_with_model (cell_combo->model, cell_combo->text_column);
+
+      if (cell_text->text)
+	gtk_entry_set_text (GTK_ENTRY (GTK_BIN (combo)->child), 
+			    cell_text->text);
+    }
+  else
+    {
+      cell = gtk_cell_renderer_text_new ();
+      combo = gtk_combo_box_new_with_model (cell_combo->model);
+      gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
+      gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), 
+				      cell, "text", cell_combo->text_column, 
+				      NULL);
+
+      /* determine the current value */
+      search_data.cell = cell_combo;
+      search_data.found = FALSE;
+      gtk_tree_model_foreach (cell_combo->model, find_text, &search_data);
+      if (search_data.found)
+	gtk_combo_box_set_active_iter (combo, &(search_data.iter));
+    }
+
+  g_object_set (combo, "has_frame", FALSE, NULL);
+  g_object_set_data_full (G_OBJECT (combo),
+			  GTK_CELL_RENDERER_COMBO_PATH,
+			  g_strdup (path), g_free);
+
+  gtk_widget_show (combo);
+
+  g_signal_connect (GTK_CELL_EDITABLE (combo), "editing_done",
+		    G_CALLBACK (gtk_cell_renderer_combo_editing_done),
+		    cell_combo);
+  cell_combo->focus_out_id = 
+    g_signal_connect (combo, "focus_out_event",
+		      G_CALLBACK (gtk_cell_renderer_combo_focus_out_event),
+		      cell_combo);
+
+  return GTK_CELL_EDITABLE (combo);
+}

gtk/gtkcellrenderercombo.h

+/* GtkCellRendererCombo
+ * Copyright (C) 2004 Lorenzo Gil Sanchez
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef GTK_CELL_RENDERER_COMBO_H
+#define GTK_CELL_RENDERER_COMBO_H
+
+#include <gtk/gtktreemodel.h>
+#include <gtk/gtkcellrenderertext.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_CELL_RENDERER_COMBO		(gtk_cell_renderer_combo_get_type ())
+#define GTK_CELL_RENDERER_COMBO(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_COMBO, GtkCellRendererCombo))
+#define GTK_CELL_RENDERER_COMBO_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_COMBO, GtkCellRendererComboClass))
+#define GTK_IS_CELL_RENDERER_COMBO(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_COMBO))
+#define GTK_IS_CELL_RENDERER_COMBO_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_COMBO))
+#define GTK_CELL_RENDERER_COMBO_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_COMBO, GtkCellRendererTextClass))
+						 
+typedef struct _GtkCellRendererCombo GtkCellRendererCombo;
+typedef struct _GtkCellRendererComboClass GtkCellRendererComboClass;
+
+struct _GtkCellRendererCombo
+{
+  GtkCellRendererText parent;
+
+  GtkTreeModel *model;
+  gint          text_column;
+  gboolean      has_entry;
+  
+  /*< private >*/
+  guint         focus_out_id;
+};
+
+struct _GtkCellRendererComboClass
+{
+  GtkCellRendererTextClass parent;
+};
+
+GType            gtk_cell_renderer_combo_get_type (void);
+GtkCellRenderer *gtk_cell_renderer_combo_new      (void);
+
+G_END_DECLS
+
+#endif

gtk/gtkcombobox.h

@@ -115,6 +115,9 @@ gchar        *gtk_combo_box_get_active_text  (GtkComboBox     *combo_box);
 void          gtk_combo_box_popup            (GtkComboBox     *combo_box);
 void          gtk_combo_box_popdown          (GtkComboBox     *combo_box);
 
+/* private */
+gboolean     _gtk_combo_box_editing_canceled (GtkComboBox     *combo_box);
+
 G_END_DECLS
 
 #endif /* __GTK_COMBO_BOX_H__ */

gtk/gtkcomboboxentry.c

@@ -54,6 +54,9 @@ static void gtk_combo_box_entry_contents_changed (GtkEntry              *entry,
                                                   gpointer               user_data);
 static gboolean gtk_combo_box_entry_mnemonic_activate (GtkWidget        *entry,
 						       gboolean          group_cycling);
+static void has_frame_changed                    (GtkComboBoxEntry      *entry_box,
+						  GParamSpec            *pspec,
+						  gpointer               data);
 
 enum
 {
@@ -125,6 +128,9 @@ gtk_combo_box_entry_init (GtkComboBoxEntry *entry_box)
   entry_box->priv->text_column = -1;
 
   entry_box->priv->entry = gtk_entry_new ();
+  /* this flag is a hack to tell the entry to fill its allocation.
+   */
+  GTK_ENTRY (entry_box->priv->entry)->is_cell_renderer = TRUE;
   gtk_container_add (GTK_CONTAINER (entry_box), entry_box->priv->entry);
   gtk_widget_show (entry_box->priv->entry);
 
@@ -139,6 +145,8 @@ gtk_combo_box_entry_init (GtkComboBoxEntry *entry_box)
                     entry_box);
   g_signal_connect (entry_box, "changed",
                     G_CALLBACK (gtk_combo_box_entry_active_changed), NULL);
+  has_frame_changed (entry_box, NULL, NULL);
+  g_signal_connect (entry_box, "notify::has-frame", G_CALLBACK (has_frame_changed), NULL);
 }
 
 static void
@@ -217,6 +225,18 @@ gtk_combo_box_entry_active_changed (GtkComboBox *combo_box,
                                      combo_box);
 }
 
+static void 
+has_frame_changed (GtkComboBoxEntry *entry_box,
+		   GParamSpec       *pspec,
+		   gpointer          data)
+{
+  gboolean has_frame;
+  
+  g_object_get (entry_box, "has_frame", &has_frame, NULL);
+
+  gtk_entry_set_has_frame (GTK_ENTRY (entry_box->priv->entry), has_frame);
+}
+
 static void
 gtk_combo_box_entry_contents_changed (GtkEntry *entry,
                                       gpointer  user_data)

gtk/gtkmarshalers.list

@@ -38,6 +38,7 @@ BOOLEAN:VOID
 BOOLEAN:BOOLEAN
 BOOLEAN:NONE
 BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN
+BOOLEAN:STRING
 ENUM:ENUM
 INT:POINTER
 NONE:BOOLEAN

gtk/gtktreeview.c

@@ -6784,7 +6784,7 @@ gtk_tree_view_put (GtkTreeView *tree_view,
 		   gint         height)
 {
   GtkTreeViewChild *child;
-
+  
   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
   g_return_if_fail (GTK_IS_WIDGET (child_widget));
 
@@ -6800,7 +6800,7 @@ gtk_tree_view_put (GtkTreeView *tree_view,
 
   if (GTK_WIDGET_REALIZED (tree_view))
     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
-
+  
   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
 }
 
@@ -12355,7 +12355,9 @@ gtk_tree_view_remove_widget (GtkCellEditable *cell_editable,
     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
 
   gtk_container_remove (GTK_CONTAINER (tree_view),
-			GTK_WIDGET (cell_editable));
+			GTK_WIDGET (cell_editable));  
+  /* FIXME should only redraw a single node */
+  gtk_widget_queue_draw (GTK_WIDGET (tree_view));
 }
 
 static gboolean