- Refactor GladePalette code slightly - Selector button can now be hidden.

	* src/glade-palette.[ch]:
	  - Refactor GladePalette code slightly
	  - Selector button can now be hidden.
	  - Palette items are now implemented as toggle buttons.

	* src/glade-palette-item.[ch]: GladePaletteItem is now a
	  subclass of GtkToggleButton instead of GtkRadioButton.

	* src/glade-app.c, src/glade-fixed.c, src/glade-placeholder.c:
	  update for change in GladePalette API.

	* src/glade-design-layout.c: Improved drawing code.

	* src/glade-project-window.c:
	  - Refactored recent files code.
	  - Added "Widget Selector" button to main toolbar. Is an
	    external selector button for the palette
	  - Fixed #373255 - "Doesn't warn about unsaved document
	    on quit"

	* pixmaps/selector.png: New selector button.

11 files changed, 414 insertions, 251 deletions

diff --git a/ChangeLog b/ChangeLog
index 99685c81..d19a2c9a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,27 @@
+2006-12-03  Vincent Geddes <vincent.geddes@gmail.com>
+
+	* src/glade-palette.[ch]:
+	  - Refactor GladePalette code slightly
+	  - Selector button can now be hidden.
+	  - Palette items are now implemented as toggle buttons.
+	
+	* src/glade-palette-item.[ch]: GladePaletteItem is now a
+	  subclass of GtkToggleButton instead of GtkRadioButton.
+	  
+	* src/glade-app.c, src/glade-fixed.c, src/glade-placeholder.c:
+	  update for change in GladePalette API.
+	  
+	* src/glade-design-layout.c: Improved drawing code.
+	
+	* src/glade-project-window.c:
+	  - Refactored recent files code.
+	  - Added "Widget Selector" button to main toolbar. Is an
+	    external selector button for the palette
+	  - Fixed #373255 - "Doesn't warn about unsaved document
+	    on quit"
+
+	* pixmaps/selector.png: New selector button.
+
 2006-11-30  Juan Pablo Ugarte <juanpablougarte@gmail.com>
 
 	* widgets/gnome.xml.in: removed glade_gnome_about_dialog_get_children()
diff --git a/pixmaps/selector.png b/pixmaps/selector.png
index 3ac980b6..b945618c 100644
--- a/pixmaps/selector.png
+++ b/pixmaps/selector.png
diff --git a/src/glade-app.c b/src/glade-app.c
index 040f6591..24f4f76c 100644
--- a/src/glade-app.c
+++ b/src/glade-app.c
@@ -278,7 +278,7 @@ on_palette_button_clicked (GladePalette *palette, GladeApp *app)
 						    app->priv->accel_group);
 		}
 
-		glade_palette_deselect_current_item (palette);
+		glade_palette_deselect_current_item (palette, FALSE);
 	}
 }
 
@@ -339,7 +339,7 @@ glade_app_init (GladeApp *app)
 	app->priv->catalogs = glade_catalog_load_all ();
 	
 	/* Create palette */
-	app->priv->palette = (GladePalette *) glade_palette_new (app->priv->catalogs, GLADE_ITEM_ICON_ONLY);
+	app->priv->palette = (GladePalette *) glade_palette_new (app->priv->catalogs);
 	g_object_ref (app->priv->palette);
 	gtk_object_sink (GTK_OBJECT (app->priv->palette));
 	gtk_widget_show_all (GTK_WIDGET (app->priv->palette));
diff --git a/src/glade-design-layout.c b/src/glade-design-layout.c
index 691d8efd..1658ff3a 100644
--- a/src/glade-design-layout.c
+++ b/src/glade-design-layout.c
@@ -23,7 +23,6 @@
  */
 
 #include "glade-design-layout.h"
-
 #include "glade.h"
 
 #include <gtk/gtk.h>
@@ -123,7 +122,8 @@ glade_design_layout_get_pointer_region (GladeDesignLayout *layout, int x, int y)
 }
 
 
-
+/* this handler ensures that the user cannot
+ * resize a widget below it minimum acceptable size */
 static void
 child_size_request_handler (GtkWidget         *widget,
 			    GtkRequisition    *req,
@@ -160,11 +160,9 @@ child_size_request_handler (GtkWidget         *widget,
 
 		if (old_height > new_height)
 			widget->requisition.height = old_height;
-
-		gtk_widget_queue_draw (GTK_WIDGET (layout));
 	}
 	
-
+	gtk_widget_queue_draw (GTK_WIDGET (layout));
 	
 }
 
@@ -225,7 +223,6 @@ glade_design_layout_handle_event (GladeDesignLayout *layout, GdkEvent* ev)
 			glade_widget_property_set_enabled (child_glade_widget, "default-width", TRUE);
 			glade_widget_property_set (child_glade_widget, "default-width", new_width, NULL);
 			
