/* -*- Mode: C; c-file-style: "gnu"; tab-width: 8 -*- */
/* gtkassistant.c
 *
 * 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 <gtk/gtk.h>
#include <gtk/gtkintl.h>
#include "gtkassistant.h"

#define GTK_ASSISTANT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_ASSISTANT, GtkAssistantPrivate))

typedef struct _GtkAssistantPage GtkAssistantPage;

struct _GtkAssistantPage
{
  GtkWidget *page;
  GtkAssistantPageType type;
  gboolean   complete;

  gchar     *title;
  GdkPixbuf *header_image;
  GdkPixbuf *sidebar_image;
};

typedef struct _GtkAssistantPrivate GtkAssistantPrivate;

struct _GtkAssistantPrivate
{
  GtkWidget *header;
  GtkWidget *header_box;
  GtkWidget *header_title;
  GtkWidget *header_image;

  GtkWidget *sidebar;
  GtkWidget *sidebar_image;

  GtkWidget *action_area;

  GList     *pages;
  GtkAssistantPage *current_page;

  GSList    *visited_pages;

  GtkSizeGroup *size_group;

  GtkAssistantPageFunc forward_function;
  gpointer forward_function_data;
  GDestroyNotify forward_data_destroy;
};

static void gtk_assistant_class_init (GtkAssistantClass *class);
static void gtk_assistant_init       (GtkAssistant      *assistant);
static void gtk_assistant_destroy    (GtkObject         *object);

static void gtk_assistant_style_set     (GtkWidget      *widget,
					 GtkStyle       *old_style);
static void gtk_assistant_size_request  (GtkWidget      *widget,
					 GtkRequisition *requisition);
static void gtk_assistant_size_allocate (GtkWidget      *widget,
					 GtkAllocation  *allocation);
static void gtk_assistant_map           (GtkWidget      *widget);
static void gtk_assistant_unmap         (GtkWidget      *widget);
static gboolean gtk_assistant_delete_event (GtkWidget   *widget,
					    GdkEventAny *event);

static void gtk_assistant_add    (GtkContainer *container,
				  GtkWidget    *page);
static void gtk_assistant_remove (GtkContainer *container,
				  GtkWidget    *page);
static void gtk_assistant_forall (GtkContainer *container,
				  gboolean      include_internals,
				  GtkCallback   callback,
				  gpointer      callback_data);

static void gtk_assistant_set_child_property (GtkContainer      *container,
					      GtkWidget         *child,
					      guint              property_id,
					      const GValue      *value,
					      GParamSpec        *pspec);
static void gtk_assistant_get_child_property (GtkContainer      *container,
					      GtkWidget         *child,
					      guint              property_id,
					      GValue            *value,
					      GParamSpec        *pspec);
enum
{
  CHILD_PROP_0,
  CHILD_PROP_PAGE_TYPE,
  CHILD_PROP_PAGE_TITLE,
  CHILD_PROP_PAGE_HEADER_IMAGE,
  CHILD_PROP_PAGE_SIDEBAR_IMAGE,
  CHILD_PROP_PAGE_COMPLETE
};

enum
{
  CANCEL,
  PREPARE,
  APPLY,
  CLOSE,
  LAST_SIGNAL
};

static guint signals [LAST_SIGNAL] = { 0 };


G_DEFINE_TYPE (GtkAssistant, gtk_assistant, GTK_TYPE_WINDOW);


static void
gtk_assistant_class_init (GtkAssistantClass *class)
{
  GObjectClass *gobject_class;
  GtkObjectClass *object_class;
  GtkWidgetClass *widget_class;
  GtkContainerClass *container_class;

  gobject_class   = (GObjectClass *) class;
  object_class    = (GtkObjectClass *) class;
  widget_class    = (GtkWidgetClass *) class;
  container_class = (GtkContainerClass *) class;

  object_class->destroy = gtk_assistant_destroy;

  widget_class->style_set = gtk_assistant_style_set;
  widget_class->size_request = gtk_assistant_size_request;
  widget_class->size_allocate = gtk_assistant_size_allocate;
  widget_class->map = gtk_assistant_map;
  widget_class->unmap = gtk_assistant_unmap;
  widget_class->delete_event = gtk_assistant_delete_event;

  container_class->add = gtk_assistant_add;
  container_class->remove = gtk_assistant_remove;
  container_class->forall = gtk_assistant_forall;
  container_class->set_child_property = gtk_assistant_set_child_property;
  container_class->get_child_property = gtk_assistant_get_child_property;

  /**
   * GtkAssistant::cancel:
   * @assistant: the #GtkAssistant
   * @page: the current page
   *
   * The ::cancel signal is emitted when then the cancel button is clicked.
   */
  signals[CANCEL] =
    g_signal_new ("cancel",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkAssistantClass, cancel),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);
    
  /**
   * GtkAssistant::prepare:
   * @assistant: the #GtkAssistant
   * @page: the current page
   *
   * The ::prepared signal is emitted when a new page is set as the assistant's 
   * current page, before making the new page visible. A handler for this signal 
   * can do any preparation which are necessary before showing @page.
   */
  signals[PREPARE] =
    g_signal_new ("prepare",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkAssistantClass, prepare),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GTK_TYPE_WIDGET);

  /**
   * GtkAssistant::apply:
   * @assistant: the @GtkAssistant
   * @page: the current page
   *
   * The ::apply signal is emitted when the apply button is clicked. The default
   * behavior of the #GtkAssistant is to switch to the page after the current page,
   * unless the current page is the last one.
   *
   * A handler for the ::apply signal should carry out the actions for which the
   * wizard has collected data. If the action takes a long time to complete, you
   * might consider to put a page displaying the progress of the operation after the
   * confirmation page with the apply button.
   *
   * Return value: %TRUE to suppress the default behavior
   */
  signals[APPLY] =
    g_signal_new ("apply",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkAssistantClass, apply),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);

  /**
   * GtkAssistant::close:
   * @assistant: the #GtkAssistant
   * @page: the current page
   *
   * The ::close signal is emitted when the close button is clicked.
   */
  signals[CLOSE] =
    g_signal_new ("close",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GtkAssistantClass, close),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);

  gtk_widget_class_install_style_property (widget_class,
					   g_param_spec_int ("header_padding",
							     P_("Header Padding"),
							     P_("Number of pixels around the header."),
							     0,
							     G_MAXINT,
							     0,
							     G_PARAM_READABLE));

  gtk_container_class_install_child_property (container_class,
					      CHILD_PROP_PAGE_TYPE,
					      g_param_spec_enum ("page_type", 
								 P_("Page type"),
								 P_("The type of the assistant page"),
								 GTK_TYPE_ASSISTANT_PAGE_TYPE,
								 GTK_ASSISTANT_PAGE_CONTENT,
								 G_PARAM_READWRITE));
  gtk_container_class_install_child_property (container_class,
					      CHILD_PROP_PAGE_TITLE,
					      g_param_spec_string ("title", 
								   P_("Page title"),
								   P_("The title of the assistant page"),
								   NULL,
								   G_PARAM_READWRITE));
  gtk_container_class_install_child_property (container_class,
					      CHILD_PROP_PAGE_HEADER_IMAGE,
					      g_param_spec_object ("header_image", 
								   P_("Header image"),
								   P_("Header image for the assistant page"),
								   GDK_TYPE_PIXBUF,
								   G_PARAM_READWRITE));
  gtk_container_class_install_child_property (container_class,
					      CHILD_PROP_PAGE_SIDEBAR_IMAGE,
					      g_param_spec_object ("sidebar_image", 
								   P_("Sidebar image"),
								   P_("Sidebar image for the assistant page"),
								   GDK_TYPE_PIXBUF,
								   G_PARAM_READWRITE));
  /**
   * GtkAssistant:complete:
   *
   * Setting the ::complete property to %TRUE will mark a page as complete
   * (i.e.: all the required fields are filled out) and let the assistant
   * know whether to set sensitive the "forward" button or not.
   **/
  gtk_container_class_install_child_property (container_class,
					      CHILD_PROP_PAGE_COMPLETE,
					      g_param_spec_boolean ("complete", 
								    P_("Page complete"),
								    P_("Whether all required fields on the page have been filled out"),
								    FALSE,
								    G_PARAM_READWRITE));

  g_type_class_add_private (gobject_class, sizeof (GtkAssistantPrivate));
}

