/* 

 * GTK - The GIMP Toolkit

 * Copyright (C) 1999  Red Hat, Inc.

 * Copyright (C) 2002  Anders Carlsson <andersca@gnu.org>

 * Copyright (C) 2003  Matthias Clasen <mclasen@redhat.com>

 * Copyright (C) 2005  Carlos Garnacho Parro <carlosg@gnome.org>

 *

 * All rights reserved.

 *

 * 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.

 */

/**

 * SECTION:gtkassistant

 * @Short_description: A widget used to guide users through multi-step operations

 * @Title: GtkAssistant

 *

 * A #GtkAssistant is a widget used to represent a generally complex

 * operation splitted in several steps, guiding the user through its pages

 * and controlling the page flow to collect the necessary data.

 *

 * <refsect2 id="GtkAssistant-BUILDER-UI">

 * <title>GtkAssistant as GtkBuildable</title>

 * <para>

 * The GtkAssistant implementation of the GtkBuildable interface exposes the

 * @action_area as internal children with the name "action_area".

 *

 * To add pages to an assistant in GtkBuilder, simply add it as a

 * <child> to the GtkAssistant object, and set its child properties

 * as necessary.

 * </para>

 * </refsect2>

 */

#include "config.h"

#include <atk/atk.h>

#include "gtkassistant.h"

#include "gtkaccessible.h"

#include "gtkbutton.h"

#include "gtkhbox.h"

#include "gtkhbbox.h"

#include "gtkimage.h"

#include "gtklabel.h"

#include "gtksizegroup.h"

#include "gtkstock.h"

#include "gtkintl.h"

#include "gtkprivate.h"

#include "gtkbuildable.h"

#include "gtkalias.h"

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

#define HEADER_SPACING 12

#define ACTION_AREA_SPACING 12

typedef struct _GtkAssistantPage GtkAssistantPage;

struct _GtkAssistantPage

{

  GtkWidget *page;

  GtkAssistantPageType type;

  guint      complete : 1;

  guint      complete_set : 1;

  GtkWidget *title;

  GdkPixbuf *header_image;

  GdkPixbuf *sidebar_image;

};

struct _GtkAssistantPrivate

{

  GtkWidget *header_image;

  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;

  guint committed : 1;

};

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 gboolean gtk_assistant_expose             (GtkWidget         *widget,

						  GdkEventExpose    *event);

static gboolean gtk_assistant_focus              (GtkWidget         *widget,

						  GtkDirectionType   direction);

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);

static AtkObject *gtk_assistant_get_accessible   (GtkWidget         *widget);

static void       gtk_assistant_buildable_interface_init     (GtkBuildableIface *iface);

static GObject   *gtk_assistant_buildable_get_internal_child (GtkBuildable  *buildable,

                                                              GtkBuilder    *builder,

                                                              const gchar   *childname);

static gboolean   gtk_assistant_buildable_custom_tag_start   (GtkBuildable  *buildable,

                                                              GtkBuilder    *builder,

                                                              GObject       *child,

                                                              const gchar   *tagname,

                                                              GMarkupParser *parser,

                                                              gpointer      *data);

static void       gtk_assistant_buildable_custom_finished    (GtkBuildable  *buildable,

                                                              GtkBuilder    *builder,

                                                              GObject       *child,

                                                              const gchar   *tagname,

                                                              gpointer       user_data);