-			gtk_widget_queue_draw (widget);
 		}
 		else if (priv->activity == GLADE_ACTIVITY_RESIZE_HEIGHT)
 		{
@@ -240,7 +237,6 @@ glade_design_layout_handle_event (GladeDesignLayout *layout, GdkEvent* ev)
 			glade_widget_property_set_enabled (child_glade_widget, "default-height", TRUE);
 			glade_widget_property_set (child_glade_widget, "default-height", new_height, NULL);
 					     
-			gtk_widget_queue_draw (widget);
 		}
 		else if (priv->activity == GLADE_ACTIVITY_RESIZE_WIDTH_AND_HEIGHT)
 		{
@@ -262,7 +258,6 @@ glade_design_layout_handle_event (GladeDesignLayout *layout, GdkEvent* ev)
 			glade_widget_property_set (child_glade_widget, "default-width", new_width, NULL);
 			glade_widget_property_set (child_glade_widget, "default-height", new_height, NULL);
 								     
-			gtk_widget_queue_draw (widget);
 		}
 		else
 		{
@@ -632,20 +627,39 @@ glade_design_layout_finalize (GObject *object)
 	G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
+/* creates a gc to draw a nice border around the child */
+GdkGC*
+create_outline_gc (GtkWidget *widget)
+{
+	GdkGC *gc;
+	GdkGCValues values;
+
+	gc = gdk_gc_new (widget->window);
+	
+	/* we want the light_gc values as a start */
+	gdk_gc_copy (gc, widget->style->light_gc[GTK_STATE_SELECTED]);
+
+	values.line_width = OUTLINE_WIDTH;
+	gdk_gc_set_values (gc, &values, GDK_GC_LINE_WIDTH);
+
+	return gc;
+}
+
+
 static gboolean
 glade_design_layout_expose_event (GtkWidget *widget, GdkEventExpose *ev)
 {
 	GladeDesignLayout *layout;
-	GdkGC *outline_gc;
-	GdkGCValues gc_values;
+	GdkGC *gc;
 	GtkWidget *child;
-	double x, y, w, h;
+	int x, y, w, h;
 	int border_width;
 
 	layout = GLADE_DESIGN_LAYOUT (widget);
 
 	border_width = GTK_CONTAINER (widget)->border_width;
 
+	/* draw a white widget background */
 	gdk_draw_rectangle (widget->window,
 			    widget->style->base_gc [GTK_WIDGET_STATE (widget)],
 			    TRUE,
@@ -663,26 +677,23 @@ glade_design_layout_expose_event (GtkWidget *widget, GdkEventExpose *ev)
 		w = child->allocation.width + OUTLINE_WIDTH;
 		h = child->allocation.height + OUTLINE_WIDTH;
 
-		/* configure outline_gc */
-		outline_gc = gdk_gc_new (widget->window);
-		gdk_gc_copy (outline_gc, widget->style->light_gc[GTK_STATE_SELECTED]);
-		gc_values.line_width = OUTLINE_WIDTH;
-		gdk_gc_set_values (outline_gc, &gc_values, GDK_GC_LINE_WIDTH);
+		gc = create_outline_gc (widget);
 
+		/* draw outline around child */
 		gdk_draw_rectangle (widget->window,
-				    outline_gc,
+				    gc,
 				    FALSE,
 				    x, y, w, h);
-				    
-		g_object_unref (outline_gc);
 
-		if (GTK_WIDGET_NO_WINDOW (child))
-			gdk_draw_rectangle (widget->window,
-					    widget->style->bg_gc[GTK_STATE_NORMAL],
-					    TRUE,
-					    child->allocation.x, child->allocation.y, 
-					    child->allocation.width, child->allocation.height);
+		/* draw a filled rectangle in case child does not draw 
+		 * it's own background (a GTK_WIDGET_NO_WINDOW child). */
+		gdk_draw_rectangle (widget->window,
+				    widget->style->fg_gc[GTK_STATE_NORMAL],
+				    TRUE,
+				    x + OUTLINE_WIDTH / 2, y + OUTLINE_WIDTH / 2, 
+				    w - OUTLINE_WIDTH, h - OUTLINE_WIDTH);
 
+		g_object_unref (gc);
 	}	
 
 	return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, ev);
diff --git a/src/glade-fixed.c b/src/glade-fixed.c
index 03ae468b..60f9f32a 100644
--- a/src/glade-fixed.c
+++ b/src/glade-fixed.c
@@ -883,8 +883,8 @@ glade_fixed_event (GtkWidget   *widget,
 						      GLADE_WIDGET (fixed)->project);
 				fixed->creating = FALSE;
 				
-				/* reset the palette */
-				glade_palette_deselect_current_item (glade_app_get_palette ());
+				glade_palette_deselect_current_item (glade_app_get_palette(), TRUE);
+					
 				handled = TRUE;
 			}
 		}
diff --git a/src/glade-palette-item.c b/src/glade-palette-item.c
index 5125c36f..57ec6bd5 100644
--- a/src/glade-palette-item.c
+++ b/src/glade-palette-item.c
@@ -62,9 +62,11 @@ enum
 };
 
 
-static GtkRadioButton *parent_class = NULL;
+static GtkToggleButton *parent_class = NULL;
 
 
+G_DEFINE_TYPE(GladePaletteItem, glade_palette_item, GTK_TYPE_TOGGLE_BUTTON)
+
 static void
 glade_palette_item_update_appearance (GladePaletteItem *item)
 {
@@ -279,7 +281,7 @@ glade_palette_item_init (GladePaletteItem *item)
 {
 	GladePaletteItemPrivate *priv;
 
-	priv = GLADE_PALETTE_ITEM_GET_PRIVATE (item);
+	priv = item->priv = GLADE_PALETTE_ITEM_GET_PRIVATE (item);
 
 	priv->label = NULL;
 	priv->adaptor = NULL;
@@ -312,32 +314,6 @@ glade_palette_item_init (GladePaletteItem *item)
 	gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (item), FALSE);
 }
 
-GType
-glade_palette_item_get_type (void)
-{
-	static GType type = 0;
-
-	if (!type)
-	{
-		static const GTypeInfo info =
-		{
-			sizeof (GladePaletteItemClass),
-			(GBaseInitFunc) NULL,
-			(GBaseFinalizeFunc) NULL,
-			(GClassInitFunc) glade_palette_item_class_init,
-			(GClassFinalizeFunc) NULL,
-			NULL,
-			sizeof (GladePaletteItem),
-			0,
-			(GInstanceInitFunc) glade_palette_item_init
-		};
-
-		type = g_type_register_static (GTK_TYPE_RADIO_BUTTON, "GladePaletteItem", &info, 0);
-	}
-
-	return type;
-}
-
 /**
  * glade_palette_item_new:
  * @adaptor: A #GladeWidgetAdaptor
@@ -347,7 +323,7 @@ glade_palette_item_get_type (void)
  * Returns: A #GtkWidget
  */
 GtkWidget*