static gint
default_forward_function (gint current_page, gpointer data)
{
  GtkAssistant *assistant;
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *page_node;

  assistant = GTK_ASSISTANT (data);
  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  page_node = g_list_nth (priv->pages, ++current_page);

  if (!page_node)
    return -1;

  page_info = (GtkAssistantPage *) page_node->data;

  while (!GTK_WIDGET_VISIBLE (page_info->page))
    {
      page_node = page_node->next;
      page_info = (GtkAssistantPage *) page_node->data;
      current_page++;
    }

  return current_page;
}

static void
compute_last_button_state (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  gint count, page_num, n_pages;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  count = 0;
  page_num = gtk_assistant_get_current_page (assistant);
  n_pages  = gtk_assistant_get_n_pages (assistant);
  page_info = g_list_nth_data (priv->pages, page_num);

  while ((page_num > 0 && page_num < n_pages) &&
	 (page_info->type == GTK_ASSISTANT_PAGE_CONTENT) &&
	 (page_info->complete))
    {
      page_num  = (priv->forward_function) (page_num, priv->forward_function_data);
      page_info = g_list_nth_data (priv->pages, page_num);
      count++;
    }

  if (count > 1)
    gtk_widget_show (assistant->last);
  else
    gtk_widget_hide (assistant->last);
}

static void
_set_assistant_title (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  gtk_label_set_text (GTK_LABEL (priv->header_title), priv->current_page->title);
}

static void
_set_assistant_header_image (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  gtk_image_set_from_pixbuf (GTK_IMAGE (priv->header_image),
			     priv->current_page->header_image);
}

static void
_set_assistant_sidebar_image (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  gtk_image_set_from_pixbuf (GTK_IMAGE (priv->sidebar_image),
			     priv->current_page->sidebar_image);

  if (priv->current_page->sidebar_image)
    gtk_widget_show (priv->sidebar);
  else
    gtk_widget_hide (priv->sidebar);
}

static void
_set_assistant_buttons_state (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  switch (priv->current_page->type)
    {
    case GTK_ASSISTANT_PAGE_INTRO:
      gtk_widget_set_sensitive (assistant->cancel, TRUE);
      gtk_widget_set_sensitive (assistant->forward, priv->current_page->complete);
      gtk_widget_show (assistant->cancel);
      gtk_widget_show (assistant->forward);
      gtk_widget_hide (assistant->back);
      gtk_widget_hide (assistant->apply);
      gtk_widget_hide (assistant->close);
      compute_last_button_state (assistant);
      break;
    case GTK_ASSISTANT_PAGE_CONFIRM:
      gtk_widget_set_sensitive (assistant->cancel, TRUE);
      gtk_widget_set_sensitive (assistant->back, TRUE);
      gtk_widget_set_sensitive (assistant->apply, priv->current_page->complete);
      gtk_widget_show (assistant->cancel);
      gtk_widget_show (assistant->back);
      gtk_widget_show (assistant->apply);
      gtk_widget_hide (assistant->forward);
      gtk_widget_hide (assistant->close);
      gtk_widget_hide (assistant->last);
      break;
    case GTK_ASSISTANT_PAGE_CONTENT:
      gtk_widget_set_sensitive (assistant->cancel, TRUE);
      gtk_widget_set_sensitive (assistant->back, TRUE);
      gtk_widget_set_sensitive (assistant->forward, priv->current_page->complete);
      gtk_widget_show (assistant->cancel);
      gtk_widget_show (assistant->back);
      gtk_widget_show (assistant->forward);
      gtk_widget_hide (assistant->apply);
      gtk_widget_hide (assistant->close);
      compute_last_button_state (assistant);
      break;
    case GTK_ASSISTANT_PAGE_SUMMARY:
      gtk_widget_set_sensitive (assistant->close, TRUE);
      gtk_widget_show (assistant->close);
      gtk_widget_hide (assistant->cancel);
      gtk_widget_hide (assistant->back);
      gtk_widget_hide (assistant->forward);
      gtk_widget_hide (assistant->apply);
      gtk_widget_hide (assistant->last);
      break;
    case GTK_ASSISTANT_PAGE_PROGRESS:
      gtk_widget_set_sensitive (assistant->cancel, priv->current_page->complete);
      gtk_widget_set_sensitive (assistant->back, priv->current_page->complete);
      gtk_widget_set_sensitive (assistant->forward, priv->current_page->complete);
      gtk_widget_show (assistant->cancel);
      gtk_widget_show (assistant->back);
      gtk_widget_show (assistant->forward);
      gtk_widget_hide (assistant->apply);
      gtk_widget_hide (assistant->close);
      gtk_widget_hide (assistant->last);
      break;
    default:
      g_assert_not_reached ();
    }

  /* this is quite general, we don't want to
   * go back if it's the first page */
  if (!priv->visited_pages)
    gtk_widget_hide (assistant->back);
}

static void
_set_current_page (GtkAssistant     *assistant,
		   GtkAssistantPage *page)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *old_page;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  if (priv->current_page &&
      GTK_WIDGET_VISIBLE (priv->current_page->page) &&
      GTK_WIDGET_MAPPED  (priv->current_page->page))
    old_page = priv->current_page;
  else
    old_page = NULL;

  priv->current_page = page;

  _set_assistant_buttons_state (assistant);
  _set_assistant_title (assistant);
  _set_assistant_header_image (assistant);
  _set_assistant_sidebar_image (assistant);

  g_signal_emit (assistant, signals [PREPARE], 0, priv->current_page->page);

  if (GTK_WIDGET_VISIBLE (priv->current_page->page) && GTK_WIDGET_MAPPED (assistant))
    gtk_widget_map (priv->current_page->page);
  
  if (old_page && GTK_WIDGET_MAPPED (old_page->page))
    gtk_widget_unmap (old_page->page);
}

static gint
compute_next_step (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  gint current_page, n_pages, next_page;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  current_page = gtk_assistant_get_current_page (assistant);
  page_info = priv->current_page;
  n_pages = gtk_assistant_get_n_pages (assistant);

  next_page = (priv->forward_function) (current_page,
					priv->forward_function_data);

  if (next_page >= 0 && next_page < n_pages)
    {
      priv->visited_pages = g_slist_prepend (priv->visited_pages, page_info);
      _set_current_page (assistant, g_list_nth_data (priv->pages, next_page));

      return TRUE;
    }

  return FALSE;
}

static void
on_assistant_close (GtkWidget *widget, GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);
  g_signal_emit (assistant, signals [CLOSE], 0, NULL);
}

static void
on_assistant_apply (GtkWidget *widget, GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;
  gboolean success;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);
  success = compute_next_step (assistant);

  g_signal_emit (assistant, signals [APPLY], 0, priv->current_page->page);

  /* if the assistant hasn't switched to another page, just emit
   * the CLOSE signal, it't the last page in the assistant flow
   */
  if (!success)
    g_signal_emit (assistant, signals [CLOSE], 0, priv->current_page->page);
}

static void
on_assistant_forward (GtkWidget *widget, GtkAssistant *assistant)
{
  if (!compute_next_step (assistant))
    g_critical ("Page flow is broken, you may want to end it with a page of "
		"type GTK_ASSISTANT_PAGE_CONFIRM or GTK_ASSISTANT_PAGE_SUMMARY");
}

static void
on_assistant_back (GtkWidget *widget, GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GSList *page_node;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  /* skip the progress pages when going back */
  do
    {
      page_node = priv->visited_pages;

      g_return_if_fail (page_node != NULL);

      priv->visited_pages = priv->visited_pages->next;
      page_info = (GtkAssistantPage *) page_node->data;
      g_slist_free_1 (page_node);
    }
  while (page_info->type == GTK_ASSISTANT_PAGE_PROGRESS ||
	 !GTK_WIDGET_VISIBLE (page_info->page));

  _set_current_page (assistant, page_info);
}

static void
on_assistant_cancel (GtkWidget *widget, GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);
  g_signal_emit (assistant, signals [CANCEL], 0, NULL);
}

static void
on_assistant_last (GtkWidget *widget, GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  while (priv->current_page->type == GTK_ASSISTANT_PAGE_CONTENT &&
	 priv->current_page->complete)
    compute_next_step (assistant);
}

static gboolean
alternative_button_order (GtkAssistant *assistant)
{
  GtkSettings *settings;
  GdkScreen *screen;
  gboolean result;

  screen   = gtk_widget_get_screen (GTK_WIDGET (assistant));
  settings = gtk_settings_get_for_screen (screen);

  g_object_get (settings,
		"gtk-alternative-button-order", &result,
		NULL);
  return result;
}

static void
gtk_assistant_init (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  gtk_widget_push_composite_child ();

  /* Header */
  priv->header = gtk_event_box_new ();
  priv->header_box = gtk_hbox_new (FALSE, 12);
  priv->header_title = gtk_label_new (NULL);
  priv->header_image = gtk_image_new ();

  gtk_misc_set_alignment (GTK_MISC (priv->header_title), 0.0, 0.0);
  gtk_box_pack_start (GTK_BOX (priv->header_box), priv->header_title, TRUE, TRUE, 0);
  gtk_box_pack_end   (GTK_BOX (priv->header_box), priv->header_image, FALSE, FALSE, 0);
  gtk_container_add  (GTK_CONTAINER (priv->header), priv->header_box);
  gtk_container_set_border_width (GTK_CONTAINER (priv->header_box), 6);
  gtk_widget_set_parent (priv->header, GTK_WIDGET (assistant));
  gtk_widget_show_all (priv->header);

  /* Sidebar */
  priv->sidebar = gtk_event_box_new ();
  priv->sidebar_image = gtk_image_new ();

  gtk_container_add (GTK_CONTAINER (priv->sidebar), priv->sidebar_image);
  gtk_widget_set_parent (priv->sidebar, GTK_WIDGET (assistant));
  gtk_widget_show (priv->sidebar_image);

  /* Action area */
  priv->action_area  = gtk_hbox_new (FALSE, 12);
  gtk_container_set_border_width (GTK_CONTAINER (priv->action_area), 6);
  assistant->close   = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
  assistant->apply   = gtk_button_new_from_stock (GTK_STOCK_APPLY);
  assistant->forward = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
  assistant->back    = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
  assistant->cancel  = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
  assistant->last    = gtk_button_new_from_stock (GTK_STOCK_GOTO_LAST);

  priv->size_group   = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
  gtk_size_group_add_widget (priv->size_group, assistant->close);
  gtk_size_group_add_widget (priv->size_group, assistant->apply);
  gtk_size_group_add_widget (priv->size_group, assistant->forward);
  gtk_size_group_add_widget (priv->size_group, assistant->back);
  gtk_size_group_add_widget (priv->size_group, assistant->cancel);
  gtk_size_group_add_widget (priv->size_group, assistant->last);

  if (!alternative_button_order (assistant))
    {
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->close, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->apply, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->forward, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->back, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->cancel, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->last, FALSE, FALSE, 0);
    }
  else
    {
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->cancel, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->close, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->apply, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->forward, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->back, FALSE, FALSE, 0);
      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->last, FALSE, FALSE, 0);
    }

  gtk_widget_set_parent (priv->action_area, GTK_WIDGET (assistant));
  gtk_widget_show (assistant->forward);
  gtk_widget_show (assistant->back);
  gtk_widget_show (assistant->cancel);
  gtk_widget_show (priv->action_area);

  gtk_widget_pop_composite_child ();

  priv->pages = NULL;
  priv->current_page = NULL;
  priv->visited_pages = NULL;

  priv->forward_function = default_forward_function;
  priv->forward_function_data = assistant;
  priv->forward_data_destroy = NULL;

  g_signal_connect (G_OBJECT (assistant->close), "clicked",
		    G_CALLBACK (on_assistant_close), assistant);
  g_signal_connect (G_OBJECT (assistant->apply), "clicked",
		    G_CALLBACK (on_assistant_apply), assistant);
  g_signal_connect (G_OBJECT (assistant->forward), "clicked",
		    G_CALLBACK (on_assistant_forward), assistant);
  g_signal_connect (G_OBJECT (assistant->back), "clicked",
		    G_CALLBACK (on_assistant_back), assistant);
  g_signal_connect (G_OBJECT (assistant->cancel), "clicked",
		    G_CALLBACK (on_assistant_cancel), assistant);
  g_signal_connect (G_OBJECT (assistant->last), "clicked",
		    G_CALLBACK (on_assistant_last), assistant);
}

static void
gtk_assistant_set_child_property (GtkContainer    *container,
				  GtkWidget       *child,
				  guint            property_id,
				  const GValue    *value,
				  GParamSpec      *pspec)
{
  switch (property_id)
    {
    case CHILD_PROP_PAGE_TYPE:
      gtk_assistant_set_page_type (GTK_ASSISTANT (container), child,
				   g_value_get_enum (value));
      break;
    case CHILD_PROP_PAGE_TITLE:
      gtk_assistant_set_page_title (GTK_ASSISTANT (container), child,
				    g_value_get_string (value));
      break;
    case CHILD_PROP_PAGE_HEADER_IMAGE:
      gtk_assistant_set_page_header_image (GTK_ASSISTANT (container), child,
					   g_value_get_object (value));
      break;
    case CHILD_PROP_PAGE_SIDEBAR_IMAGE:
      gtk_assistant_set_page_side_image (GTK_ASSISTANT (container), child,
					 g_value_get_object (value));
      break;
    case CHILD_PROP_PAGE_COMPLETE:
      gtk_assistant_set_page_complete (GTK_ASSISTANT (container), child,
				       g_value_get_boolean (value));
      break;
    default:
      GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
      break;
    }
}

static void
gtk_assistant_get_child_property (GtkContainer *container,
				  GtkWidget    *child,
				  guint         property_id,
				  GValue       *value,
				  GParamSpec   *pspec)
{
  switch (property_id)
    {
    case CHILD_PROP_PAGE_TYPE:
      g_value_set_enum (value,
			gtk_assistant_get_page_type (GTK_ASSISTANT (container), child));
      break;
    case CHILD_PROP_PAGE_TITLE:
      g_value_set_string (value,
			  gtk_assistant_get_page_title (GTK_ASSISTANT (container), child));
      break;
    case CHILD_PROP_PAGE_HEADER_IMAGE:
      g_value_set_object (value,
			  gtk_assistant_get_page_header_image (GTK_ASSISTANT (container), child));
      break;
    case CHILD_PROP_PAGE_SIDEBAR_IMAGE:
      g_value_set_object (value,
			  gtk_assistant_get_page_side_image (GTK_ASSISTANT (container), child));
      break;
    case CHILD_PROP_PAGE_COMPLETE:
      g_value_set_boolean (value,
			   gtk_assistant_get_page_complete (GTK_ASSISTANT (container), child));
      break;
    default:
      GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
      break;
    }
}

static void
_remove_assistant_page (GtkAssistant *assistant, GList *element)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);
  page_info = element->data;

  /* If we are mapped and visible, we want to deal with changing the page. */
  if ((GTK_WIDGET_MAPPED (page_info->page)) && (page_info == priv->current_page))
    compute_next_step (assistant);

  priv->pages = g_list_remove_link (priv->pages, element);

  g_slist_remove_all (priv->visited_pages, page_info);
  gtk_widget_unparent (page_info->page);

  if (page_info->header_image)
    g_object_unref (page_info->header_image);

  if (page_info->sidebar_image)
    g_object_unref (page_info->sidebar_image);

  g_free (page_info->title);
  g_free (page_info);
  g_list_free_1 (element);
}

static void
gtk_assistant_destroy (GtkObject *object)
{
  GtkAssistantPrivate *priv;

  /* remember, destroy can be run multiple times! */
  g_return_if_fail (GTK_IS_ASSISTANT (object));

  priv = GTK_ASSISTANT_GET_PRIVATE (object);

  if (priv->header)
    {
      gtk_widget_destroy (priv->header);
      priv->header = NULL;
    }

  if (priv->sidebar)
    {
      gtk_widget_destroy (priv->sidebar);
      priv->sidebar = NULL;
    }

  if (priv->action_area)
    {
      gtk_widget_destroy (priv->action_area);
      priv->action_area = NULL;
    }

  if (priv->size_group)
    {
      g_object_unref (priv->size_group);
      priv->size_group = NULL;
    }

  if (priv->forward_function)
    {
      if (priv->forward_function_data &&
	  priv->forward_data_destroy)
	priv->forward_data_destroy (priv->forward_function_data);

      priv->forward_function = NULL;
      priv->forward_function_data = NULL;
      priv->forward_data_destroy = NULL;
    }

  if (priv->visited_pages)
    {
      g_slist_free (priv->visited_pages);
      priv->visited_pages = NULL;
    }

  /* We set current to NULL so that the remove code doesn't try
   * to do anything funny */
  priv->current_page = NULL;

  while (priv->pages)
    _remove_assistant_page (GTK_ASSISTANT (object), priv->pages);
      
  GTK_OBJECT_CLASS (gtk_assistant_parent_class)->destroy (object);
}

static GList*
find_page (GtkAssistant  *assistant,
	   GtkWidget     *page)
{
  GtkAssistantPrivate *priv = GTK_ASSISTANT_GET_PRIVATE (assistant);
  GList *child = priv->pages;
  
  while (child)
    {
      GtkAssistantPage *page_info = child->data;
      if (page_info->page == page)
	return child;

      child = child->next;
    }
  
  return NULL;
}

static void
set_assistant_colors (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;
  GtkStyle *style;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  gtk_widget_ensure_style (GTK_WIDGET (assistant));
  style = gtk_widget_get_style (GTK_WIDGET (assistant));

  /* change colors schema, for making the header visible */
  gtk_widget_modify_bg (priv->header,  GTK_STATE_NORMAL, &style->bg[GTK_STATE_SELECTED]);
  gtk_widget_modify_bg (priv->sidebar,  GTK_STATE_NORMAL, &style->bg[GTK_STATE_SELECTED]);

  gtk_widget_modify_bg (priv->header_title, GTK_STATE_NORMAL, &style->bg[GTK_STATE_SELECTED]);
  gtk_widget_modify_fg (priv->header_title, GTK_STATE_NORMAL, &style->fg[GTK_STATE_SELECTED]);
}

static void
set_title_font (GtkAssistant *assistant)
{
  GtkAssistantPrivate  *priv;
  PangoFontDescription *desc;
  gint size;

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);
  desc = pango_font_description_new ();
  size = pango_font_description_get_size (GTK_WIDGET (assistant)->style->font_desc);

  pango_font_description_set_weight (desc, PANGO_WEIGHT_ULTRABOLD);
  pango_font_description_set_size   (desc, size * PANGO_SCALE_XX_LARGE);

  gtk_widget_modify_font (priv->header_title, desc);
  pango_font_description_free (desc);
}

static void
gtk_assistant_style_set (GtkWidget *widget,
			 GtkStyle  *old_style)
{
  set_assistant_colors (GTK_ASSISTANT (widget));
  set_title_font (GTK_ASSISTANT (widget));
}

static void
gtk_assistant_size_request (GtkWidget      *widget,
			    GtkRequisition *requisition)
{
  GtkAssistantPrivate *priv;
  GtkRequisition child_requisition;
  gint header_padding, width, height;
  GList *list;

  priv = GTK_ASSISTANT_GET_PRIVATE (widget);

  gtk_widget_style_get (widget,
			"header-padding", &header_padding,
			NULL);
  gtk_container_set_border_width (GTK_CONTAINER (priv->header), header_padding);

  width = height = 0;
  list  = priv->pages;
  
  while (list)
    {
      GtkAssistantPage *page = list->data;

      gtk_widget_size_request (page->page, &child_requisition);
      width  = MAX (width, child_requisition.width);
      height = MAX (height, child_requisition.height);

      list = list->next;
    }

  gtk_widget_size_request (priv->sidebar, &child_requisition);
  width  += child_requisition.width;
  height  = MAX (height, child_requisition.height);

  gtk_widget_size_request (priv->header, &child_requisition);
  width   = MAX (width, child_requisition.width);
  height += child_requisition.height;

  gtk_widget_size_request (priv->action_area, &child_requisition);
  width   = MAX (width, child_requisition.width);
  height += child_requisition.height;

  width += GTK_CONTAINER (widget)->border_width * 2;
  height += GTK_CONTAINER (widget)->border_width * 2;

  requisition->width = width;
  requisition->height = height;
}

static void
gtk_assistant_size_allocate (GtkWidget      *widget,
			     GtkAllocation  *allocation)
{
  GtkAssistantPrivate *priv;
  GtkAllocation child_allocation;
  gboolean rtl;
  GList *pages;

  priv  = GTK_ASSISTANT_GET_PRIVATE (widget);
  rtl   = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
  pages = priv->pages;

  widget->allocation = *allocation;

  /* Header */
  child_allocation.x = allocation->x + GTK_CONTAINER (widget)->border_width;
  child_allocation.y = allocation->y + GTK_CONTAINER (widget)->border_width;
  child_allocation.width  = allocation->width - 2 * GTK_CONTAINER (widget)->border_width;
  child_allocation.height = priv->header->requisition.height;

  gtk_widget_size_allocate (priv->header, &child_allocation);

  /* Action area */
  child_allocation.x = allocation->x + GTK_CONTAINER (widget)->border_width;
  child_allocation.y = allocation->y + allocation->height -
    GTK_CONTAINER (widget)->border_width - priv->action_area->requisition.height;
  child_allocation.width  = allocation->width - 2 * GTK_CONTAINER (widget)->border_width;
  child_allocation.height = priv->action_area->requisition.height;

  gtk_widget_size_allocate (priv->action_area, &child_allocation);

  /* Sidebar */
  if (rtl)
    child_allocation.x = allocation->x + allocation->width -
      GTK_CONTAINER (widget)->border_width - priv->sidebar->requisition.width;
  else
    child_allocation.x = allocation->x + GTK_CONTAINER (widget)->border_width;

  child_allocation.y = allocation->y + GTK_CONTAINER (widget)->border_width + priv->header->allocation.height;
  child_allocation.width = priv->sidebar->requisition.width;
  child_allocation.height = allocation->height - 2 * GTK_CONTAINER (widget)->border_width -
    priv->header->allocation.height - priv->action_area->allocation.height;

  gtk_widget_size_allocate (priv->sidebar, &child_allocation);

  /* Pages */
  if (rtl)
    child_allocation.x = allocation->x + GTK_CONTAINER (widget)->border_width;
  else
    child_allocation.x = allocation->x + GTK_CONTAINER (widget)->border_width +
      priv->sidebar->allocation.width;

  child_allocation.y = allocation->y + GTK_CONTAINER (widget)->border_width + priv->header->allocation.height;
  child_allocation.width  = allocation->width - 2 * GTK_CONTAINER (widget)->border_width -
    priv->sidebar->allocation.width;
  child_allocation.height = allocation->height - 2 * GTK_CONTAINER (widget)->border_width -
    priv->header->allocation.height - priv->action_area->allocation.height;

  while (pages)
    {
      GtkAssistantPage *page = pages->data;

      gtk_widget_size_allocate (page->page, &child_allocation);
      pages = pages->next;
    }
}

static void
gtk_assistant_map (GtkWidget *widget)
{
  GtkAssistantPrivate *priv;
  GList *page_node;

  priv = GTK_ASSISTANT_GET_PRIVATE (widget);

  GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);

  gtk_widget_map (priv->header);
  gtk_widget_map (priv->action_area);

  if (GTK_WIDGET_VISIBLE (priv->sidebar) &&
      !GTK_WIDGET_MAPPED (priv->sidebar))
    gtk_widget_map (priv->sidebar);

  /* if there's no default page, pick the first one */
  if (!priv->current_page && priv->pages)
    {
      page_node = priv->pages;

      while (!GTK_WIDGET_VISIBLE (((GtkAssistantPage *) page_node->data)->page))
	page_node = page_node->next;

      if (page_node)
	priv->current_page = page_node->data;
    }

  if (priv->current_page &&
      GTK_WIDGET_VISIBLE (priv->current_page->page) &&
      !GTK_WIDGET_MAPPED (priv->current_page->page))
    {
      _set_assistant_buttons_state ((GtkAssistant *) widget);
      _set_assistant_title ((GtkAssistant*) widget);
      _set_assistant_header_image ((GtkAssistant*) widget);
      _set_assistant_sidebar_image ((GtkAssistant*) widget);

      g_signal_emit (widget, signals [PREPARE], 0, priv->current_page->page);
      gtk_widget_map (priv->current_page->page);
    }

  GTK_WIDGET_CLASS (gtk_assistant_parent_class)->map (widget);
}

static void
gtk_assistant_unmap (GtkWidget *widget)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (widget);

  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);

  gtk_widget_unmap (priv->header);
  gtk_widget_unmap (priv->action_area);

  if (GTK_WIDGET_VISIBLE (priv->sidebar) &&
      GTK_WIDGET_MAPPED  (priv->sidebar))
    gtk_widget_unmap (priv->sidebar);

  if (priv->current_page &&
      GTK_WIDGET_VISIBLE (priv->current_page->page) &&
      GTK_WIDGET_MAPPED  (priv->current_page->page))
    gtk_widget_unmap (priv->current_page->page);

  g_slist_free (priv->visited_pages);
  priv->visited_pages = NULL;
  priv->current_page  = NULL;

  GTK_WIDGET_CLASS (gtk_assistant_parent_class)->unmap (widget);
}

static gboolean
gtk_assistant_delete_event (GtkWidget   *widget,
			    GdkEventAny *event)
{
  GtkAssistantPrivate *priv;

  priv = GTK_ASSISTANT_GET_PRIVATE (widget);

  /* Do not allow cancelling in the middle of a progress page */
  if (priv->current_page &&
      (priv->current_page->type != GTK_ASSISTANT_PAGE_PROGRESS ||
       priv->current_page->complete))
    g_signal_emit (widget, signals [CANCEL], 0, NULL);

  return TRUE;
}

static void
gtk_assistant_add (GtkContainer *container,
		   GtkWidget    *page)
{
  g_return_if_fail (GTK_IS_WIDGET (page));

  gtk_assistant_append_page (GTK_ASSISTANT (container), page);
}

static void
gtk_assistant_remove (GtkContainer *container,
		      GtkWidget    *page)
{
  GtkAssistant *assistant;
  GList *element;

  assistant = (GtkAssistant*) container;

  element = find_page (assistant, page);

  if (element)
    _remove_assistant_page (assistant, element);
}

static void
gtk_assistant_forall (GtkContainer *container,
		      gboolean      include_internals,
		      GtkCallback   callback,
		      gpointer      callback_data)
{
  GtkAssistantPrivate *priv;
  GtkAssistant *assistant;
  GList *pages;

  assistant = GTK_ASSISTANT (container);
  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  if (include_internals)
    {
      (*callback) (priv->header, callback_data);
      (*callback) (priv->sidebar, callback_data);
      (*callback) (priv->action_area, callback_data);
    }

  pages = priv->pages;

  while (pages)
    {
      GtkAssistantPage *page = (GtkAssistantPage *) pages->data;

      (*callback) (page->page, callback_data);
      pages = pages->next;
    }
}

/**
 * gtk_assistant_new:
 * 
 * Creates a new #GtkAssistant.
 *
 * Return value: a newly created #GtkAssistant
 **/
GtkWidget*
gtk_assistant_new (void)
{
  GtkWidget *assistant;

  assistant = g_object_new (GTK_TYPE_ASSISTANT, NULL);

  return assistant;
}

/**
 * gtk_assistant_get_current_page:
 * @assistant: a #GtkAssistant
 *
 * Returns the page number of the current page
 *
 * Return value: The index (starting from 0) of the current page in
 * the @assistant, if the @assistant has no pages, -1 will be returned
 **/
gint
gtk_assistant_get_current_page (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), -1);

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  if (!priv->pages || !priv->current_page)
    return -1;

  return g_list_index (priv->pages, priv->current_page);
}

/**
 * gtk_assistant_set_current_page:
 * @assistant: a #GtkAssistant
 * @page_num: index of the page to switch to, starting from 0.
 *            If negative, the last page will be used. If greater
 *            than the number of pages in the @assistant, nothing
 *            will be done.
 *
 * Switches the page to @page_num. Note that this will only be necessary
 * in custom buttons, as the @assistant flow can be set with
 * gtk_assistant_set_forward_page_func().
 **/
void
gtk_assistant_set_current_page (GtkAssistant *assistant,
				gint          page_num)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  if (page_num >= 0)
    page = (GtkAssistantPage *) g_list_nth_data (priv->pages, page_num);
  else
    page = (GtkAssistantPage *) g_list_last (priv->pages);

  g_return_if_fail (page != NULL);

  if (priv->current_page == page)
    return;

  /* only add the page to the visited list if the
   * assistant is mapped, if not, just use it as an
   * initial page setting, for the cases where the
   * initial page is != to 0
   */
  if (GTK_WIDGET_MAPPED (assistant))
    priv->visited_pages = g_slist_prepend (priv->visited_pages, page);

  _set_current_page (assistant, page);
}

/**
 * gtk_assistant_get_n_pages:
 * @assistant: a #GtkAssistant
 *
 * Returns the number of pages in the @assistant
 *
 * Return value: The number of pages in the @assistant, or -1 if the function fails
 **/
gint
gtk_assistant_get_n_pages (GtkAssistant *assistant)
{
  GtkAssistantPrivate *priv;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), -1);

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  return g_list_length (priv->pages);
}

/**
 * gtk_assistant_get_nth_page:
 * @assistant: a #GtkAssistant
 * @page_num: The index of a page in the @assistant, or -1 to get the last page;
 *
 * Returns the child widget contained in page number @page_num.
 *
 * Return value: The child widget, or NULL if page_num is out of bounds.
 **/
GtkWidget*
gtk_assistant_get_nth_page (GtkAssistant *assistant,
			    gint          page_num)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page;
  GList *elem;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), NULL);

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  elem = g_list_nth (priv->pages, page_num);

  if (!elem)
    return NULL;

  page = (GtkAssistantPage *) elem->data;

  return page->page;
}

/**
 * gtk_assistant_prepend_page:
 * @assistant: a #GtkAssistant
 * @page: a #GtkWidget
 *
 * Prepends a page to the @assistant.
 *
 * Return value: the index (starting at 0) of the inserted page,
 * -1 if the function fails.
 **/
gint
gtk_assistant_prepend_page (GtkAssistant *assistant,
			    GtkWidget    *page)
{
  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), -1);
  g_return_val_if_fail (GTK_IS_WIDGET (page), -1);

  return gtk_assistant_insert_page (assistant, page, 0);
}

/**
 * gtk_assistant_append_page:
 * @assistant: a #GtkAssistant
 * @page: a #GtkWidget
 *
 * Appends a page to the @assistant.
 *
 * Return value: the index (starting at 0) of the inserted page,
 * -1 if the function fails.
 **/
gint
gtk_assistant_append_page (GtkAssistant *assistant,
			   GtkWidget    *page)
{
  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), -1);
  g_return_val_if_fail (GTK_IS_WIDGET (page), -1);

  return gtk_assistant_insert_page (assistant, page, -1);
}

/**
 * gtk_assistant_insert_page:
 * @assistant: a #GtkAssistant
 * @page: a #GtkWidget
 * @position: the index (starting at 0) at which to insert the page,
 *            or -1 to append the page to the @assistant
 *
 * Inserts a page in the @assistant at a given position.
 *
 * Return value: the index (starting from 0) of the inserted page,
 * -1 if the function fails.
 **/
gint
gtk_assistant_insert_page (GtkAssistant *assistant,
			   GtkWidget    *page,
			   gint          position)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  gint n_pages;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), -1);
  g_return_val_if_fail (GTK_IS_WIDGET (page), -1);
  g_return_val_if_fail (GTK_WIDGET (page)->parent == NULL, -1);
  g_return_val_if_fail (!GTK_WIDGET_TOPLEVEL (page), -1);

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  page_info = g_new0 (GtkAssistantPage, 1);
  page_info->page = page;

  n_pages = g_list_length (priv->pages);

  if (position < 0 || position > n_pages)
    position = n_pages;

  priv->pages = g_list_insert (priv->pages, page_info, position);

  gtk_widget_set_parent (page, GTK_WIDGET (assistant));

  if (GTK_WIDGET_REALIZED (GTK_WIDGET (assistant)))
    gtk_widget_realize (page);

  return position;
}

/**
 * gtk_assistant_set_forward_page_func:
 * @assistant: a #GtkAssistant
 * @page_func: the #GtkAssistantPageFunc to use, or NULL to set the default one
 * @data: user data for @page_func
 * @destroy: destroy notifier for @data
 *
 * Sets the page forwarding function to be @page_func, this function will
 * be used to determine what will be the next page when the user presses
 * the forward button. Setting @page_func to NULL will make the assistant
 * to use the default forward function, which just goes to the next page.
 **/
void
gtk_assistant_set_forward_page_func (GtkAssistant         *assistant,
				     GtkAssistantPageFunc  page_func,
				     gpointer              data,
				     GDestroyNotify        destroy)
{
  GtkAssistantPrivate *priv;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  if (priv->forward_data_destroy &&
      priv->forward_function_data)
    (*priv->forward_data_destroy) (priv->forward_function_data);

  if (page_func)
    {
      priv->forward_function = page_func;
      priv->forward_function_data = data;
      priv->forward_data_destroy = destroy;
    }
  else
    {
      priv->forward_function = default_forward_function;
      priv->forward_function_data = assistant;
      priv->forward_data_destroy = NULL;
    }
}

/**
 * gtk_assistant_add_action_widget:
 * @dialog: a #GtkAssistant
 * @child: an #GtkWidget
 * 
 * Adds a widget to the action area of a #GtkAssistant.
 **/
void
gtk_assistant_add_action_widget (GtkAssistant *assistant,
				 GtkWidget    *child)
{
  GtkAssistantPrivate *priv;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));
  g_return_if_fail (GTK_IS_WIDGET (child));

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  if (GTK_IS_BUTTON (child))
    gtk_size_group_add_widget (priv->size_group, child);

  gtk_box_pack_end (GTK_BOX (priv->action_area), child, FALSE, FALSE, 0);
}

/**
 * gtk_assistant_remove_action_widget:
 * @dialog: a #GtkAssistant
 * @child: a #GtkWidget
 *
 * Removes a widget from the action area of a #GtkAssistant.
 **/
void
gtk_assistant_remove_action_widget (GtkAssistant *assistant,
				    GtkWidget    *child)
{
  GtkAssistantPrivate *priv;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));
  g_return_if_fail (GTK_IS_WIDGET (child));

  priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  if (GTK_IS_BUTTON (child))
    gtk_size_group_remove_widget (priv->size_group, child);

  gtk_container_remove (GTK_CONTAINER (priv->action_area), child);
}

/**
 * gtk_assistant_set_page_title:
 * @assistant: a #GtkAssistant
 * @page: a page of @assitant
 * @title: the new title for @page
 * 
 * Sets a title for @page. The title is displayed in the header
 * area of the assistant when @page is the current page.
 **/
void
gtk_assistant_set_page_title (GtkAssistant *assistant,
			      GtkWidget    *page,
			      const gchar  *title)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));
  g_return_if_fail (GTK_IS_WIDGET (page));

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_if_fail (child != NULL);

  page_info = (GtkAssistantPage*) child->data;

  if (title != page_info->title)
    {
      g_free (page_info->title);
      page_info->title = g_strdup (title);

      if (page_info == priv->current_page)
	_set_assistant_title (assistant);

      gtk_widget_child_notify (page, "title");
    }
}

/**
 * gtk_assistant_get_page_title:
 * @assistant: a #GtkAssistant
 * @page: a page of @assistant
 * 
 * Gets the title for @page. 
 * 
 * Return value: the title for @page.
 **/
G_CONST_RETURN gchar*
gtk_assistant_get_page_title (GtkAssistant *assistant,
			      GtkWidget    *page)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), NULL);
  g_return_val_if_fail (GTK_IS_WIDGET (page), NULL);

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_val_if_fail (child != NULL, NULL);

  page_info = (GtkAssistantPage*) child->data;

  return page_info->title;
}