static GList*     find_page                                  (GtkAssistant  *assistant,

                                                              GtkWidget     *page);

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_WITH_CODE (GtkAssistant, gtk_assistant, GTK_TYPE_WINDOW,

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,

                                                gtk_assistant_buildable_interface_init))

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;

  widget_class->expose_event = gtk_assistant_expose;

  widget_class->focus = gtk_assistant_focus;

  widget_class->get_accessible = gtk_assistant_get_accessible;

  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

   *

   * The ::cancel signal is emitted when then the cancel button is clicked.

   *

   * Since: 2.10

   */

  signals[CANCEL] =

    g_signal_new (I_("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 ::prepare 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.

   *

   * Since: 2.10

   */

  signals[PREPARE] =

    g_signal_new (I_("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

   *

   * 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 putting a page of type %GTK_ASSISTANT_PAGE_PROGRESS

   * after the confirmation page and handle this operation within the

   * #GtkAssistant::prepare signal of the progress page.

   *

   * Since: 2.10

   */

  signals[APPLY] =

    g_signal_new (I_("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

   *

   * The ::close signal is emitted either when the close button of

   * a summary page is clicked, or when the apply button in the last

   * page in the flow (of type %GTK_ASSISTANT_PAGE_CONFIRM) is clicked.

   *

   * Since: 2.10

   */

  signals[CLOSE] =

    g_signal_new (I_("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,

							     6,

							     GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("content-padding",

							     P_("Content Padding"),

							     P_("Number of pixels around the content pages."),

							     0,

							     G_MAXINT,

							     1,

							     GTK_PARAM_READABLE));

  /**

   * GtkAssistant:page-type:

   *

   * The type of the assistant page.

   *

   * Since: 2.10

   */

  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,

								 GTK_PARAM_READWRITE));

  /**

   * GtkAssistant:title:

   *

   * The title that is displayed in the page header.

   *

   * If title and header-image are both %NULL, no header is displayed.

   *

   * Since: 2.10

   */

  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,

								   GTK_PARAM_READWRITE));

  /**

   * GtkAssistant:header-image:

   *

   * The image that is displayed next to the title in the page header.

   *

   * If title and header-image are both %NULL, no header is displayed.

   *

   * Since: 2.10

   */

  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,

								   GTK_PARAM_READWRITE));

  /**

   * GtkAssistant:header-image:

   *

   * The image that is displayed next to the page.

   *

   * Set this to %NULL to make the sidebar disappear.

   *

   * Since: 2.10

   */

  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,

								   GTK_PARAM_READWRITE));

  /**

   * GtkAssistant:complete:

   *

   * Setting the "complete" child property to %TRUE marks a page as complete

   * (i.e.: all the required fields are filled out). GTK+ uses this information

   * to control the sensitivity of the navigation buttons.

   *

   * Since: 2.10

   **/

  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 = assistant->priv;

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

  if (!page_node)

    return -1;

  page_info = (GtkAssistantPage *) page_node->data;

  while (page_node && !gtk_widget_get_visible (page_info->page))

    {

      page_node = page_node->next;

      current_page++;

      if (page_node)

	page_info = (GtkAssistantPage *) page_node->data;

    }

  return current_page;

}

static void

compute_last_button_state (GtkAssistant *assistant)

{

  GtkAssistantPrivate *priv = assistant->priv;

  GtkAssistantPage *page_info, *current_page_info;

  gint count, page_num, n_pages;

  count = 0;

  page_num = gtk_assistant_get_current_page (assistant);

  n_pages  = gtk_assistant_get_n_pages (assistant);

  current_page_info = 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 &&

	 (count == 0 || page_info->complete) &&

	 count < n_pages)

    {

      page_num = (priv->forward_function) (page_num, priv->forward_function_data);

      page_info = g_list_nth_data (priv->pages, page_num);

      count++;

    }

  /* make the last button visible if we can skip multiple

   * pages and end on a confirmation or summary page

   */

  if (count > 1 && page_info &&

      (page_info->type == GTK_ASSISTANT_PAGE_CONFIRM ||

       page_info->type == GTK_ASSISTANT_PAGE_SUMMARY))

    {

      gtk_widget_show (assistant->last);

      gtk_widget_set_sensitive (assistant->last,

				current_page_info->complete);

    }

  else

    gtk_widget_hide (assistant->last);

}

static void

compute_progress_state (GtkAssistant *assistant)

{

  GtkAssistantPrivate *priv = assistant->priv;

  gint page_num, n_pages;

  n_pages = gtk_assistant_get_n_pages (assistant);

  page_num = gtk_assistant_get_current_page (assistant);

  page_num = (priv->forward_function) (page_num, priv->forward_function_data);

  if (page_num >= 0 && page_num < n_pages)

    gtk_widget_show (assistant->forward);

  else

    gtk_widget_hide (assistant->forward);

}

static void

set_assistant_header_image (GtkAssistant *assistant)

{

  GtkAssistantPrivate *priv = assistant->priv;

  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 = assistant->priv;

  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_image);

  else

    gtk_widget_hide (priv->sidebar_image);

}

static void

set_assistant_buttons_state (GtkAssistant *assistant)