-glade_palette_item_new (GladeWidgetAdaptor *adaptor, GtkRadioButton *group)
+glade_palette_item_new (GladeWidgetAdaptor *adaptor)
 {
 	GladePaletteItem        *item;
 	GladePaletteItemPrivate *priv;
@@ -356,7 +332,6 @@ glade_palette_item_new (GladeWidgetAdaptor *adaptor, GtkRadioButton *group)
 	g_return_val_if_fail (GLADE_IS_WIDGET_ADAPTOR (adaptor), NULL);
 
 	item = g_object_new (GLADE_TYPE_PALETTE_ITEM,
-			     "group", group,
 			     "adaptor", adaptor,
 			     "appearance", GLADE_ITEM_ICON_ONLY,
 			     NULL);
diff --git a/src/glade-palette-item.h b/src/glade-palette-item.h
index 1da37d60..639a4445 100644
--- a/src/glade-palette-item.h
+++ b/src/glade-palette-item.h
@@ -31,7 +31,7 @@
 #include "glade-palette.h"
 #include "glade-widget-adaptor.h"
 
-#include <gtk/gtkradiobutton.h>
+#include <gtk/gtktogglebutton.h>
 
 G_BEGIN_DECLS
 
@@ -57,29 +57,30 @@ enum _GladeItemAppearance {
 
 struct _GladePaletteItem
 {
-	GtkRadioButton button; /* The parent is a radio button */
+	GtkToggleButton button; /* The parent is a radio button */
+	
+	GladePaletteItemPrivate *priv;
 
 };
 
 struct _GladePaletteItemClass
 {
-	GtkRadioButtonClass parent_class;
+	GtkToggleButtonClass parent_class;
 
 
 };
 
 GType                 glade_palette_item_get_type (void) G_GNUC_CONST;
 
-GtkWidget            *glade_palette_item_new (GladeWidgetAdaptor *adaptor, 
-					      GtkRadioButton     *group);
+GtkWidget            *glade_palette_item_new (GladeWidgetAdaptor *adaptor);
 
-GladeWidgetAdaptor   *glade_palette_item_get_adaptor (GladePaletteItem *item) G_GNUC_CONST;
+GladeWidgetAdaptor   *glade_palette_item_get_adaptor (GladePaletteItem *item);
 
-GladeItemAppearance   glade_palette_item_get_appearance (GladePaletteItem *item) G_GNUC_CONST;
+GladeItemAppearance   glade_palette_item_get_appearance (GladePaletteItem *item);
 
 void		      glade_palette_item_set_appearance (GladePaletteItem *item, GladeItemAppearance appearance);
 
-gboolean              glade_palette_item_get_use_small_icon (GladePaletteItem *item) G_GNUC_CONST;
+gboolean              glade_palette_item_get_use_small_icon (GladePaletteItem *item);
 
 void		      glade_palette_item_set_use_small_icon (GladePaletteItem *item, gboolean use_small_icon);
 
diff --git a/src/glade-palette.c b/src/glade-palette.c
index 5aa44ab4..cc0f896b 100644
--- a/src/glade-palette.c
+++ b/src/glade-palette.c
@@ -50,23 +50,25 @@ struct _GladePalettePrivate
 {
 	const GList *catalogs;        /* List of widget catalogs */
 
-	GtkWidget *selector;    /* Selector item button */
+	GtkWidget *selector_hbox;	
+	GtkWidget *selector_button;
+
 	GtkWidget *tray;	/* Where all the item groups are contained */
 
-	GladeWidgetAdaptor *current_item; /* The currently selected item adaptor */
+	GladePaletteItem *current_item; /* The currently selected item */
 
 	GSList *sections;   	         /* List of GladePaletteExpanders */ 
-	GSList *items_radio_group;       /* Radio group for palette item buttons */
 
 	GtkTooltips *tooltips;           /* Tooltips for the item buttons */
-	GtkTooltips *selector_tooltips;  /* Tooltip for the selector */
+	GtkTooltips *static_tooltips;    /* These tooltips never get disabled */
 
-	GtkSizeGroup *size_group;        /* All items have the same width */
+	GtkSizeGroup *size_group;        /* All items have the same dimensions */
 
 	GladeItemAppearance item_appearance;
 
 	gboolean use_small_item_icons;
-	gboolean locked; /* Wheater the palette should "stick" the selector */
+	
+	gboolean sticky_selection_mode; /* whether sticky_selection mode has been enabled */
 };
 
 enum
@@ -80,18 +82,64 @@ enum
 	PROP_0,
 	PROP_CURRENT_ITEM,
 	PROP_ITEM_APPEARANCE,
-	PROP_USE_SMALL_ITEM_ICONS
+	PROP_USE_SMALL_ITEM_ICONS,
+	PROP_SHOW_SELECTOR_BUTTON,
+	PROP_CATALOGS
 };
 
 static guint glade_palette_signals[LAST_SIGNAL] = {0};
 
-static void glade_palette_append_item_group (GladePalette     *palette, 
-					       GladeWidgetGroup *group);
+static void glade_palette_append_item_group (GladePalette *palette, GladeWidgetGroup *group);
 
 static void glade_palette_update_appearance (GladePalette *palette);
 
 static GtkVBoxClass *parent_class = NULL;
 
+
+G_DEFINE_TYPE(GladePalette, glade_palette, GTK_TYPE_VBOX)
+
+void
+selector_button_toggled_cb (GtkToggleButton *button, GladePalette *palette)
+{
+	if (gtk_toggle_button_get_active (button))
+	{
+		glade_palette_deselect_current_item (palette, FALSE);
+	}
+	else if (glade_palette_get_current_item (palette) == FALSE)
+	{
+		gtk_toggle_button_set_active (button, TRUE);
+	}
+}
+
+static void
+glade_palette_set_catalogs (GladePalette *palette, GList *catalogs)
+{
+	GladePalettePrivate *priv;
+	GList *l;
+
+	g_return_if_fail (GLADE_IS_PALETTE (palette));
+	priv = GLADE_PALETTE_GET_PRIVATE (palette);
+
+	priv->catalogs = catalogs;
+
+	for (l = (GList *) priv->catalogs; l; l = l->next) 
+	{
+		GList *groups = glade_catalog_get_widget_groups (GLADE_CATALOG (l->data));
+
+		for (; groups; groups = groups->next)
+		{
+			GladeWidgetGroup *group = GLADE_WIDGET_GROUP (groups->data);
+
+			if (glade_widget_group_get_adaptors (group)) 
+				glade_palette_append_item_group (palette, group);
+		}
+	}
+	
+	gtk_widget_show_all (priv->tray);
+	
+	g_object_unref (priv->size_group);
+}
+
 /**
  * glade_palette_set_item_appearance:
  * @palette: a #GladePalette
@@ -142,6 +190,33 @@ glade_palette_set_use_small_item_icons (GladePalette *palette, gboolean use_smal
 
 }
 
+/**
+ * glade_palette_set_show_selector_button:
+ * @palette: a #GladePalette
+ * @show_selector_button: whether to show selector button
+ *
+ * Sets whether to show the internal widget selector button
+ */
+void
+glade_palette_set_show_selector_button (GladePalette *palette, gboolean show_selector_button)
+{
+	GladePalettePrivate *priv;
+	g_return_if_fail (GLADE_IS_PALETTE (palette));
+	priv = GLADE_PALETTE_GET_PRIVATE (palette);
+
+	if (GTK_WIDGET_VISIBLE (priv->selector_hbox) != show_selector_button)
+	{
+		if (show_selector_button)
+			gtk_widget_show (priv->selector_hbox);
+		else
+			gtk_widget_hide (priv->selector_hbox);
+			
+		g_object_notify (G_OBJECT (palette), "show-selector-button");
+		
+	}
+
+}
+
 static void 
 glade_palette_set_property (GObject *object,
 		            guint prop_id,
@@ -158,6 +233,12 @@ glade_palette_set_property (GObject *object,
 		case PROP_ITEM_APPEARANCE:
 			glade_palette_set_item_appearance (palette, g_value_get_enum (value));
 			break;
+		case PROP_SHOW_SELECTOR_BUTTON:
+			glade_palette_set_show_selector_button (palette, g_value_get_boolean (value));
+			break;
+		case PROP_CATALOGS:
+			glade_palette_set_catalogs (palette, g_value_get_pointer (value));
+			break;
 		default:
 			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 		break;
@@ -176,14 +257,20 @@ glade_palette_get_property (GObject    *object,
 	switch (prop_id)
 	{
 		case PROP_CURRENT_ITEM:
-			g_value_set_pointer (value, (gpointer) priv->current_item);
+			g_value_set_pointer (value, (gpointer) glade_palette_item_get_adaptor (priv->current_item));
 			break;
 		case PROP_USE_SMALL_ITEM_ICONS:
 			g_value_set_boolean (value, priv->use_small_item_icons);
 			break;
+		case PROP_SHOW_SELECTOR_BUTTON:
+			g_value_set_boolean (value, GTK_WIDGET_VISIBLE (priv->selector_button));
+			break;
 		case PROP_ITEM_APPEARANCE:
 			g_value_set_enum (value, priv->item_appearance);
 			break;
+		case PROP_CATALOGS:
+			g_value_set_pointer (value, (gpointer) priv->catalogs);
+			break;
 		default:
 			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 			break;			
@@ -203,7 +290,7 @@ glade_palette_dispose (GObject *object)
 	priv->catalogs = NULL;
 
 	g_object_unref (priv->tooltips);
-	g_object_unref (priv->selector_tooltips);
+	g_object_unref (priv->static_tooltips);
 
 	G_OBJECT_CLASS (parent_class)->dispose (object);
 
@@ -233,6 +320,7 @@ glade_palette_class_init (GladePaletteClass *class)
 	parent_class = g_type_class_peek_parent (class);
 
 	class->toggled = NULL;
+	
 	object_class->get_property = glade_palette_get_property;
 	object_class->set_property = glade_palette_set_property;
 	object_class->dispose = glade_palette_dispose;
@@ -266,47 +354,70 @@ glade_palette_class_init (GladePaletteClass *class)
 							       G_PARAM_READWRITE));
 
 	g_object_class_install_property (object_class,
+					 PROP_ITEM_APPEARANCE,
+					 g_param_spec_boolean ("show-selector-button",
+							       "Show Selector Button",
+							       "Whether to show the internal selector button",
+							       TRUE,
+							       G_PARAM_READWRITE));
+
+	g_object_class_install_property (object_class,
 					 PROP_CURRENT_ITEM,
 					 g_param_spec_pointer  ("current-item",
 							        "Current Item Class",
 							        "The GladeWidgetAdaptor of the currently selected item",
 							        G_PARAM_READABLE));
+							        
+	g_object_class_install_property (object_class,
+					 PROP_CATALOGS,
+					 g_param_spec_pointer  ("catalogs",
+							        "Widget catalogs",
+							        "The widget catalogs for the palette",
+							        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
 
 	g_type_class_add_private (object_class, sizeof (GladePalettePrivate));
 }
 
-
 static void
 glade_palette_on_button_toggled (GtkWidget *button, GladePalette *palette)
 {
 	GladePalettePrivate *priv;
-
+	GdkModifierType mask;
+	GladeWidgetAdaptor *adaptor;
+	
 	g_return_if_fail (GLADE_IS_PALETTE (palette));
 	g_return_if_fail (GTK_IS_TOGGLE_BUTTON (button));
 	priv = GLADE_PALETTE_GET_PRIVATE (palette);
 
-	/* we are interested only in buttons which toggle from inactive to active */
-	if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
-		return;
-
-	if (button == priv->selector)
+	/* if we are toggling currently active item into non-active state */
+	if (priv->current_item == GLADE_PALETTE_ITEM (button))
 	{
 		priv->current_item = NULL;
-		priv->locked = FALSE;
-	}
-	else
-	{
-		GdkModifierType mask;
-		
-		priv->current_item = 
-			glade_palette_item_get_adaptor (GLADE_PALETTE_ITEM (button));
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selector_button), TRUE);	
+
+		priv->sticky_selection_mode = FALSE;
 		
-		gdk_window_get_pointer (button->window, NULL, NULL, &mask);
+		g_signal_emit (G_OBJECT (palette), glade_palette_signals[TOGGLED], 0);
 
-	  	priv->locked = 
-			(! GWA_IS_TOPLEVEL (priv->current_item)) && (mask & GDK_CONTROL_MASK);
+		return;
 	}
 
+	/* now we are interested only in buttons which toggle from inactive to active */
+	if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
+		return;
+	
+	if (priv->current_item && (GLADE_PALETTE_ITEM (button) != priv->current_item))
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->current_item), FALSE);
+		
+	priv->current_item = GLADE_PALETTE_ITEM (button);
+	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selector_button), FALSE);	
+	
+	/* check whether to enable sticky selection */
+	adaptor = glade_palette_item_get_adaptor (GLADE_PALETTE_ITEM (button));	
+	gdk_window_get_pointer (button->window, NULL, NULL, &mask);
+  	priv->sticky_selection_mode = (!GWA_IS_TOPLEVEL (adaptor)) && (mask & GDK_CONTROL_MASK);
+
+
 	g_signal_emit (G_OBJECT (palette), glade_palette_signals[TOGGLED], 0);
 }
 
@@ -320,7 +431,7 @@ glade_palette_new_item (GladePalette *palette, GladeWidgetAdaptor *adaptor)
 	g_return_val_if_fail (GLADE_IS_WIDGET_ADAPTOR (adaptor), NULL);
 	priv = GLADE_PALETTE_GET_PRIVATE (palette);
 
-	item = glade_palette_item_new (adaptor, GTK_RADIO_BUTTON (priv->selector));
+	item = glade_palette_item_new (adaptor);
 
 	glade_palette_item_set_appearance (GLADE_PALETTE_ITEM (item), priv->item_appearance);
 
@@ -444,109 +555,92 @@ glade_palette_update_appearance (GladePalette *palette)
 }
 
 static GtkWidget*
-glade_palette_selector_new (GladePalette *palette)
+glade_palette_create_selector_button (GladePalette *palette)
 {
-	GladePalettePrivate *priv;
-	GtkWidget *hbox;
+	GtkWidget *selector;
 	GtkWidget *image;
 	gchar *path;
 
-	priv = GLADE_PALETTE_GET_PRIVATE (palette);
-
-	hbox = gtk_hbox_new (FALSE, 0);
-	gtk_container_set_border_width (GTK_CONTAINER (hbox), 1);
-
-	/* Create selector button */
-	priv->selector = gtk_radio_button_new (priv->items_radio_group);
+	/* create selector button */
+	selector = gtk_toggle_button_new ();
+	
+	gtk_container_set_border_width (GTK_CONTAINER (selector), 0);
 
 	path = g_build_filename (glade_pixmaps_dir, "selector.png", NULL);
 	image = gtk_image_new_from_file (path);
-	g_free (path);
+	gtk_widget_show (image);
 	
-	gtk_container_add (GTK_CONTAINER (priv->selector), image);
-	gtk_button_set_relief (GTK_BUTTON (priv->selector), GTK_RELIEF_NONE);
-	gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (priv->selector), FALSE);
-	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selector), TRUE);
-
-	gtk_tooltips_set_tip (priv->selector_tooltips, priv->selector, _("Widget Selector"), NULL);
+	gtk_container_add (GTK_CONTAINER (selector), image);
+	gtk_button_set_relief (GTK_BUTTON (selector), GTK_RELIEF_NONE);
+	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (selector), TRUE);
 
-	g_signal_connect (G_OBJECT (priv->selector), "toggled",
-			  G_CALLBACK (glade_palette_on_button_toggled), 
+	g_signal_connect (G_OBJECT (selector), "toggled",
+			  G_CALLBACK (selector_button_toggled_cb), 
 			  palette);
 
-	/* Pack button into hbox */
-	gtk_box_pack_start (GTK_BOX (hbox), priv->selector, FALSE, FALSE, 1);
-
+	g_free (path);
 
-	return hbox;
+	return selector;
 }
 
 static void
 glade_palette_init (GladePalette *palette)
 {
 	GladePalettePrivate *priv;
-	GtkWidget *widget;
+	GtkWidget *sw;
 
-	priv = GLADE_PALETTE_GET_PRIVATE (palette);
+	priv = palette->priv = GLADE_PALETTE_GET_PRIVATE (palette);
 
 	priv->catalogs = NULL;
 	priv->current_item = NULL;
-	priv->items_radio_group = NULL;
 	priv->sections = NULL;
 	priv->item_appearance = GLADE_ITEM_ICON_ONLY;
 	priv->use_small_item_icons = FALSE;
+	priv->sticky_selection_mode = FALSE;
 
+	/* create selector button */
+	priv->selector_button = glade_palette_create_selector_button (palette);
+	priv->selector_hbox = gtk_hbox_new (FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (priv->selector_hbox), priv->selector_button, FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (palette), priv->selector_hbox, FALSE, FALSE, 0);
+	gtk_widget_show (priv->selector_button);
+	gtk_widget_show (priv->selector_hbox);
 
-	/* Create tooltips */
+	/* create tooltips */
 	priv->tooltips = gtk_tooltips_new ();
 	g_object_ref (priv->tooltips);
 	gtk_object_sink (GTK_OBJECT (priv->tooltips));
+	priv->static_tooltips = gtk_tooltips_new ();
+	g_object_ref (priv->static_tooltips);
+	gtk_object_sink (GTK_OBJECT (priv->static_tooltips));
 
-	priv->selector_tooltips = gtk_tooltips_new ();
-	g_object_ref (priv->selector_tooltips);
-	gtk_object_sink (GTK_OBJECT (priv->selector_tooltips));
-
-
-	/* Create Selector */
-	widget = glade_palette_selector_new (palette);
-	gtk_box_pack_start (GTK_BOX (palette), widget, FALSE, FALSE, 0);
+	gtk_tooltips_set_tip (priv->static_tooltips, priv->selector_button, _("Widget selector"), NULL);
 
+	/* create size group */
+	priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+	gtk_size_group_set_ignore_hidden (priv->size_group, FALSE);
 
-	/* Add items tray (via a scrolled window) */
+	/* add items tray (via a scrolled window) */
 	priv->tray = gtk_vbox_new (FALSE, 0);
 	g_object_ref (G_OBJECT (priv->tray));
 	gtk_object_sink (GTK_OBJECT (priv->tray));
 	gtk_container_set_border_width (GTK_CONTAINER (priv->tray), 1);
+	
+	sw = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+					GTK_POLICY_NEVER,
+					GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), priv->tray);
+	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+					     GTK_SHADOW_NONE);
 
-	/* Create Size Group */
-	priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
-	gtk_size_group_set_ignore_hidden (priv->size_group, FALSE);
-}
-
-GType
-glade_palette_get_type (void)
-{
-	static GType type = 0;
+	gtk_box_pack_start (GTK_BOX (palette), sw, TRUE, TRUE, 0);
 
-	if (!type)
-	{
-		static const GTypeInfo info =
-		{
-			sizeof (GladePaletteClass),
-			(GBaseInitFunc) NULL,
-			(GBaseFinalizeFunc) NULL,
-			(GClassInitFunc) glade_palette_class_init,
-			(GClassFinalizeFunc) NULL,
-			NULL,
-			sizeof (GladePalette),
-			0,
-			(GInstanceInitFunc) glade_palette_init
-		};
-
-		type = g_type_register_static (GTK_TYPE_VBOX, "GladePalette", &info, 0);
-	}
 
-	return type;
+	gtk_widget_show (sw);
+	gtk_widget_show (priv->tray);
+	
+	gtk_widget_set_no_show_all (GTK_WIDGET (palette), TRUE);
 }
 
 /**
@@ -561,89 +655,68 @@ glade_palette_get_type (void)
 GladeWidgetAdaptor *
 glade_palette_get_current_item (GladePalette *palette)
 {
-	GladePalettePrivate *priv;
 	g_return_val_if_fail (GLADE_IS_PALETTE (palette), NULL);
-	priv = GLADE_PALETTE_GET_PRIVATE (palette);
-
 
-	return priv->current_item;
+	if (palette->priv->current_item)
+	{
+		return glade_palette_item_get_adaptor (palette->priv->current_item);
+	}
+	else
+	{
+		return NULL;
+	}
 
 }
 
 /**
  * glade_palette_new:
  * @catalogs: the widget catalogs for the palette.
- * @item_appearance: the appearance of the palette items.
  *
  * Creates a new #GladePalette widget
  *
  * Returns: a new #GladePalette
  */
 GtkWidget*
-glade_palette_new (const GList *catalogs, GladeItemAppearance item_appearance)
+glade_palette_new (const GList *catalogs)
 {
 	GladePalette *palette;
-	GladePalettePrivate *priv;
-	GtkWidget *sw;
-	GList *l;
 
 	g_return_val_if_fail (catalogs != NULL, NULL);
 
 	palette = g_object_new (GLADE_TYPE_PALETTE,
 				"spacing", 2, 
-				"item-appearance", item_appearance,
+				"item-appearance", GLADE_ITEM_ICON_ONLY,
+				"catalogs", catalogs,
 				NULL);
 
-	g_return_val_if_fail (palette != NULL, NULL);
-
-	priv = GLADE_PALETTE_GET_PRIVATE (palette);
-
-	priv->catalogs = catalogs;
-
-	for (l = (GList *) priv->catalogs; l; l = l->next) 
-	{
-		GList *groups = glade_catalog_get_widget_groups (GLADE_CATALOG (l->data));
-
-		for (; groups; groups = groups->next)
-		{
-			GladeWidgetGroup *group = GLADE_WIDGET_GROUP (groups->data);
-
-			if (glade_widget_group_get_adaptors (group)) 
-				glade_palette_append_item_group (palette, group);
-		}
-	}
-
-	sw = gtk_scrolled_window_new (NULL, NULL);
-	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
-					GTK_POLICY_NEVER,
-					GTK_POLICY_AUTOMATIC);
-	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), priv->tray);
-	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
-					     GTK_SHADOW_NONE);
-
-	gtk_box_pack_start (GTK_BOX (palette), sw, TRUE, TRUE, 0);
-
-	g_object_unref (priv->size_group);
-
 	return GTK_WIDGET (palette);
 }
 
 /**
  * glade_palette_deselect_current_item:
  * @palette: a #GladePalette
+ * @sticky_aware: whether to consider sticky selection mode
  *
  * Deselects the currently selected item
  */
 void
-glade_palette_deselect_current_item (GladePalette *palette)
+glade_palette_deselect_current_item (GladePalette *palette, gboolean sticky_aware)
 {
-	GladePalettePrivate *priv;
 	g_return_if_fail (GLADE_IS_PALETTE (palette));
-	priv = GLADE_PALETTE_GET_PRIVATE (palette);
 
-	if (priv->locked == FALSE)
-		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selector),
-					      TRUE);
+	if (sticky_aware && palette->priv->sticky_selection_mode)
+		return;
+
+	if (palette->priv->current_item)
+	{
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (palette->priv->current_item), FALSE);
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (palette->priv->selector_button), TRUE);		
+		
+		palette->priv->current_item = NULL;
+
+		g_signal_emit (G_OBJECT (palette), glade_palette_signals[TOGGLED], 0);
+	}
+	
 }
 
 /**
@@ -654,13 +727,10 @@ glade_palette_deselect_current_item (GladePalette *palette)
  */
 GladeItemAppearance
 glade_palette_get_item_appearance (GladePalette *palette)
-{
-	GladePalettePrivate *priv;
-	g_return_val_if_fail (GLADE_IS_PALETTE (palette), 
-			      GLADE_ITEM_ICON_ONLY);
-	priv = GLADE_PALETTE_GET_PRIVATE (palette);
+{;
+	g_return_val_if_fail (GLADE_IS_PALETTE (palette), GLADE_ITEM_ICON_ONLY);
 
-	return priv->item_appearance;
+	return palette->priv->item_appearance;
 }
 
 /**
@@ -672,9 +742,21 @@ glade_palette_get_item_appearance (GladePalette *palette)
 gboolean
 glade_palette_get_use_small_item_icons (GladePalette *palette)
 {
-	GladePalettePrivate *priv;
 	g_return_val_if_fail (GLADE_IS_PALETTE (palette), FALSE);
-	priv = GLADE_PALETTE_GET_PRIVATE (palette);
 
-	return priv->use_small_item_icons;
+	return palette->priv->use_small_item_icons;
+}
+
+/**
+ * glade_palette_get_show_selector_button:
+ * @palette: a #GladePalette
+ *
+ * Returns: Whether the selector button is visible
+ */
+gboolean
+glade_palette_get_show_selector_button (GladePalette *palette)
+{
+	g_return_val_if_fail (GLADE_IS_PALETTE (palette), FALSE);
+
+	return GTK_WIDGET_VISIBLE (palette->priv->selector_hbox);
 }
diff --git a/src/glade-palette.h b/src/glade-palette.h
index f6501d76..58645372 100644
--- a/src/glade-palette.h
+++ b/src/glade-palette.h
@@ -51,6 +51,7 @@ struct _GladePalette
 {
 	GtkVBox vbox; /* The parent is a vbox */
 
+	GladePalettePrivate *priv;
 };
 
 struct _GladePaletteClass
@@ -64,27 +65,29 @@ LIBGLADEUI_API
 GType                glade_palette_get_type (void) G_GNUC_CONST;
 
 LIBGLADEUI_API
-GtkWidget           *glade_palette_new (const GList         *catalogs, 
-					GladeItemAppearance  item_appearance);
+GtkWidget           *glade_palette_new (const GList *catalogs);
 
 LIBGLADEUI_API
-void                 glade_palette_deselect_current_item (GladePalette *palette);
+void                 glade_palette_deselect_current_item (GladePalette *palette, gboolean sticky_aware);
 
 LIBGLADEUI_API
-GladeWidgetAdaptor  *glade_palette_get_current_item (GladePalette *palette) G_GNUC_CONST;
+GladeWidgetAdaptor  *glade_palette_get_current_item (GladePalette *palette);
 
 LIBGLADEUI_API
-GladeItemAppearance  glade_palette_get_item_appearance (GladePalette *palette) G_GNUC_CONST;
+GladeItemAppearance  glade_palette_get_item_appearance (GladePalette *palette);
 
 LIBGLADEUI_API
 void                 glade_palette_set_item_appearance (GladePalette *palette, GladeItemAppearance appearance);
 
 LIBGLADEUI_API
-gboolean             glade_palette_get_use_small_item_icons (GladePalette *palette) G_GNUC_CONST;
+gboolean             glade_palette_get_use_small_item_icons (GladePalette *palette);
 
 LIBGLADEUI_API
 void		     glade_palette_set_use_small_item_icons (GladePalette *palette, gboolean use_small_item_icons);
 
+LIBGLADEUI_API
+void		     glade_palette_set_show_selector_button (GladePalette *palette, gboolean show_selector_button);
+
 G_END_DECLS
 
 #endif /* __GLADE_PALETTE_H__ */
diff --git a/src/glade-placeholder.c b/src/glade-placeholder.c
index 19d81d8b..9556a690 100644
--- a/src/glade-placeholder.c
+++ b/src/glade-placeholder.c
@@ -331,8 +331,7 @@ glade_placeholder_button_press (GtkWidget *widget, GdkEventButton *event)
 				 glade_placeholder_get_parent (placeholder),
 				 placeholder, project);
 
-			/* reset the palette */
-			glade_palette_deselect_current_item (palette);
+			glade_palette_deselect_current_item (glade_app_get_palette(), TRUE);
 
 			/* reset the cursor */
 			glade_cursor_set (event->window, GLADE_CURSOR_SELECTOR);
diff --git a/src/glade-project-window.c b/src/glade-project-window.c
index 0b03af9f..5044f644 100644
--- a/src/glade-project-window.c
+++ b/src/glade-project-window.c
@@ -74,6 +74,9 @@ struct _GladeProjectWindowPrivate
 	GtkWidget *console;
 
 	gchar *default_path; /* the default path for open/save operations */
+	
+	GtkToggleToolButton *selector_button; /* the widget selector button (replaces the one in the palette) */
+	
 };
 
 const gint   GLADE_WIDGET_TREE_WIDTH      = 230;
@@ -157,13 +160,32 @@ gpw_window_state_event_cb (GtkWidget *widget,
 	return FALSE;
 }
 
+static GtkWidget *
+create_recent_chooser_menu (GladeProjectWindow *gpw, GtkRecentManager *manager)
+{
+	GtkWidget *recent_menu;
+	GtkRecentFilter *filter;
+
+	recent_menu = gtk_recent_chooser_menu_new_for_manager (manager);
+
+	gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (recent_menu), TRUE);
+	gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (recent_menu), FALSE);
+	gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (recent_menu), GTK_RECENT_SORT_MRU);
+	gtk_recent_chooser_menu_set_show_numbers (GTK_RECENT_CHOOSER_MENU (recent_menu), TRUE);
+
+	filter = gtk_recent_filter_new ();
+	gtk_recent_filter_add_application (filter, g_get_application_name());
+	gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (recent_menu), filter);
+
+	return recent_menu;
+}
+
 static void
 gpw_window_screen_changed_cb (GtkWidget *widget,
 			      GdkScreen *old_screen,
 			      GladeProjectWindow *gpw)
 {
 	GtkWidget *menu_item;
-	GtkRecentFilter *filter;
 	GdkScreen *screen;
 
 	screen = gtk_widget_get_screen (widget);	
@@ -173,15 +195,7 @@ gpw_window_screen_changed_cb (GtkWidget *widget,
 	gtk_menu_detach (GTK_MENU (gpw->priv->recent_menu));
 	g_object_unref (G_OBJECT (gpw->priv->recent_menu));
 	
-	gpw->priv->recent_menu = gtk_recent_chooser_menu_new_for_manager (gpw->priv->recent_manager);
-
-	gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), TRUE);
-	gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), FALSE);
-	gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), GTK_RECENT_SORT_MRU);
-
-	filter = gtk_recent_filter_new ();
-	gtk_recent_filter_add_application (filter, g_get_application_name());
-	gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), filter);
+	gpw->priv->recent_menu = create_recent_chooser_menu (gpw, gpw->priv->recent_manager);
 
 	g_signal_connect (gpw->priv->recent_menu,
 			  "item-activated",
@@ -385,6 +399,24 @@ gpw_construct_dock_item (GladeProjectWindow *gpw, const gchar *title, GtkWidget
 	return vbox;
 }
 
+void
+on_palette_toggled (GladePalette *palette, GladeProjectWindow *gpw)
+{
+	if (glade_palette_get_current_item (palette))
+		gtk_toggle_tool_button_set_active (gpw->priv->selector_button, FALSE);	
+	else
+		gtk_toggle_tool_button_set_active (gpw->priv->selector_button, TRUE);			
+}
+
+void
+on_selector_button_toggled (GtkToggleToolButton *button, GladeProjectWindow *gpw)
+{
+	if (gtk_toggle_tool_button_get_active (gpw->priv->selector_button))
+		glade_palette_deselect_current_item (glade_app_get_palette(), FALSE);
+	else if (glade_palette_get_current_item (glade_app_get_palette()) == FALSE)
+		gtk_toggle_tool_button_set_active (gpw->priv->selector_button, TRUE);
+}
+
 static void
 gpw_set_sensitivity_according_to_project (GladeProjectWindow *window, GladeProject *project)
 {
@@ -918,7 +950,7 @@ gpw_close_cb (GtkAction *action, GladeProjectWindow *gpw)
 static void
 gpw_quit_cb (GtkAction *action, GladeProjectWindow *gpw)
 {
-/*	GList *list;
+	GList *list;
 
 	for (list = glade_app_get_projects (); list; list = list->next)
 	{
@@ -935,10 +967,11 @@ gpw_quit_cb (GtkAction *action, GladeProjectWindow *gpw)
 	while (glade_app_get_projects ())
 	{
 		GladeProject *project = GLADE_PROJECT (glade_app_get_projects ()->data);
-		do_close (gpw, project);
+		do_close (gpw, glade_design_view_get_from_project (project));
 	}
-*/
+
 	gtk_main_quit ();
+
 }
 
 static void
@@ -1706,6 +1739,33 @@ gpw_delete_event (GtkWindow *w, GdkEvent *event, GladeProjectWindow *gpw)
 	return TRUE;	
 }
 
+static GtkWidget *
+create_selector_tool_button (GtkToolbar *toolbar)
+{
+	GtkToolItem  *button;
+	GtkWidget    *image;
+	gchar        *image_path;
+	
+	image_path = g_build_filename (glade_pixmaps_dir, "selector.png", NULL);
+	image = gtk_image_new_from_file (image_path);
+	g_free (image_path);
+	
+	button = gtk_toggle_tool_button_new ();
+	gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (button), TRUE);
+	
+	gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (button), image);
+	
+	gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (button),
+				   toolbar->tooltips,
+				   _("Select a widget"),
+				   NULL);
+	
+	gtk_widget_show (GTK_WIDGET (button));
+	gtk_widget_show (image);
+	
+	return GTK_WIDGET (button);
+}
+
 static void
 glade_project_window_create (GladeProjectWindow *gpw)
 {
@@ -1723,7 +1783,7 @@ glade_project_window_create (GladeProjectWindow *gpw)
 	GtkWidget *editor;
 	GtkWidget *dockitem;
 	GtkWidget *widget;
-	GtkRecentFilter *filter;
+	GtkToolItem *sep;
 
 	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 	gpw->priv->window = window;
@@ -1754,9 +1814,9 @@ glade_project_window_create (GladeProjectWindow *gpw)
 	gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned, FALSE, FALSE);
 
 	/* divider position between design area and editor/tree */
-	gtk_paned_set_position (GTK_PANED (hpaned1), 370);
+	gtk_paned_set_position (GTK_PANED (hpaned1), 350);
 	/* divider position between tree and editor */	
-	gtk_paned_set_position (GTK_PANED (vpaned), 135);
+	gtk_paned_set_position (GTK_PANED (vpaned), 150);
 
 
 	gtk_widget_show_all (hpaned1);
@@ -1765,6 +1825,7 @@ glade_project_window_create (GladeProjectWindow *gpw)
 
 	/* palette */
 	palette = GTK_WIDGET (glade_app_get_palette ());
+	glade_palette_set_show_selector_button (GLADE_PALETTE (palette), FALSE);
 	dockitem = gpw_construct_dock_item (gpw, _("Palette"), palette);
 	gtk_paned_pack1 (GTK_PANED (hpaned2), dockitem, FALSE, FALSE);
 
@@ -1775,7 +1836,7 @@ glade_project_window_create (GladeProjectWindow *gpw)
 	gtk_paned_pack2 (GTK_PANED (hpaned2), gpw->priv->notebook, TRUE, FALSE);
 	gtk_widget_show (gpw->priv->notebook);
 
-	/* project view */	
+	/* project view */
 	project_view = GLADE_PROJECT_VIEW (glade_project_view_new ());
 	glade_app_add_project_view (project_view);
 	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (project_view),
@@ -1791,7 +1852,7 @@ glade_project_window_create (GladeProjectWindow *gpw)
 	gpw->priv->label = GTK_LABEL (g_object_get_data (G_OBJECT (dockitem), "dock-label"));
 	gtk_label_set_ellipsize	(GTK_LABEL (gpw->priv->label), PANGO_ELLIPSIZE_END);
 	gtk_misc_set_alignment (GTK_MISC (gpw->priv->label), 0, 0.5);
-	gtk_paned_pack2 (GTK_PANED (vpaned), dockitem, FALSE, FALSE);
+	gtk_paned_pack2 (GTK_PANED (vpaned), dockitem, TRUE, FALSE);
 
 	/* status bar */
 	statusbar = gpw_construct_statusbar (gpw);
@@ -1816,15 +1877,7 @@ glade_project_window_create (GladeProjectWindow *gpw)
 	/* recent files */	
 	gpw->priv->recent_manager = gtk_recent_manager_get_for_screen (gtk_widget_get_screen (gpw->priv->window));
 
-	gpw->priv->recent_menu = gtk_recent_chooser_menu_new_for_manager (gpw->priv->recent_manager);
-
-	gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), TRUE);
-	gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), FALSE);
-	gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), GTK_RECENT_SORT_MRU);
-
-	filter = gtk_recent_filter_new ();
-	gtk_recent_filter_add_application (filter, g_get_application_name());
-	gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (gpw->priv->recent_menu), filter);
+	gpw->priv->recent_menu = create_recent_chooser_menu (gpw, gpw->priv->recent_manager);
 
 	g_signal_connect (gpw->priv->recent_menu,
 			  "item-activated",
@@ -1834,6 +1887,21 @@ glade_project_window_create (GladeProjectWindow *gpw)
 	widget = gtk_ui_manager_get_widget (gpw->priv->ui, "/MenuBar/FileMenu/OpenRecent");
 	gtk_menu_item_set_submenu (GTK_MENU_ITEM (widget), gpw->priv->recent_menu);		  
 	
+	/* palette selector button */
+	
+	gpw->priv->selector_button = GTK_TOGGLE_TOOL_BUTTON (create_selector_tool_button (GTK_TOOLBAR (toolbar)));	
+	
+	sep = gtk_separator_tool_item_new();
+	gtk_widget_show (GTK_WIDGET (sep));
+	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (sep), -1);
+	
+	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (gpw->priv->selector_button), -1);
+	
+	g_signal_connect (G_OBJECT (glade_app_get_palette ()), "toggled",
+			  G_CALLBACK (on_palette_toggled), gpw);
+	g_signal_connect (G_OBJECT (gpw->priv->selector_button), "toggled",
+			  G_CALLBACK (on_selector_button_toggled), gpw);
+	
 	
 	/* support for opening a file by dragging onto the project window */
 	gtk_drag_dest_set (GTK_WIDGET (window),