/**
 * gtk_assistant_set_page_type:
 * @assistant: a #GtkAssistant
 * @page: a page of @assitant
 * @type: the new type for @page
 * 
 * Sets the page type for @page. The page type determines the page
 * behavior in the @assistant.
 **/
void
gtk_assistant_set_page_type (GtkAssistant         *assistant,
			     GtkWidget            *page,
			     GtkAssistantPageType  type)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));
  g_return_if_fail (GTK_IS_WIDGET (page));

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_if_fail (child != NULL);

  page_info = (GtkAssistantPage*) child->data;

  if (type != page_info->type)
    {
      page_info->type = type;

      /* Always set buttons state, a change in a future page
	 might change current page buttons */
      if (priv->current_page)
	_set_assistant_buttons_state (assistant);

      gtk_widget_child_notify (page, "page-type");
    }
}

/**
 * gtk_assistant_get_page_type:
 * @assistant: a #GtkAssistant
 * @page: a page of @assistant
 *
 * Gets the page type of @page.
 *
 * Return value: the page type of @page.
 **/
GtkAssistantPageType
gtk_assistant_get_page_type (GtkAssistant *assistant,
			     GtkWidget    *page)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), GTK_ASSISTANT_PAGE_CONTENT);
  g_return_val_if_fail (GTK_IS_WIDGET (page), GTK_ASSISTANT_PAGE_CONTENT);

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_val_if_fail (child != NULL, GTK_ASSISTANT_PAGE_CONTENT);

  page_info = (GtkAssistantPage*) child->data;

  return page_info->type;
}

/**
 * gtk_assistant_set_page_header_image:
 * @assistant: a #GtkAssistant
 * @page: a page of @assitant
 * @pixbuf: the new header image @page
 * 
 * Sets a header image for @page. This image is displayed in the header
 * area of the assistant when @page is the current page.
 **/
void
gtk_assistant_set_page_header_image (GtkAssistant *assistant,
				     GtkWidget    *page,
				     GdkPixbuf    *pixbuf)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));
  g_return_if_fail (GTK_IS_WIDGET (page));
  g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf));

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_if_fail (child != NULL);

  page_info = (GtkAssistantPage*) child->data;

  if (pixbuf != page_info->header_image)
    {
      if (page_info->header_image)
	g_object_unref (page_info->header_image);

      page_info->header_image = g_object_ref (pixbuf);

      if (page_info == priv->current_page)
	_set_assistant_header_image (assistant);

      gtk_widget_child_notify (page, "header-image");
    }
}

/**
 * gtk_assistant_get_page_header_image:
 * @assistant: a #GtkAssistant
 * @page: a page of @assistant
 * 
 * Gets the header image for @page. 
 * 
 * Return value: the header image for @page, or %NULL
 * if there's no header image for the page.
 **/
GdkPixbuf*
gtk_assistant_get_page_header_image (GtkAssistant *assistant,
				     GtkWidget    *page)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), NULL);
  g_return_val_if_fail (GTK_IS_WIDGET (page), NULL);

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_val_if_fail (child != NULL, NULL);

  page_info = (GtkAssistantPage*) child->data;

  return page_info->header_image;
}

/**
 * gtk_assistant_set_page_side_image:
 * @assistant: a #GtkAssistant
 * @page: a page of @assitant
 * @pixbuf: the new header image @page
 * 
 * Sets a header image for @page. This image is displayed in the side
 * area of the assistant when @page is the current page.
 **/
void
gtk_assistant_set_page_side_image (GtkAssistant *assistant,
				   GtkWidget    *page,
				   GdkPixbuf    *pixbuf)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));
  g_return_if_fail (GTK_IS_WIDGET (page));
  g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf));

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_if_fail (child != NULL);

  page_info = (GtkAssistantPage*) child->data;

  if (pixbuf != page_info->sidebar_image)
    {
      if (page_info->sidebar_image)
	g_object_unref (page_info->sidebar_image);

      page_info->sidebar_image = g_object_ref (pixbuf);

      if (page_info == priv->current_page)
	_set_assistant_sidebar_image (assistant);

      gtk_widget_child_notify (page, "sidebar-image");
    }
}

/**
 * gtk_assistant_get_page_side_image:
 * @assistant: a #GtkAssistant
 * @page: a page of @assistant
 * 
 * Gets the header image for @page. 
 * 
 * Return value: the side image for @page, or %NULL
 * if there's no side image for the page.
 **/
GdkPixbuf*
gtk_assistant_get_page_side_image (GtkAssistant *assistant,
				   GtkWidget    *page)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), NULL);
  g_return_val_if_fail (GTK_IS_WIDGET (page), NULL);

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_val_if_fail (child != NULL, NULL);

  page_info = (GtkAssistantPage*) child->data;

  return page_info->sidebar_image;
}

/**
 * gtk_assistant_set_page_complete:
 * @assistant: a #GtkAssistant
 * @page: a page of @assitant
 * @pixbuf: the new header image @page
 * 
 * Sets whether @page contents are complete. This will make
 * @assistant update the buttons state to be able to continue the task.
 **/
void
gtk_assistant_set_page_complete (GtkAssistant *assistant,
				 GtkWidget    *page,
				 gboolean      complete)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_if_fail (GTK_IS_ASSISTANT (assistant));
  g_return_if_fail (GTK_IS_WIDGET (page));

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_if_fail (child != NULL);

  page_info = (GtkAssistantPage*) child->data;

  if (complete != page_info->complete)
    {
      page_info->complete = complete;

      /* Always set buttons state, a change in a future page
	 might change current page buttons */
      if (priv->current_page)
	{
	  /* Always set buttons state, a change in a future page
	     might change current page buttons */
	  _set_assistant_buttons_state (assistant);
	}

      gtk_widget_child_notify (page, "complete");
    }
}

/**
 * gtk_assistant_get_page_complete:
 * @assistant: a #GtkAssistant
 * @page: a page of @assistant
 * 
 * Gets whether @page is complete..
 * 
 * Return value: %TRUE if @page is complete.
 **/
gboolean
gtk_assistant_get_page_complete (GtkAssistant *assistant,
				 GtkWidget    *page)
{
  GtkAssistantPrivate *priv;
  GtkAssistantPage *page_info;
  GList *child;

  g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), FALSE);
  g_return_val_if_fail (GTK_IS_WIDGET (page), FALSE);

  priv  = GTK_ASSISTANT_GET_PRIVATE (assistant);
  child = find_page (assistant, page);

  g_return_val_if_fail (child != NULL, FALSE);

  page_info = (GtkAssistantPage*) child->data;

  return page_info->complete;
}