{

  GtkAssistantPrivate *priv = assistant->priv;

  if (!priv->current_page)

    return;

  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_grab_default (assistant->forward);

      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_grab_default (assistant->apply);

      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_grab_default (assistant->forward);

      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, priv->current_page->complete);

      gtk_widget_grab_default (assistant->close);

      gtk_widget_show (assistant->close);

      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_grab_default (assistant->forward);

      gtk_widget_show (assistant->back);

      gtk_widget_hide (assistant->apply);

      gtk_widget_hide (assistant->close);

      gtk_widget_hide (assistant->last);

      compute_progress_state (assistant);

      break;

    default:

      g_assert_not_reached ();

    }

  if (priv->committed)

    gtk_widget_hide (assistant->cancel);

  else if (priv->current_page->type == GTK_ASSISTANT_PAGE_SUMMARY)

    gtk_widget_hide (assistant->cancel);

  else

    gtk_widget_show (assistant->cancel);

  /* 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 = assistant->priv;

  GtkAssistantPage *old_page;

  if (priv->current_page &&

      gtk_widget_is_drawable (priv->current_page->page))

    old_page = priv->current_page;

  else

    old_page = NULL;

  priv->current_page = page;

  set_assistant_buttons_state (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_get_visible (priv->current_page->page) && gtk_widget_get_mapped (GTK_WIDGET (assistant)))

    {

      gtk_widget_set_child_visible (priv->current_page->page, TRUE);

      gtk_widget_map (priv->current_page->page);

      gtk_widget_map (priv->current_page->title);

    }

  if (old_page && gtk_widget_get_mapped (old_page->page))

    {

      gtk_widget_set_child_visible (old_page->page, FALSE);

      gtk_widget_unmap (old_page->page);

      gtk_widget_unmap (old_page->title);

    }

  if (!gtk_widget_child_focus (priv->current_page->page, GTK_DIR_TAB_FORWARD))

    {

      GtkWidget *button[6];

      gint i;

      /* find the best button to focus */

      button[0] = assistant->apply;

      button[1] = assistant->close;

      button[2] = assistant->forward;

      button[3] = assistant->back;

      button[4] = assistant->cancel;

      button[5] = assistant->last;

      for (i = 0; i < 6; i++)

        {

          if (gtk_widget_get_visible (button[i]) && gtk_widget_get_sensitive (button[i]))

            {

              gtk_widget_grab_focus (button[i]);

              break;

            }

        }

    }

  gtk_widget_queue_resize (GTK_WIDGET (assistant));

}

static gint

compute_next_step (GtkAssistant *assistant)

{

  GtkAssistantPrivate *priv = assistant->priv;

  GtkAssistantPage *page_info;

  gint current_page, n_pages, next_page;

  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)

{

  g_signal_emit (assistant, signals [CLOSE], 0, NULL);

}

static void

on_assistant_apply (GtkWidget    *widget,

                    GtkAssistant *assistant)

{

  gboolean success;

  g_signal_emit (assistant, signals [APPLY], 0);

  success = compute_next_step (assistant);

  /* 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);

}

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 = assistant->priv;

  GtkAssistantPage *page_info;

  GSList *page_node;

  /* 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_get_visible (page_info->page));

  set_current_page (assistant, page_info);

}

static void

on_assistant_cancel (GtkWidget    *widget,

                     GtkAssistant *assistant)

{

  g_signal_emit (assistant, signals [CANCEL], 0, NULL);

}

static void

on_assistant_last (GtkWidget    *widget,

                   GtkAssistant *assistant)

{

  GtkAssistantPrivate *priv = assistant->priv;

  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 = assistant->priv = GTK_ASSISTANT_GET_PRIVATE (assistant);

  gtk_container_set_reallocate_redraws (GTK_CONTAINER (assistant), TRUE);

  gtk_container_set_border_width (GTK_CONTAINER (assistant), 12);

  gtk_widget_push_composite_child ();

  /* Header */

  priv->header_image = gtk_image_new ();

  gtk_misc_set_alignment (GTK_MISC (priv->header_image), 1., 0.5);

  gtk_widget_set_parent (priv->header_image, GTK_WIDGET (assistant));

  gtk_widget_show (priv->header_image);

  /* Sidebar */

  priv->sidebar_image = gtk_image_new ();

  gtk_misc_set_alignment (GTK_MISC (priv->sidebar_image), 0., 0.);

  gtk_widget_set_parent (priv->sidebar_image, GTK_WIDGET (assistant));

  gtk_widget_show (priv->sidebar_image);

  /* Action area  */

  priv->action_area  = gtk_hbox_new (FALSE, 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);

  gtk_widget_set_can_default (assistant->close, TRUE);

  gtk_widget_set_can_default (assistant->apply, TRUE);

  gtk_widget_set_can_default (assistant->forward, TRUE);

  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->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_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);

    }

  else

    {

      gtk_box_pack_end (GTK_BOX (priv->action_area), assistant->close, 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->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: