2011-01-24 02:50:39 +00:00
|
|
|
|
/*
|
2008-07-01 22:57:50 +00:00
|
|
|
|
* GTK - The GIMP Toolkit
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* 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
|
2012-02-27 13:01:10 +00:00
|
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2010-03-05 22:44:31 +00:00
|
|
|
|
/**
|
|
|
|
|
* 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
|
2020-08-15 09:20:03 +00:00
|
|
|
|
* operation split up into several steps. Each step consists of one or more
|
|
|
|
|
* pages. GtkAssistant guides the user through the pages, and controls
|
|
|
|
|
* the page flow to collect the data needed for the operation.
|
2010-03-05 22:44:31 +00:00
|
|
|
|
*
|
2020-08-15 09:20:03 +00:00
|
|
|
|
* GtkAssistant handles which buttons to show and to make sensitive based
|
|
|
|
|
* on page sequence knowledge and the [type][GtkAssistantPageType]
|
|
|
|
|
* of each page in addition to state information like the
|
2014-02-07 02:07:03 +00:00
|
|
|
|
* [completion][gtk-assistant-set-page-complete]
|
2020-08-15 09:20:03 +00:00
|
|
|
|
* and [committed][gtk-assistant-commit] page statuses.
|
2010-10-31 01:25:21 +00:00
|
|
|
|
*
|
2014-02-07 18:32:47 +00:00
|
|
|
|
* If you have a case that doesn’t quite fit in #GtkAssistants way of
|
2014-02-02 05:29:00 +00:00
|
|
|
|
* handling buttons, you can use the #GTK_ASSISTANT_PAGE_CUSTOM page
|
|
|
|
|
* type and handle buttons yourself.
|
2010-10-31 18:34:35 +00:00
|
|
|
|
*
|
2019-02-07 20:18:49 +00:00
|
|
|
|
* GtkAssistant maintains a #GtkAssistantPage object for each added
|
|
|
|
|
* child, which holds additional per-child properties. You
|
|
|
|
|
* obtain the #GtkAssistantPage for a child with gtk_assistant_get_page().
|
|
|
|
|
*
|
2014-02-05 02:00:58 +00:00
|
|
|
|
* # GtkAssistant as GtkBuildable
|
2010-03-05 22:44:31 +00:00
|
|
|
|
*
|
2014-02-02 05:29:00 +00:00
|
|
|
|
* The GtkAssistant implementation of the #GtkBuildable interface
|
|
|
|
|
* exposes the @action_area as internal children with the name
|
2014-02-05 18:07:34 +00:00
|
|
|
|
* “action_area”.
|
2014-02-02 05:29:00 +00:00
|
|
|
|
*
|
|
|
|
|
* To add pages to an assistant in #GtkBuilder, simply add it as a
|
2019-02-07 20:18:49 +00:00
|
|
|
|
* child to the GtkAssistant object. If you need to set per-object
|
|
|
|
|
* properties, create a #GtkAssistantPage object explicitly, and
|
|
|
|
|
* set the child widget as a property on it.
|
2015-10-27 18:31:32 +00:00
|
|
|
|
*
|
|
|
|
|
* # CSS nodes
|
|
|
|
|
*
|
2020-05-20 07:36:21 +00:00
|
|
|
|
* GtkAssistant has a single CSS node with the name window and style
|
|
|
|
|
* class .assistant.
|
2010-03-05 22:44:31 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2008-06-22 14:28:52 +00:00
|
|
|
|
#include "config.h"
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
#include "gtkassistant.h"
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
#include "gtkbox.h"
|
2018-02-08 23:42:38 +00:00
|
|
|
|
#include "gtkbuildable.h"
|
|
|
|
|
#include "gtkbutton.h"
|
2011-05-18 21:22:40 +00:00
|
|
|
|
#include "gtkframe.h"
|
2018-02-08 23:42:38 +00:00
|
|
|
|
#include "gtkheaderbar.h"
|
|
|
|
|
#include "gtkintl.h"
|
2006-01-18 22:39:14 +00:00
|
|
|
|
#include "gtkimage.h"
|
|
|
|
|
#include "gtklabel.h"
|
2019-03-16 03:48:26 +00:00
|
|
|
|
#include "gtklistlistmodelprivate.h"
|
|
|
|
|
#include "gtkmaplistmodel.h"
|
2018-02-08 23:42:38 +00:00
|
|
|
|
#include "gtkprivate.h"
|
2012-03-03 18:22:22 +00:00
|
|
|
|
#include "gtksettings.h"
|
2006-01-18 22:39:14 +00:00
|
|
|
|
#include "gtksizegroup.h"
|
2010-09-09 13:35:58 +00:00
|
|
|
|
#include "gtksizerequest.h"
|
2019-03-16 03:48:26 +00:00
|
|
|
|
#include "gtkstack.h"
|
|
|
|
|
#include "gtkstylecontext.h"
|
2011-01-04 19:51:19 +00:00
|
|
|
|
#include "gtktypebuiltins.h"
|
2018-02-08 23:42:38 +00:00
|
|
|
|
|
2019-05-27 01:08:01 +00:00
|
|
|
|
typedef struct _GtkAssistantPageClass GtkAssistantPageClass;
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
struct _GtkAssistantPage
|
|
|
|
|
{
|
2019-02-07 20:18:49 +00:00
|
|
|
|
GObject instance;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
GtkAssistantPageType type;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
guint complete : 1;
|
2009-12-10 16:34:29 +00:00
|
|
|
|
guint complete_set : 1;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-07-24 18:40:36 +00:00
|
|
|
|
char *title;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
|
|
|
|
GtkWidget *page;
|
|
|
|
|
GtkWidget *regular_title;
|
|
|
|
|
GtkWidget *current_title;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
};
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
struct _GtkAssistantPageClass
|
|
|
|
|
{
|
|
|
|
|
GObjectClass parent_class;
|
|
|
|
|
};
|
|
|
|
|
|
2019-05-27 01:08:01 +00:00
|
|
|
|
typedef struct _GtkAssistantClass GtkAssistantClass;
|
|
|
|
|
|
|
|
|
|
struct _GtkAssistant
|
|
|
|
|
{
|
|
|
|
|
GtkWindow parent;
|
|
|
|
|
|
2010-05-24 13:46:51 +00:00
|
|
|
|
GtkWidget *cancel;
|
|
|
|
|
GtkWidget *forward;
|
|
|
|
|
GtkWidget *back;
|
|
|
|
|
GtkWidget *apply;
|
|
|
|
|
GtkWidget *close;
|
|
|
|
|
GtkWidget *last;
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
GtkWidget *sidebar;
|
|
|
|
|
GtkWidget *content;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
GtkWidget *action_area;
|
2014-01-29 02:27:26 +00:00
|
|
|
|
GtkWidget *headerbar;
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int use_header_bar;
|
2014-01-29 02:27:26 +00:00
|
|
|
|
gboolean constructed;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
GList *pages;
|
|
|
|
|
GSList *visited_pages;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
GtkAssistantPage *current_page;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
GtkSizeGroup *button_size_group;
|
|
|
|
|
GtkSizeGroup *title_size_group;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
GtkAssistantPageFunc forward_function;
|
|
|
|
|
gpointer forward_function_data;
|
|
|
|
|
GDestroyNotify forward_data_destroy;
|
2010-06-02 20:00:16 +00:00
|
|
|
|
|
2019-02-13 23:27:25 +00:00
|
|
|
|
GListModel *model;
|
|
|
|
|
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int extra_buttons;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
2010-06-02 20:00:16 +00:00
|
|
|
|
guint committed : 1;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
struct _GtkAssistantClass
|
|
|
|
|
{
|
|
|
|
|
GtkWindowClass parent_class;
|
|
|
|
|
|
|
|
|
|
void (* prepare) (GtkAssistant *assistant, GtkWidget *page);
|
|
|
|
|
void (* apply) (GtkAssistant *assistant);
|
|
|
|
|
void (* close) (GtkAssistant *assistant);
|
|
|
|
|
void (* cancel) (GtkAssistant *assistant);
|
|
|
|
|
};
|
|
|
|
|
|
2020-05-02 19:17:20 +00:00
|
|
|
|
static void gtk_assistant_dispose (GObject *object);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
static void gtk_assistant_map (GtkWidget *widget);
|
|
|
|
|
static void gtk_assistant_unmap (GtkWidget *widget);
|
2018-01-01 20:24:16 +00:00
|
|
|
|
static gboolean gtk_assistant_close_request (GtkWindow *window);
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
static void gtk_assistant_page_set_property (GObject *object,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
guint property_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec);
|
2019-02-07 20:18:49 +00:00
|
|
|
|
static void gtk_assistant_page_get_property (GObject *object,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
guint property_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2019-08-29 13:21:20 +00:00
|
|
|
|
static void gtk_assistant_buildable_interface_init (GtkBuildableIface *iface);
|
|
|
|
|
static void gtk_assistant_buildable_add_child (GtkBuildable *buildable,
|
|
|
|
|
GtkBuilder *builder,
|
|
|
|
|
GObject *child,
|
|
|
|
|
const char *type);
|
|
|
|
|
static gboolean gtk_assistant_buildable_custom_tag_start (GtkBuildable *buildable,
|
|
|
|
|
GtkBuilder *builder,
|
|
|
|
|
GObject *child,
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *tagname,
|
2019-08-29 13:21:20 +00:00
|
|
|
|
GtkBuildableParser *parser,
|
|
|
|
|
gpointer *data);
|
|
|
|
|
static void gtk_assistant_buildable_custom_finished (GtkBuildable *buildable,
|
|
|
|
|
GtkBuilder *builder,
|
|
|
|
|
GObject *child,
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *tagname,
|
2019-08-29 13:21:20 +00:00
|
|
|
|
gpointer user_data);
|
|
|
|
|
|
|
|
|
|
static GList* find_page (GtkAssistant *assistant,
|
|
|
|
|
GtkWidget *page);
|
|
|
|
|
static void on_assistant_close (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant);
|
|
|
|
|
static void on_assistant_apply (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant);
|
|
|
|
|
static void on_assistant_forward (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant);
|
|
|
|
|
static void on_assistant_back (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant);
|
|
|
|
|
static void on_assistant_cancel (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant);
|
|
|
|
|
static void on_assistant_last (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant);
|
|
|
|
|
|
|
|
|
|
static int gtk_assistant_add_page (GtkAssistant *assistant,
|
|
|
|
|
GtkAssistantPage *page_info,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int position);
|
2019-08-29 13:21:20 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
enum
|
|
|
|
|
{
|
|
|
|
|
CHILD_PROP_0,
|
2019-02-07 20:18:49 +00:00
|
|
|
|
CHILD_PROP_CHILD,
|
2006-01-18 22:39:14 +00:00
|
|
|
|
CHILD_PROP_PAGE_TYPE,
|
|
|
|
|
CHILD_PROP_PAGE_TITLE,
|
2015-06-15 01:29:09 +00:00
|
|
|
|
CHILD_PROP_PAGE_COMPLETE,
|
|
|
|
|
CHILD_PROP_HAS_PADDING
|
2006-01-18 22:39:14 +00:00
|
|
|
|
};
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
G_DEFINE_TYPE (GtkAssistantPage, gtk_assistant_page, G_TYPE_OBJECT)
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_page_init (GtkAssistantPage *page)
|
|
|
|
|
{
|
|
|
|
|
page->type = GTK_ASSISTANT_PAGE_CONTENT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_page_finalize (GObject *object)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page = GTK_ASSISTANT_PAGE (object);
|
|
|
|
|
|
|
|
|
|
g_clear_object (&page->page);
|
|
|
|
|
g_free (page->title);
|
|
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_assistant_page_parent_class)->finalize (object);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_page_class_init (GtkAssistantPageClass *class)
|
|
|
|
|
{
|
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
|
|
|
|
|
|
|
|
object_class->finalize = gtk_assistant_page_finalize;
|
|
|
|
|
object_class->get_property = gtk_assistant_page_get_property;
|
|
|
|
|
object_class->set_property = gtk_assistant_page_set_property;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkAssistantPage:page-type:
|
|
|
|
|
*
|
|
|
|
|
* The type of the assistant page.
|
|
|
|
|
*/
|
|
|
|
|
g_object_class_install_property (object_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,
|
2019-02-08 14:03:18 +00:00
|
|
|
|
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY));
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkAssistantPage:title:
|
|
|
|
|
*
|
|
|
|
|
* The title of the page.
|
|
|
|
|
*/
|
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
CHILD_PROP_PAGE_TITLE,
|
|
|
|
|
g_param_spec_string ("title",
|
|
|
|
|
P_("Page title"),
|
|
|
|
|
P_("The title of the assistant page"),
|
|
|
|
|
NULL,
|
2019-02-08 14:03:18 +00:00
|
|
|
|
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY));
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkAssistantPage:complete:
|
|
|
|
|
*
|
|
|
|
|
* Setting the "complete" property to %TRUE marks a page as
|
2020-09-12 16:01:04 +00:00
|
|
|
|
* complete (i.e.: all the required fields are filled out). GTK uses
|
2019-02-07 20:18:49 +00:00
|
|
|
|
* this information to control the sensitivity of the navigation buttons.
|
|
|
|
|
*/
|
|
|
|
|
g_object_class_install_property (object_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,
|
2019-02-08 14:03:18 +00:00
|
|
|
|
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY));
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
|
CHILD_PROP_CHILD,
|
|
|
|
|
g_param_spec_object ("child",
|
|
|
|
|
P_("Child widget"),
|
|
|
|
|
P_("The content the assistant page"),
|
|
|
|
|
GTK_TYPE_WIDGET,
|
|
|
|
|
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
enum
|
|
|
|
|
{
|
|
|
|
|
CANCEL,
|
|
|
|
|
PREPARE,
|
|
|
|
|
APPLY,
|
|
|
|
|
CLOSE,
|
2014-09-08 04:08:01 +00:00
|
|
|
|
ESCAPE,
|
2006-01-18 22:39:14 +00:00
|
|
|
|
LAST_SIGNAL
|
|
|
|
|
};
|
|
|
|
|
|
2014-01-29 02:27:26 +00:00
|
|
|
|
enum {
|
|
|
|
|
PROP_0,
|
2019-02-13 23:27:25 +00:00
|
|
|
|
PROP_USE_HEADER_BAR,
|
|
|
|
|
PROP_PAGES
|
2014-01-29 02:27:26 +00:00
|
|
|
|
};
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
static guint signals [LAST_SIGNAL] = { 0 };
|
|
|
|
|
|
2009-04-18 05:23:20 +00:00
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkAssistant, gtk_assistant, GTK_TYPE_WINDOW,
|
|
|
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
|
|
|
|
|
gtk_assistant_buildable_interface_init))
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2014-01-29 02:27:26 +00:00
|
|
|
|
static void
|
|
|
|
|
set_use_header_bar (GtkAssistant *assistant,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int use_header_bar)
|
2014-01-29 02:27:26 +00:00
|
|
|
|
{
|
|
|
|
|
if (use_header_bar == -1)
|
|
|
|
|
return;
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->use_header_bar = use_header_bar;
|
2014-01-29 02:27:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_set_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (object);
|
|
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
|
{
|
|
|
|
|
case PROP_USE_HEADER_BAR:
|
|
|
|
|
set_use_header_bar (assistant, g_value_get_int (value));
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_get_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (object);
|
|
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
|
{
|
|
|
|
|
case PROP_USE_HEADER_BAR:
|
2020-05-05 01:36:00 +00:00
|
|
|
|
g_value_set_int (value, assistant->use_header_bar);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2019-02-13 23:27:25 +00:00
|
|
|
|
case PROP_PAGES:
|
|
|
|
|
g_value_set_object (value, gtk_assistant_get_pages (assistant));
|
|
|
|
|
break;
|
|
|
|
|
|
2014-01-29 02:27:26 +00:00
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
apply_use_header_bar (GtkAssistant *assistant)
|
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_visible (assistant->action_area, !assistant->use_header_bar);
|
|
|
|
|
gtk_widget_set_visible (assistant->headerbar, assistant->use_header_bar);
|
|
|
|
|
if (!assistant->use_header_bar)
|
2014-01-29 02:27:26 +00:00
|
|
|
|
gtk_window_set_titlebar (GTK_WINDOW (assistant), NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
add_to_header_bar (GtkAssistant *assistant,
|
|
|
|
|
GtkWidget *child)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_set_valign (child, GTK_ALIGN_CENTER);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (child == assistant->back || child == assistant->cancel)
|
|
|
|
|
gtk_header_bar_pack_start (GTK_HEADER_BAR (assistant->headerbar), child);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
else
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_header_bar_pack_end (GTK_HEADER_BAR (assistant->headerbar), child);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
add_action_widgets (GtkAssistant *assistant)
|
|
|
|
|
{
|
2020-05-09 12:26:52 +00:00
|
|
|
|
GList *children, *l;
|
|
|
|
|
GtkWidget *child;
|
2014-01-29 02:27:26 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->use_header_bar)
|
2014-01-29 02:27:26 +00:00
|
|
|
|
{
|
2020-05-09 12:26:52 +00:00
|
|
|
|
children = NULL;
|
|
|
|
|
for (child = gtk_widget_get_last_child (assistant->action_area);
|
|
|
|
|
child != NULL;
|
|
|
|
|
child = gtk_widget_get_prev_sibling (child))
|
|
|
|
|
children = g_list_prepend (children, child);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
for (l = children; l != NULL; l = l->next)
|
|
|
|
|
{
|
|
|
|
|
gboolean has_default;
|
|
|
|
|
|
2020-05-09 12:26:52 +00:00
|
|
|
|
child = l->data;
|
2014-01-29 02:27:26 +00:00
|
|
|
|
has_default = gtk_widget_has_default (child);
|
|
|
|
|
|
|
|
|
|
g_object_ref (child);
|
2020-05-09 12:26:52 +00:00
|
|
|
|
gtk_box_remove (GTK_BOX (assistant->action_area), child);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
add_to_header_bar (assistant, child);
|
|
|
|
|
g_object_unref (child);
|
|
|
|
|
|
|
|
|
|
if (has_default)
|
|
|
|
|
{
|
2019-04-27 03:20:41 +00:00
|
|
|
|
gtk_window_set_default_widget (GTK_WINDOW (assistant), child);
|
2020-08-13 23:49:02 +00:00
|
|
|
|
gtk_widget_add_css_class (child, "suggested-action");
|
2014-01-29 02:27:26 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
g_list_free (children);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-26 22:22:42 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_constructed (GObject *object)
|
2014-01-29 02:27:26 +00:00
|
|
|
|
{
|
2014-06-26 22:22:42 +00:00
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (object);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
|
2014-06-26 22:22:42 +00:00
|
|
|
|
G_OBJECT_CLASS (gtk_assistant_parent_class)->constructed (object);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->constructed = TRUE;
|
|
|
|
|
if (assistant->use_header_bar == -1)
|
|
|
|
|
assistant->use_header_bar = FALSE;
|
2014-01-29 02:27:26 +00:00
|
|
|
|
|
|
|
|
|
add_action_widgets (assistant);
|
|
|
|
|
apply_use_header_bar (assistant);
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2014-09-08 04:08:01 +00:00
|
|
|
|
static void
|
|
|
|
|
escape_cb (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
/* Do not allow cancelling in the middle of a progress page */
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->current_page &&
|
|
|
|
|
(assistant->current_page->type != GTK_ASSISTANT_PAGE_PROGRESS ||
|
|
|
|
|
assistant->current_page->complete))
|
2014-09-08 04:08:01 +00:00
|
|
|
|
g_signal_emit (assistant, signals [CANCEL], 0, NULL);
|
|
|
|
|
|
|
|
|
|
/* don't run any user handlers - this is not a public signal */
|
|
|
|
|
g_signal_stop_emission (assistant, signals[ESCAPE], 0);
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-21 02:45:11 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_finalize (GObject *object)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (object);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->model)
|
|
|
|
|
g_object_remove_weak_pointer (G_OBJECT (assistant->model), (gpointer *)&assistant->model);
|
2019-02-21 02:45:11 +00:00
|
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (gtk_assistant_parent_class)->finalize (object);
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_class_init (GtkAssistantClass *class)
|
|
|
|
|
{
|
|
|
|
|
GObjectClass *gobject_class;
|
|
|
|
|
GtkWidgetClass *widget_class;
|
2018-01-01 20:24:16 +00:00
|
|
|
|
GtkWindowClass *window_class;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
gobject_class = (GObjectClass *) class;
|
|
|
|
|
widget_class = (GtkWidgetClass *) class;
|
2018-01-01 20:24:16 +00:00
|
|
|
|
window_class = (GtkWindowClass *) class;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-02 19:17:20 +00:00
|
|
|
|
gobject_class->dispose = gtk_assistant_dispose;
|
2019-02-21 02:45:11 +00:00
|
|
|
|
gobject_class->finalize = gtk_assistant_finalize;
|
2014-06-26 22:22:42 +00:00
|
|
|
|
gobject_class->constructed = gtk_assistant_constructed;
|
2014-01-29 02:27:26 +00:00
|
|
|
|
gobject_class->set_property = gtk_assistant_set_property;
|
|
|
|
|
gobject_class->get_property = gtk_assistant_get_property;
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
widget_class->map = gtk_assistant_map;
|
|
|
|
|
widget_class->unmap = gtk_assistant_unmap;
|
2011-07-06 16:34:50 +00:00
|
|
|
|
|
2018-01-01 20:24:16 +00:00
|
|
|
|
window_class->close_request = gtk_assistant_close_request;
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkAssistant::cancel:
|
|
|
|
|
* @assistant: the #GtkAssistant
|
|
|
|
|
*
|
|
|
|
|
* The ::cancel signal is emitted when then the cancel button is clicked.
|
|
|
|
|
*/
|
|
|
|
|
signals[CANCEL] =
|
|
|
|
|
g_signal_new (I_("cancel"),
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkAssistantClass, cancel),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:05:19 +00:00
|
|
|
|
NULL,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkAssistant::prepare:
|
|
|
|
|
* @assistant: the #GtkAssistant
|
|
|
|
|
* @page: the current page
|
|
|
|
|
*
|
2011-04-17 00:45:26 +00:00
|
|
|
|
* 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 preparations which are
|
|
|
|
|
* necessary before showing @page.
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*/
|
|
|
|
|
signals[PREPARE] =
|
|
|
|
|
g_signal_new (I_("prepare"),
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkAssistantClass, prepare),
|
|
|
|
|
NULL, NULL,
|
2019-05-31 03:56:50 +00:00
|
|
|
|
NULL,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_NONE, 1, GTK_TYPE_WIDGET);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkAssistant::apply:
|
2010-03-05 22:44:31 +00:00
|
|
|
|
* @assistant: the #GtkAssistant
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*
|
2011-04-17 00:45:26 +00:00
|
|
|
|
* 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.
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*
|
2011-04-17 00:45:26 +00:00
|
|
|
|
* 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.
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*/
|
|
|
|
|
signals[APPLY] =
|
|
|
|
|
g_signal_new (I_("apply"),
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkAssistantClass, apply),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:05:19 +00:00
|
|
|
|
NULL,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkAssistant::close:
|
|
|
|
|
* @assistant: the #GtkAssistant
|
|
|
|
|
*
|
2006-01-28 06:03:50 +00:00
|
|
|
|
* The ::close signal is emitted either when the close button of
|
|
|
|
|
* a summary page is clicked, or when the apply button in the last
|
2009-05-30 06:14:03 +00:00
|
|
|
|
* page in the flow (of type %GTK_ASSISTANT_PAGE_CONFIRM) is clicked.
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*/
|
|
|
|
|
signals[CLOSE] =
|
|
|
|
|
g_signal_new (I_("close"),
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkAssistantClass, close),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:05:19 +00:00
|
|
|
|
NULL,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2014-09-08 04:08:01 +00:00
|
|
|
|
signals[ESCAPE] =
|
|
|
|
|
g_signal_new_class_handler (I_("escape"),
|
|
|
|
|
G_TYPE_FROM_CLASS (gobject_class),
|
|
|
|
|
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
|
|
|
|
|
G_CALLBACK (escape_cb),
|
|
|
|
|
NULL, NULL,
|
2019-05-29 20:05:19 +00:00
|
|
|
|
NULL,
|
2014-09-08 04:08:01 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
2018-08-05 02:20:58 +00:00
|
|
|
|
gtk_widget_class_add_binding_signal (widget_class,
|
|
|
|
|
GDK_KEY_Escape, 0,
|
|
|
|
|
"escape",
|
|
|
|
|
NULL);
|
2014-09-08 04:08:01 +00:00
|
|
|
|
|
2014-01-29 02:27:26 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkAssistant:use-header-bar:
|
|
|
|
|
*
|
|
|
|
|
* %TRUE if the assistant uses a #GtkHeaderBar for action buttons
|
|
|
|
|
* instead of the action-area.
|
|
|
|
|
*
|
|
|
|
|
* For technical reasons, this property is declared as an integer
|
|
|
|
|
* property, but you should only set it to %TRUE or %FALSE.
|
|
|
|
|
*/
|
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
|
|
|
PROP_USE_HEADER_BAR,
|
|
|
|
|
g_param_spec_int ("use-header-bar",
|
|
|
|
|
P_("Use Header Bar"),
|
|
|
|
|
P_("Use Header Bar for actions."),
|
|
|
|
|
-1, 1, -1,
|
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
|
|
|
|
|
|
2019-02-13 23:27:25 +00:00
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
|
|
|
PROP_PAGES,
|
|
|
|
|
g_param_spec_object ("pages",
|
|
|
|
|
P_("Pages"),
|
2019-02-21 12:28:37 +00:00
|
|
|
|
P_("The pages of the assistant."),
|
2019-02-13 23:27:25 +00:00
|
|
|
|
G_TYPE_LIST_MODEL,
|
|
|
|
|
GTK_PARAM_READABLE));
|
2015-06-15 01:29:09 +00:00
|
|
|
|
|
2013-03-23 10:10:34 +00:00
|
|
|
|
/* Bind class to template
|
|
|
|
|
*/
|
|
|
|
|
gtk_widget_class_set_template_from_resource (widget_class,
|
2020-05-05 01:36:00 +00:00
|
|
|
|
"/org/gtk/libgtk/ui/gtkassistant.ui");
|
|
|
|
|
|
|
|
|
|
gtk_widget_class_bind_template_child_internal (widget_class, GtkAssistant, action_area);
|
|
|
|
|
gtk_widget_class_bind_template_child_internal (widget_class, GtkAssistant, headerbar);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, content);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, cancel);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, forward);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, back);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, apply);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, close);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, last);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, sidebar);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, button_size_group);
|
|
|
|
|
gtk_widget_class_bind_template_child (widget_class, GtkAssistant, title_size_group);
|
2013-07-26 17:49:49 +00:00
|
|
|
|
|
|
|
|
|
gtk_widget_class_bind_template_callback (widget_class, on_assistant_close);
|
|
|
|
|
gtk_widget_class_bind_template_callback (widget_class, on_assistant_apply);
|
|
|
|
|
gtk_widget_class_bind_template_callback (widget_class, on_assistant_forward);
|
|
|
|
|
gtk_widget_class_bind_template_callback (widget_class, on_assistant_back);
|
|
|
|
|
gtk_widget_class_bind_template_callback (widget_class, on_assistant_cancel);
|
|
|
|
|
gtk_widget_class_bind_template_callback (widget_class, on_assistant_last);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-24 13:54:49 +00:00
|
|
|
|
static int
|
|
|
|
|
default_forward_function (int current_page, gpointer data)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2019-05-27 01:20:53 +00:00
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (data);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
GtkAssistantPage *page_info;
|
|
|
|
|
GList *page_node;
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_node = g_list_nth (assistant->pages, ++current_page);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
if (!page_node)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
page_info = (GtkAssistantPage *) page_node->data;
|
|
|
|
|
|
2010-03-01 06:47:38 +00:00
|
|
|
|
while (page_node && !gtk_widget_get_visible (page_info->page))
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
page_node = page_node->next;
|
|
|
|
|
current_page++;
|
2006-01-28 06:03:50 +00:00
|
|
|
|
|
|
|
|
|
if (page_node)
|
2011-01-24 02:50:39 +00:00
|
|
|
|
page_info = (GtkAssistantPage *) page_node->data;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return current_page;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
last_button_visible (GtkAssistant *assistant, GtkAssistantPage *page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2011-04-17 00:45:26 +00:00
|
|
|
|
GtkAssistantPage *page_info;
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int count, page_num, n_pages;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (page == NULL)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
if (page->type != GTK_ASSISTANT_PAGE_CONTENT)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
count = 0;
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_num = g_list_index (assistant->pages, page);
|
|
|
|
|
n_pages = g_list_length (assistant->pages);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
page_info = page;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2006-01-23 19:11:40 +00:00
|
|
|
|
while (page_num >= 0 && page_num < n_pages &&
|
2011-01-24 02:50:39 +00:00
|
|
|
|
page_info->type == GTK_ASSISTANT_PAGE_CONTENT &&
|
|
|
|
|
(count == 0 || page_info->complete) &&
|
|
|
|
|
count < n_pages)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_num = (assistant->forward_function) (page_num, assistant->forward_function_data);
|
|
|
|
|
page_info = g_list_nth_data (assistant->pages, page_num);
|
2006-01-23 19:11:40 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
count++;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
/* Make the last button visible if we can skip multiple
|
2009-05-30 06:14:03 +00:00
|
|
|
|
* pages and end on a confirmation or summary page
|
2006-01-23 19:11:40 +00:00
|
|
|
|
*/
|
2009-05-30 06:14:03 +00:00
|
|
|
|
if (count > 1 && page_info &&
|
2006-01-23 19:11:40 +00:00
|
|
|
|
(page_info->type == GTK_ASSISTANT_PAGE_CONFIRM ||
|
|
|
|
|
page_info->type == GTK_ASSISTANT_PAGE_SUMMARY))
|
2011-04-17 00:45:26 +00:00
|
|
|
|
return TRUE;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
else
|
2011-04-17 00:45:26 +00:00
|
|
|
|
return FALSE;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-06-02 20:00:16 +00:00
|
|
|
|
static void
|
2011-04-17 00:45:26 +00:00
|
|
|
|
update_actions_size (GtkAssistant *assistant)
|
2010-06-02 20:00:16 +00:00
|
|
|
|
{
|
2011-04-17 00:45:26 +00:00
|
|
|
|
GList *l;
|
|
|
|
|
GtkAssistantPage *page;
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int buttons, page_buttons;
|
2010-06-02 20:00:16 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (!assistant->current_page)
|
2011-04-17 00:45:26 +00:00
|
|
|
|
return;
|
2010-06-02 20:00:16 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
/* Some heuristics to find out how many buttons we should
|
|
|
|
|
* reserve space for. It is possible to trick this code
|
|
|
|
|
* with page forward functions and invisible pages, etc.
|
|
|
|
|
*/
|
|
|
|
|
buttons = 0;
|
2020-05-05 01:36:00 +00:00
|
|
|
|
for (l = assistant->pages; l; l = l->next)
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
|
|
|
|
page = l->data;
|
2010-06-02 20:00:16 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (!gtk_widget_get_visible (page->page))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
page_buttons = 2; /* cancel, forward/apply/close */
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (l != assistant->pages)
|
2011-04-17 00:45:26 +00:00
|
|
|
|
page_buttons += 1; /* back */
|
|
|
|
|
if (last_button_visible (assistant, page))
|
|
|
|
|
page_buttons += 1; /* last */
|
|
|
|
|
|
|
|
|
|
buttons = MAX (buttons, page_buttons);
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
buttons += assistant->extra_buttons;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_size_request (assistant->action_area,
|
|
|
|
|
buttons * gtk_widget_get_allocated_width (assistant->cancel) + (buttons - 1) * 6,
|
2011-04-17 00:45:26 +00:00
|
|
|
|
-1);
|
2010-06-02 20:00:16 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
static void
|
2011-04-17 00:45:26 +00:00
|
|
|
|
compute_last_button_state (GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_sensitive (assistant->last, assistant->current_page->complete);
|
|
|
|
|
if (last_button_visible (assistant, assistant->current_page))
|
|
|
|
|
gtk_widget_show (assistant->last);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
else
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_hide (assistant->last);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2011-04-17 00:45:26 +00:00
|
|
|
|
compute_progress_state (GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int page_num, n_pages;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
|
|
|
|
n_pages = gtk_assistant_get_n_pages (assistant);
|
|
|
|
|
page_num = gtk_assistant_get_current_page (assistant);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_num = (assistant->forward_function) (page_num, assistant->forward_function_data);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (page_num >= 0 && page_num < n_pages)
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_show (assistant->forward);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
else
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_hide (assistant->forward);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2011-04-17 00:45:26 +00:00
|
|
|
|
update_buttons_state (GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (!assistant->current_page)
|
2007-06-06 14:24:31 +00:00
|
|
|
|
return;
|
2011-01-24 02:50:39 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
switch (assistant->current_page->type)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
case GTK_ASSISTANT_PAGE_INTRO:
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_sensitive (assistant->cancel, TRUE);
|
|
|
|
|
gtk_widget_set_sensitive (assistant->forward, assistant->current_page->complete);
|
|
|
|
|
gtk_window_set_default_widget (GTK_WINDOW (assistant), assistant->forward);
|
|
|
|
|
gtk_widget_show (assistant->forward);
|
|
|
|
|
gtk_widget_hide (assistant->back);
|
|
|
|
|
gtk_widget_hide (assistant->apply);
|
|
|
|
|
gtk_widget_hide (assistant->close);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
compute_last_button_state (assistant);
|
|
|
|
|
break;
|
|
|
|
|
case GTK_ASSISTANT_PAGE_CONFIRM:
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_sensitive (assistant->cancel, TRUE);
|
|
|
|
|
gtk_widget_set_sensitive (assistant->back, TRUE);
|
|
|
|
|
gtk_widget_set_sensitive (assistant->apply, assistant->current_page->complete);
|
|
|
|
|
gtk_window_set_default_widget (GTK_WINDOW (assistant), 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);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
|
|
|
|
case GTK_ASSISTANT_PAGE_CONTENT:
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_sensitive (assistant->cancel, TRUE);
|
|
|
|
|
gtk_widget_set_sensitive (assistant->back, TRUE);
|
|
|
|
|
gtk_widget_set_sensitive (assistant->forward, assistant->current_page->complete);
|
|
|
|
|
gtk_window_set_default_widget (GTK_WINDOW (assistant), assistant->forward);
|
|
|
|
|
gtk_widget_show (assistant->back);
|
|
|
|
|
gtk_widget_show (assistant->forward);
|
|
|
|
|
gtk_widget_hide (assistant->apply);
|
|
|
|
|
gtk_widget_hide (assistant->close);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
compute_last_button_state (assistant);
|
|
|
|
|
break;
|
|
|
|
|
case GTK_ASSISTANT_PAGE_SUMMARY:
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_sensitive (assistant->close, assistant->current_page->complete);
|
|
|
|
|
gtk_window_set_default_widget (GTK_WINDOW (assistant), 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);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
|
|
|
|
case GTK_ASSISTANT_PAGE_PROGRESS:
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_sensitive (assistant->cancel, assistant->current_page->complete);
|
|
|
|
|
gtk_widget_set_sensitive (assistant->back, assistant->current_page->complete);
|
|
|
|
|
gtk_widget_set_sensitive (assistant->forward, assistant->current_page->complete);
|
|
|
|
|
gtk_window_set_default_widget (GTK_WINDOW (assistant), assistant->forward);
|
|
|
|
|
gtk_widget_show (assistant->back);
|
|
|
|
|
gtk_widget_hide (assistant->apply);
|
|
|
|
|
gtk_widget_hide (assistant->close);
|
|
|
|
|
gtk_widget_hide (assistant->last);
|
2010-06-02 20:00:16 +00:00
|
|
|
|
compute_progress_state (assistant);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
2010-10-30 19:12:58 +00:00
|
|
|
|
case GTK_ASSISTANT_PAGE_CUSTOM:
|
2020-05-05 01:36:00 +00:00
|
|
|
|
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);
|
|
|
|
|
gtk_widget_hide (assistant->close);
|
2010-10-30 19:12:58 +00:00
|
|
|
|
break;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
default:
|
|
|
|
|
g_assert_not_reached ();
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->committed)
|
|
|
|
|
gtk_widget_hide (assistant->cancel);
|
|
|
|
|
else if (assistant->current_page->type == GTK_ASSISTANT_PAGE_SUMMARY ||
|
|
|
|
|
assistant->current_page->type == GTK_ASSISTANT_PAGE_CUSTOM)
|
|
|
|
|
gtk_widget_hide (assistant->cancel);
|
2010-06-02 20:00:16 +00:00
|
|
|
|
else
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_show (assistant->cancel);
|
2010-06-02 20:00:16 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
/* this is quite general, we don't want to
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* go back if it's the first page
|
|
|
|
|
*/
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (!assistant->visited_pages)
|
|
|
|
|
gtk_widget_hide (assistant->back);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
update_page_title_state (GtkAssistant *assistant, GList *list)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2011-04-17 00:45:26 +00:00
|
|
|
|
GtkAssistantPage *page, *other;
|
|
|
|
|
gboolean visible;
|
|
|
|
|
GList *l;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
page = list->data;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (page->title == NULL || page->title[0] == 0)
|
|
|
|
|
visible = FALSE;
|
|
|
|
|
else
|
|
|
|
|
visible = gtk_widget_get_visible (page->page);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (page == assistant->current_page)
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_widget_set_visible (page->regular_title, FALSE);
|
|
|
|
|
gtk_widget_set_visible (page->current_title, visible);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* If multiple consecutive pages have the same title,
|
|
|
|
|
* we only show it once, since it would otherwise look
|
|
|
|
|
* silly. We have to be a little careful, since we
|
|
|
|
|
* _always_ show the title of the current page.
|
|
|
|
|
*/
|
|
|
|
|
if (list->prev)
|
|
|
|
|
{
|
|
|
|
|
other = list->prev->data;
|
|
|
|
|
if (g_strcmp0 (page->title, other->title) == 0)
|
|
|
|
|
visible = FALSE;
|
|
|
|
|
}
|
|
|
|
|
for (l = list->next; l; l = l->next)
|
|
|
|
|
{
|
|
|
|
|
other = l->data;
|
|
|
|
|
if (g_strcmp0 (page->title, other->title) != 0)
|
|
|
|
|
break;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (other == assistant->current_page)
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
|
|
|
|
visible = FALSE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
gtk_widget_set_visible (page->regular_title, visible);
|
|
|
|
|
gtk_widget_set_visible (page->current_title, FALSE);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
2011-01-24 02:50:39 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
return visible;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
update_title_state (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
GList *l;
|
|
|
|
|
gboolean show_titles;
|
|
|
|
|
|
|
|
|
|
show_titles = FALSE;
|
2020-05-05 01:36:00 +00:00
|
|
|
|
for (l = assistant->pages; l != NULL; l = l->next)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (update_page_title_state (assistant, l))
|
|
|
|
|
show_titles = TRUE;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_widget_set_visible (assistant->sidebar, show_titles);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
set_current_page (GtkAssistant *assistant,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int page_num)
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->current_page = (GtkAssistantPage *)g_list_nth_data (assistant->pages, page_num);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
g_signal_emit (assistant, signals [PREPARE], 0, assistant->current_page->page);
|
2012-09-08 12:21:32 +00:00
|
|
|
|
/* do not continue if the prepare signal handler has already changed the
|
|
|
|
|
* current page */
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->current_page != (GtkAssistantPage *)g_list_nth_data (assistant->pages, page_num))
|
2012-09-08 12:21:32 +00:00
|
|
|
|
return;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
|
|
|
|
update_title_state (assistant);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_window_set_title (GTK_WINDOW (assistant), assistant->current_page->title);
|
2014-01-29 03:36:16 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_stack_set_visible_child (GTK_STACK (assistant->content), assistant->current_page->page);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
|
|
|
|
/* update buttons state, flow may have changed */
|
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
|
|
|
|
update_buttons_state (assistant);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (!gtk_widget_child_focus (assistant->current_page->page, GTK_DIR_TAB_FORWARD))
|
2009-02-17 05:36:12 +00:00
|
|
|
|
{
|
|
|
|
|
GtkWidget *button[6];
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int i;
|
2009-02-17 05:36:12 +00:00
|
|
|
|
|
|
|
|
|
/* find the best button to focus */
|
2020-05-05 01:36:00 +00:00
|
|
|
|
button[0] = assistant->apply;
|
|
|
|
|
button[1] = assistant->close;
|
|
|
|
|
button[2] = assistant->forward;
|
|
|
|
|
button[3] = assistant->back;
|
|
|
|
|
button[4] = assistant->cancel;
|
|
|
|
|
button[5] = assistant->last;
|
2009-02-17 05:36:12 +00:00
|
|
|
|
for (i = 0; i < 6; i++)
|
|
|
|
|
{
|
2011-01-24 02:50:39 +00:00
|
|
|
|
if (gtk_widget_get_visible (button[i]) &&
|
|
|
|
|
gtk_widget_get_sensitive (button[i]))
|
2009-02-17 05:36:12 +00:00
|
|
|
|
{
|
|
|
|
|
gtk_widget_grab_focus (button[i]);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-24 13:54:49 +00:00
|
|
|
|
static int
|
2006-01-18 22:39:14 +00:00
|
|
|
|
compute_next_step (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info;
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int current_page, n_pages, next_page;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
current_page = gtk_assistant_get_current_page (assistant);
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_info = assistant->current_page;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
n_pages = gtk_assistant_get_n_pages (assistant);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
next_page = (assistant->forward_function) (current_page,
|
|
|
|
|
assistant->forward_function_data);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
if (next_page >= 0 && next_page < n_pages)
|
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->visited_pages = g_slist_prepend (assistant->visited_pages, page_info);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
set_current_page (assistant, next_page);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2008-08-12 15:20:19 +00:00
|
|
|
|
on_assistant_close (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_signal_emit (assistant, signals [CLOSE], 0, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2008-08-12 15:20:19 +00:00
|
|
|
|
on_assistant_apply (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
gboolean success;
|
|
|
|
|
|
2008-07-18 19:07:39 +00:00
|
|
|
|
g_signal_emit (assistant, signals [APPLY], 0);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2009-08-07 03:52:18 +00:00
|
|
|
|
success = compute_next_step (assistant);
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
/* 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)
|
2008-07-18 19:07:39 +00:00
|
|
|
|
g_signal_emit (assistant, signals [CLOSE], 0);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2008-08-12 15:20:19 +00:00
|
|
|
|
on_assistant_forward (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2010-10-30 19:12:58 +00:00
|
|
|
|
gtk_assistant_next_page (assistant);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2008-08-12 15:20:19 +00:00
|
|
|
|
on_assistant_back (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2010-10-30 19:12:58 +00:00
|
|
|
|
gtk_assistant_previous_page (assistant);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2008-08-12 15:20:19 +00:00
|
|
|
|
on_assistant_cancel (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_signal_emit (assistant, signals [CANCEL], 0, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2008-08-12 15:20:19 +00:00
|
|
|
|
on_assistant_last (GtkWidget *widget,
|
|
|
|
|
GtkAssistant *assistant)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
while (assistant->current_page->type == GTK_ASSISTANT_PAGE_CONTENT &&
|
|
|
|
|
assistant->current_page->complete)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
compute_next_step (assistant);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
alternative_button_order (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
gboolean result;
|
|
|
|
|
|
2017-10-30 23:07:14 +00:00
|
|
|
|
g_object_get (gtk_widget_get_settings (GTK_WIDGET (assistant)),
|
2011-01-24 02:50:39 +00:00
|
|
|
|
"gtk-alternative-button-order", &result,
|
|
|
|
|
NULL);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-09 18:48:04 +00:00
|
|
|
|
static void
|
2019-02-07 20:18:49 +00:00
|
|
|
|
on_page_page_notify (GtkWidget *widget,
|
|
|
|
|
GParamSpec *arg,
|
|
|
|
|
gpointer data)
|
2011-07-09 18:48:04 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (data);
|
|
|
|
|
|
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
|
|
|
|
{
|
|
|
|
|
update_buttons_state (assistant);
|
|
|
|
|
update_title_state (assistant);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
static void
|
|
|
|
|
on_page_notify (GtkAssistantPage *page,
|
|
|
|
|
GParamSpec *arg,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
if (page->page)
|
|
|
|
|
on_page_page_notify (page->page, arg, data);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-09 18:48:04 +00:00
|
|
|
|
static void
|
2020-05-02 19:17:20 +00:00
|
|
|
|
assistant_remove_page (GtkAssistant *assistant,
|
|
|
|
|
GtkWidget *page)
|
2011-07-09 18:48:04 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info;
|
|
|
|
|
GList *page_node;
|
|
|
|
|
GList *element;
|
|
|
|
|
|
|
|
|
|
element = find_page (assistant, page);
|
|
|
|
|
if (!element)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
page_info = element->data;
|
|
|
|
|
|
|
|
|
|
/* If this is the current page, we need to switch away. */
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (page_info == assistant->current_page)
|
2011-07-09 18:48:04 +00:00
|
|
|
|
{
|
|
|
|
|
if (!compute_next_step (assistant))
|
|
|
|
|
{
|
|
|
|
|
/* The best we can do at this point is probably to pick
|
|
|
|
|
* the first visible page.
|
|
|
|
|
*/
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_node = assistant->pages;
|
2011-07-09 18:48:04 +00:00
|
|
|
|
|
|
|
|
|
while (page_node &&
|
|
|
|
|
!gtk_widget_get_visible (((GtkAssistantPage *) page_node->data)->page))
|
|
|
|
|
page_node = page_node->next;
|
|
|
|
|
|
|
|
|
|
if (page_node == element)
|
|
|
|
|
page_node = page_node->next;
|
|
|
|
|
|
|
|
|
|
if (page_node)
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->current_page = page_node->data;
|
2011-07-09 18:48:04 +00:00
|
|
|
|
else
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->current_page = NULL;
|
2011-07-09 18:48:04 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_signal_handlers_disconnect_by_func (page_info->page, on_page_page_notify, assistant);
|
|
|
|
|
g_signal_handlers_disconnect_by_func (page_info, on_page_notify, assistant);
|
2011-07-09 18:48:04 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_size_group_remove_widget (assistant->title_size_group, page_info->regular_title);
|
|
|
|
|
gtk_size_group_remove_widget (assistant->title_size_group, page_info->current_title);
|
2011-07-09 18:48:04 +00:00
|
|
|
|
|
2020-05-09 12:26:52 +00:00
|
|
|
|
gtk_box_remove (GTK_BOX (assistant->sidebar), page_info->regular_title);
|
|
|
|
|
gtk_box_remove (GTK_BOX (assistant->sidebar), page_info->current_title);
|
2011-07-09 18:48:04 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->pages = g_list_remove_link (assistant->pages, element);
|
|
|
|
|
assistant->visited_pages = g_slist_remove_all (assistant->visited_pages, page_info);
|
2011-07-09 18:48:04 +00:00
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_object_unref (page_info);
|
2011-07-09 18:48:04 +00:00
|
|
|
|
|
|
|
|
|
g_list_free_1 (element);
|
|
|
|
|
|
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
|
|
|
|
{
|
|
|
|
|
update_buttons_state (assistant);
|
|
|
|
|
update_actions_size (assistant);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_init (GtkAssistant *assistant)
|
|
|
|
|
{
|
2020-05-20 07:07:24 +00:00
|
|
|
|
gtk_widget_add_css_class (GTK_WIDGET (assistant), "assistant");
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->pages = NULL;
|
|
|
|
|
assistant->current_page = NULL;
|
|
|
|
|
assistant->visited_pages = NULL;
|
2013-06-27 19:02:52 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->forward_function = default_forward_function;
|
|
|
|
|
assistant->forward_function_data = assistant;
|
|
|
|
|
assistant->forward_data_destroy = NULL;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2014-01-29 02:27:26 +00:00
|
|
|
|
g_object_get (gtk_widget_get_settings (GTK_WIDGET (assistant)),
|
2020-05-05 01:36:00 +00:00
|
|
|
|
"gtk-dialogs-use-header", &assistant->use_header_bar,
|
2014-01-29 02:27:26 +00:00
|
|
|
|
NULL);
|
|
|
|
|
|
2013-03-23 10:10:34 +00:00
|
|
|
|
gtk_widget_init_template (GTK_WIDGET (assistant));
|
|
|
|
|
|
|
|
|
|
if (alternative_button_order (assistant))
|
|
|
|
|
{
|
|
|
|
|
GList *buttons, *l;
|
2020-05-09 12:26:52 +00:00
|
|
|
|
GtkWidget *child;
|
2013-03-23 10:10:34 +00:00
|
|
|
|
|
2020-05-09 12:26:52 +00:00
|
|
|
|
buttons = NULL;
|
|
|
|
|
for (child = gtk_widget_get_last_child (assistant->action_area);
|
|
|
|
|
child != NULL;
|
|
|
|
|
child = gtk_widget_get_prev_sibling (child))
|
|
|
|
|
buttons = g_list_prepend (buttons, child);
|
2013-03-23 10:10:34 +00:00
|
|
|
|
|
|
|
|
|
for (l = buttons; l; l = l->next)
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_box_reorder_child_after (GTK_BOX (assistant->action_area), GTK_WIDGET (l->data), NULL);
|
2013-03-23 10:10:34 +00:00
|
|
|
|
|
|
|
|
|
g_list_free (buttons);
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2019-02-07 20:18:49 +00:00
|
|
|
|
gtk_assistant_page_set_property (GObject *object,
|
|
|
|
|
guint property_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2019-02-07 20:18:49 +00:00
|
|
|
|
GtkAssistantPage *page = GTK_ASSISTANT_PAGE (object);
|
|
|
|
|
GtkWidget *assistant = NULL;
|
|
|
|
|
|
|
|
|
|
if (page->page)
|
|
|
|
|
assistant = gtk_widget_get_ancestor (page->page, GTK_TYPE_ASSISTANT);
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
switch (property_id)
|
|
|
|
|
{
|
2019-02-07 20:18:49 +00:00
|
|
|
|
case CHILD_PROP_CHILD:
|
|
|
|
|
g_set_object (&page->page, g_value_get_object (value));
|
|
|
|
|
break;
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
case CHILD_PROP_PAGE_TYPE:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
if (page->type != g_value_get_enum (value))
|
|
|
|
|
{
|
|
|
|
|
page->type = g_value_get_enum (value);
|
|
|
|
|
|
|
|
|
|
/* backwards compatibility to the era before fixing bug 604289 */
|
|
|
|
|
if (page->type == GTK_ASSISTANT_PAGE_SUMMARY && !page->complete_set)
|
|
|
|
|
{
|
|
|
|
|
page->complete = TRUE;
|
|
|
|
|
page->complete_set = FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Always set buttons state, a change in a future page
|
|
|
|
|
* might change current page buttons
|
|
|
|
|
*/
|
|
|
|
|
if (assistant)
|
|
|
|
|
update_buttons_state (GTK_ASSISTANT (assistant));
|
|
|
|
|
g_object_notify (G_OBJECT (page), "page-type");
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
case CHILD_PROP_PAGE_TITLE:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_free (page->title);
|
|
|
|
|
page->title = g_value_dup_string (value);
|
|
|
|
|
|
|
|
|
|
if (assistant)
|
|
|
|
|
{
|
|
|
|
|
gtk_label_set_text ((GtkLabel*) page->regular_title, page->title);
|
|
|
|
|
gtk_label_set_text ((GtkLabel*) page->current_title, page->title);
|
|
|
|
|
update_title_state (GTK_ASSISTANT (assistant));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (page), "title");
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
case CHILD_PROP_PAGE_COMPLETE:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
if (page->complete != g_value_get_boolean (value))
|
|
|
|
|
{
|
|
|
|
|
page->complete = g_value_get_boolean (value);
|
|
|
|
|
page->complete_set = TRUE;
|
|
|
|
|
|
|
|
|
|
/* Always set buttons state, a change in a future page
|
|
|
|
|
* might change current page buttons
|
|
|
|
|
*/
|
|
|
|
|
if (assistant)
|
|
|
|
|
update_buttons_state (GTK_ASSISTANT (assistant));
|
|
|
|
|
g_object_notify (G_OBJECT (page), "complete");
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
default:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2019-02-07 20:18:49 +00:00
|
|
|
|
gtk_assistant_page_get_property (GObject *object,
|
|
|
|
|
guint property_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2019-02-07 20:18:49 +00:00
|
|
|
|
GtkAssistantPage *page = GTK_ASSISTANT_PAGE (object);
|
2011-11-08 03:56:36 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
switch (property_id)
|
|
|
|
|
{
|
2019-02-07 20:18:49 +00:00
|
|
|
|
case CHILD_PROP_CHILD:
|
|
|
|
|
g_value_set_object (value, page->page);
|
|
|
|
|
break;
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
case CHILD_PROP_PAGE_TYPE:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_value_set_enum (value, page->type);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
case CHILD_PROP_PAGE_TITLE:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_value_set_string (value, page->title);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
case CHILD_PROP_PAGE_COMPLETE:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_value_set_boolean (value, page->complete);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
default:
|
2019-02-07 20:18:49 +00:00
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2020-05-02 19:17:20 +00:00
|
|
|
|
gtk_assistant_dispose (GObject *object)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-02 19:17:20 +00:00
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (object);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->model)
|
|
|
|
|
g_list_model_items_changed (G_LIST_MODEL (assistant->model), 0, g_list_length (assistant->pages), 0);
|
2019-02-13 23:27:25 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
/* We set current to NULL so that the remove code doesn't try
|
|
|
|
|
* to do anything funny
|
|
|
|
|
*/
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->current_page = NULL;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->content)
|
2011-07-09 18:48:04 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
while (assistant->pages)
|
2020-05-02 19:17:20 +00:00
|
|
|
|
gtk_assistant_remove_page (assistant, 0);
|
2011-07-09 18:48:04 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->content = NULL;
|
2011-07-09 18:48:04 +00:00
|
|
|
|
}
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->sidebar = NULL;
|
|
|
|
|
assistant->action_area = NULL;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->forward_function)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->forward_function_data &&
|
|
|
|
|
assistant->forward_data_destroy)
|
|
|
|
|
assistant->forward_data_destroy (assistant->forward_function_data);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->forward_function = NULL;
|
|
|
|
|
assistant->forward_function_data = NULL;
|
|
|
|
|
assistant->forward_data_destroy = NULL;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->visited_pages)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
g_slist_free (assistant->visited_pages);
|
|
|
|
|
assistant->visited_pages = NULL;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-05-02 19:17:20 +00:00
|
|
|
|
G_OBJECT_CLASS (gtk_assistant_parent_class)->dispose (object);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GList*
|
|
|
|
|
find_page (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
GList *child = assistant->pages;
|
2011-01-24 02:50:39 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
while (child)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info = child->data;
|
2019-02-14 19:46:01 +00:00
|
|
|
|
if (page_info->page == page)
|
2011-01-24 02:50:39 +00:00
|
|
|
|
return child;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
child = child->next;
|
|
|
|
|
}
|
2011-01-24 02:50:39 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_map (GtkWidget *widget)
|
|
|
|
|
{
|
2006-01-19 16:51:21 +00:00
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (widget);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
GList *page_node;
|
2009-07-17 02:06:40 +00:00
|
|
|
|
GtkAssistantPage *page;
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int page_num;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
/* if there's no default page, pick the first one */
|
2009-07-17 02:06:40 +00:00
|
|
|
|
page = NULL;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
page_num = 0;
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (!assistant->current_page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_node = assistant->pages;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2010-03-01 06:47:38 +00:00
|
|
|
|
while (page_node && !gtk_widget_get_visible (((GtkAssistantPage *) page_node->data)->page))
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
|
|
|
|
page_node = page_node->next;
|
|
|
|
|
page_num++;
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
if (page_node)
|
2011-01-24 02:50:39 +00:00
|
|
|
|
page = page_node->data;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (page && gtk_widget_get_visible (page->page))
|
|
|
|
|
set_current_page (assistant, page_num);
|
|
|
|
|
|
|
|
|
|
update_buttons_state (assistant);
|
|
|
|
|
update_actions_size (assistant);
|
|
|
|
|
update_title_state (assistant);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_assistant_parent_class)->map (widget);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_unmap (GtkWidget *widget)
|
|
|
|
|
{
|
2006-01-19 16:51:21 +00:00
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (widget);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
g_slist_free (assistant->visited_pages);
|
|
|
|
|
assistant->visited_pages = NULL;
|
|
|
|
|
assistant->current_page = NULL;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_assistant_parent_class)->unmap (widget);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2018-01-01 20:24:16 +00:00
|
|
|
|
gtk_assistant_close_request (GtkWindow *window)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2018-01-01 20:24:16 +00:00
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (window);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
/* Do not allow cancelling in the middle of a progress page */
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->current_page &&
|
|
|
|
|
(assistant->current_page->type != GTK_ASSISTANT_PAGE_PROGRESS ||
|
|
|
|
|
assistant->current_page->complete))
|
2018-01-01 20:24:16 +00:00
|
|
|
|
g_signal_emit (assistant, signals [CANCEL], 0, NULL);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_new:
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* Creates a new #GtkAssistant.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: a newly created #GtkAssistant
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
GtkWidget*
|
|
|
|
|
gtk_assistant_new (void)
|
|
|
|
|
{
|
|
|
|
|
GtkWidget *assistant;
|
|
|
|
|
|
2009-04-18 18:42:43 +00:00
|
|
|
|
assistant = g_object_new (GTK_TYPE_ASSISTANT, NULL);
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
return assistant;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_current_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
*
|
2011-04-17 00:45:26 +00:00
|
|
|
|
* Returns the page number of the current page.
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: The index (starting from 0) of the current
|
2011-04-17 00:45:26 +00:00
|
|
|
|
* page in the @assistant, or -1 if the @assistant has no pages,
|
|
|
|
|
* or no current page.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int
|
2006-01-18 22:39:14 +00:00
|
|
|
|
gtk_assistant_get_current_page (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), -1);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (!assistant->pages || !assistant->current_page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
return -1;
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
return g_list_index (assistant->pages, assistant->current_page);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_set_current_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
* @page_num: index of the page to switch to, starting from 0.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* If negative, the last page will be used. If greater
|
|
|
|
|
* than the number of pages in the @assistant, nothing
|
|
|
|
|
* will be done.
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* Switches the page to @page_num.
|
|
|
|
|
*
|
|
|
|
|
* Note that this will only be necessary in custom buttons,
|
|
|
|
|
* as the @assistant flow can be set with
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* gtk_assistant_set_forward_page_func().
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_set_current_page (GtkAssistant *assistant,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int page_num)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
|
|
|
|
|
if (page_num >= 0)
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page = (GtkAssistantPage *) g_list_nth_data (assistant->pages, page_num);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
else
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page = (GtkAssistantPage *) g_list_last (assistant->pages)->data;
|
|
|
|
|
page_num = g_list_length (assistant->pages);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
g_return_if_fail (page != NULL);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->current_page == page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2011-01-24 02:50:39 +00:00
|
|
|
|
/* 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
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*/
|
2010-03-02 04:19:28 +00:00
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->visited_pages = g_slist_prepend (assistant->visited_pages,
|
|
|
|
|
assistant->current_page);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
set_current_page (assistant, page_num);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-10-30 19:12:58 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_next_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
*
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* Navigate to the next page.
|
|
|
|
|
*
|
|
|
|
|
* It is a programming error to call this function when
|
|
|
|
|
* there is no next page.
|
2010-10-30 19:12:58 +00:00
|
|
|
|
*
|
|
|
|
|
* This function is for use when creating pages of the
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* #GTK_ASSISTANT_PAGE_CUSTOM type.
|
|
|
|
|
*/
|
2010-10-30 19:12:58 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_next_page (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
|
|
|
|
|
if (!compute_next_step (assistant))
|
2011-01-24 02:50:39 +00:00
|
|
|
|
g_critical ("Page flow is broken.\n"
|
|
|
|
|
"You may want to end it with a page of type\n"
|
|
|
|
|
"GTK_ASSISTANT_PAGE_CONFIRM or GTK_ASSISTANT_PAGE_SUMMARY");
|
2010-10-30 19:12:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_previous_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
*
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* Navigate to the previous visited page.
|
|
|
|
|
*
|
|
|
|
|
* It is a programming error to call this function when
|
|
|
|
|
* no previous page is available.
|
2010-10-30 19:12:58 +00:00
|
|
|
|
*
|
|
|
|
|
* This function is for use when creating pages of the
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* #GTK_ASSISTANT_PAGE_CUSTOM type.
|
|
|
|
|
*/
|
2010-10-30 19:12:58 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_previous_page (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info;
|
|
|
|
|
GSList *page_node;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
|
|
|
|
|
/* skip the progress pages when going back */
|
|
|
|
|
do
|
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page_node = assistant->visited_pages;
|
2010-10-30 19:12:58 +00:00
|
|
|
|
|
|
|
|
|
g_return_if_fail (page_node != NULL);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->visited_pages = assistant->visited_pages->next;
|
2010-10-30 19:12:58 +00:00
|
|
|
|
page_info = (GtkAssistantPage *) page_node->data;
|
|
|
|
|
g_slist_free_1 (page_node);
|
|
|
|
|
}
|
|
|
|
|
while (page_info->type == GTK_ASSISTANT_PAGE_PROGRESS ||
|
2011-01-24 02:50:39 +00:00
|
|
|
|
!gtk_widget_get_visible (page_info->page));
|
2010-10-30 19:12:58 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
set_current_page (assistant, g_list_index (assistant->pages, page_info));
|
2010-10-30 19:12:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_n_pages:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
*
|
|
|
|
|
* Returns the number of pages in the @assistant
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: the number of pages in the @assistant
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int
|
2006-01-18 22:39:14 +00:00
|
|
|
|
gtk_assistant_get_n_pages (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), 0);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
return g_list_length (assistant->pages);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_nth_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* @page_num: the index of a page in the @assistant,
|
|
|
|
|
* or -1 to get the last page
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*
|
|
|
|
|
* Returns the child widget contained in page number @page_num.
|
|
|
|
|
*
|
2015-12-28 20:14:08 +00:00
|
|
|
|
* Returns: (nullable) (transfer none): the child widget, or %NULL
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* if @page_num is out of bounds
|
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
GtkWidget*
|
|
|
|
|
gtk_assistant_get_nth_page (GtkAssistant *assistant,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int page_num)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page;
|
|
|
|
|
GList *elem;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), NULL);
|
2010-02-23 16:23:10 +00:00
|
|
|
|
g_return_val_if_fail (page_num >= -1, NULL);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2010-02-23 16:23:10 +00:00
|
|
|
|
if (page_num == -1)
|
2020-05-05 01:36:00 +00:00
|
|
|
|
elem = g_list_last (assistant->pages);
|
2010-02-23 16:23:10 +00:00
|
|
|
|
else
|
2020-05-05 01:36:00 +00:00
|
|
|
|
elem = g_list_nth (assistant->pages, page_num);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: the index (starting at 0) of the inserted page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int
|
2006-01-18 22:39:14 +00:00
|
|
|
|
gtk_assistant_prepend_page (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), 0);
|
|
|
|
|
g_return_val_if_fail (GTK_IS_WIDGET (page), 0);
|
|
|
|
|
|
|
|
|
|
return gtk_assistant_insert_page (assistant, page, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_append_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
* @page: a #GtkWidget
|
|
|
|
|
*
|
|
|
|
|
* Appends a page to the @assistant.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: the index (starting at 0) of the inserted page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int
|
2006-01-18 22:39:14 +00:00
|
|
|
|
gtk_assistant_append_page (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), 0);
|
|
|
|
|
g_return_val_if_fail (GTK_IS_WIDGET (page), 0);
|
|
|
|
|
|
|
|
|
|
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,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* or -1 to append the page to the @assistant
|
2006-01-18 22:39:14 +00:00
|
|
|
|
*
|
|
|
|
|
* Inserts a page in the @assistant at a given position.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: the index (starting from 0) of the inserted page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int
|
2006-01-18 22:39:14 +00:00
|
|
|
|
gtk_assistant_insert_page (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int position)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), 0);
|
|
|
|
|
g_return_val_if_fail (GTK_IS_WIDGET (page), 0);
|
2010-08-11 21:18:32 +00:00
|
|
|
|
g_return_val_if_fail (gtk_widget_get_parent (page) == NULL, 0);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
page_info = g_object_new (GTK_TYPE_ASSISTANT_PAGE, NULL);
|
|
|
|
|
page_info->page = g_object_ref (page);
|
|
|
|
|
|
|
|
|
|
return gtk_assistant_add_page (assistant, page_info, position);
|
2019-02-08 14:49:54 +00:00
|
|
|
|
|
|
|
|
|
g_object_unref (page_info);
|
2019-02-07 20:18:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
gtk_assistant_add_page (GtkAssistant *assistant,
|
|
|
|
|
GtkAssistantPage *page_info,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int position)
|
2019-02-07 20:18:49 +00:00
|
|
|
|
{
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int n_pages;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
GtkWidget *sibling;
|
2019-02-14 19:07:46 +00:00
|
|
|
|
char *name;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
|
|
|
|
page_info->regular_title = gtk_label_new (page_info->title);
|
|
|
|
|
page_info->current_title = gtk_label_new (page_info->title);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2014-10-01 04:50:25 +00:00
|
|
|
|
gtk_label_set_xalign (GTK_LABEL (page_info->regular_title), 0.0);
|
|
|
|
|
gtk_label_set_xalign (GTK_LABEL (page_info->current_title), 0.0);
|
2014-05-13 12:45:00 +00:00
|
|
|
|
|
|
|
|
|
gtk_widget_show (page_info->regular_title);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
gtk_widget_hide (page_info->current_title);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-08-13 23:49:02 +00:00
|
|
|
|
gtk_widget_add_css_class (page_info->current_title, "highlight");
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_size_group_add_widget (assistant->title_size_group, page_info->regular_title);
|
|
|
|
|
gtk_size_group_add_widget (assistant->title_size_group, page_info->current_title);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_signal_connect (G_OBJECT (page_info->page), "notify::visible",
|
|
|
|
|
G_CALLBACK (on_page_page_notify), assistant);
|
2015-10-26 13:01:07 +00:00
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_signal_connect (G_OBJECT (page_info), "notify::page-title",
|
2015-10-26 13:01:07 +00:00
|
|
|
|
G_CALLBACK (on_page_notify), assistant);
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_signal_connect (G_OBJECT (page_info), "notify::page-type",
|
2015-10-26 13:01:07 +00:00
|
|
|
|
G_CALLBACK (on_page_notify), assistant);
|
2011-01-04 00:57:50 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
n_pages = g_list_length (assistant->pages);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
if (position < 0 || position > n_pages)
|
|
|
|
|
position = n_pages;
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->pages = g_list_insert (assistant->pages, g_object_ref (page_info), position);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2019-01-22 23:44:34 +00:00
|
|
|
|
if (position == 0)
|
|
|
|
|
sibling = NULL;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int i;
|
2020-05-05 01:36:00 +00:00
|
|
|
|
sibling = gtk_widget_get_first_child (assistant->sidebar);
|
2019-01-22 23:44:34 +00:00
|
|
|
|
for (i = 1; i < 2 * position; i++)
|
|
|
|
|
sibling = gtk_widget_get_next_sibling (sibling);
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_box_insert_child_after (GTK_BOX (assistant->sidebar), page_info->current_title, sibling);
|
|
|
|
|
gtk_box_insert_child_after (GTK_BOX (assistant->sidebar), page_info->regular_title, sibling);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2019-02-14 19:46:01 +00:00
|
|
|
|
name = g_strdup_printf ("%p", page_info->page);
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_stack_add_named (GTK_STACK (assistant->content), page_info->page, name);
|
2019-02-14 19:07:46 +00:00
|
|
|
|
g_free (name);
|
2011-04-17 00:45:26 +00:00
|
|
|
|
|
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
2011-04-17 00:45:26 +00:00
|
|
|
|
update_buttons_state (assistant);
|
|
|
|
|
update_actions_size (assistant);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->model)
|
|
|
|
|
g_list_model_items_changed (assistant->model, position, 0, 1);
|
2019-02-13 23:27:25 +00:00
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
return position;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-12 01:46:38 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_remove_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
* @page_num: the index of a page in the @assistant,
|
2011-09-13 08:08:22 +00:00
|
|
|
|
* or -1 to remove the last page
|
2011-07-12 01:46:38 +00:00
|
|
|
|
*
|
2014-02-07 18:01:26 +00:00
|
|
|
|
* Removes the @page_num’s page from @assistant.
|
2011-07-12 01:46:38 +00:00
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_assistant_remove_page (GtkAssistant *assistant,
|
2020-07-24 13:54:49 +00:00
|
|
|
|
int page_num)
|
2011-07-12 01:46:38 +00:00
|
|
|
|
{
|
|
|
|
|
GtkWidget *page;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
|
|
|
|
|
page = gtk_assistant_get_nth_page (assistant, page_num);
|
|
|
|
|
if (page)
|
2020-05-02 19:17:20 +00:00
|
|
|
|
assistant_remove_page (assistant, page);
|
2019-02-13 23:27:25 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->model)
|
|
|
|
|
g_list_model_items_changed (assistant->model, page_num, 1, 0);
|
2011-07-12 01:46:38 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_set_forward_page_func:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* @page_func: (allow-none): the #GtkAssistantPageFunc, or %NULL
|
|
|
|
|
* to use the default one
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* @data: user data for @page_func
|
|
|
|
|
* @destroy: destroy notifier for @data
|
|
|
|
|
*
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* 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 visible page.
|
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_set_forward_page_func (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkAssistantPageFunc page_func,
|
|
|
|
|
gpointer data,
|
|
|
|
|
GDestroyNotify destroy)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->forward_data_destroy &&
|
|
|
|
|
assistant->forward_function_data)
|
|
|
|
|
(*assistant->forward_data_destroy) (assistant->forward_function_data);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
|
|
|
|
if (page_func)
|
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->forward_function = page_func;
|
|
|
|
|
assistant->forward_function_data = data;
|
|
|
|
|
assistant->forward_data_destroy = destroy;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->forward_function = default_forward_function;
|
|
|
|
|
assistant->forward_function_data = assistant;
|
|
|
|
|
assistant->forward_data_destroy = NULL;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
2006-01-28 06:03:50 +00:00
|
|
|
|
|
|
|
|
|
/* Page flow has possibly changed, so the
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* buttons state might need to change too
|
|
|
|
|
*/
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
|
|
|
|
update_buttons_state (assistant);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-29 02:27:26 +00:00
|
|
|
|
static void
|
|
|
|
|
add_to_action_area (GtkAssistant *assistant,
|
|
|
|
|
GtkWidget *child)
|
|
|
|
|
{
|
|
|
|
|
gtk_widget_set_valign (child, GTK_ALIGN_BASELINE);
|
|
|
|
|
|
2020-05-09 12:26:52 +00:00
|
|
|
|
gtk_box_append (GTK_BOX (assistant->action_area), child);
|
2014-01-29 02:27:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-01-18 22:39:14 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_add_action_widget:
|
2006-01-28 06:03:50 +00:00
|
|
|
|
* @assistant: a #GtkAssistant
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* @child: a #GtkWidget
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* Adds a widget to the action area of a #GtkAssistant.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_add_action_widget (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *child)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
|
|
|
|
|
|
|
|
if (GTK_IS_BUTTON (child))
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_size_group_add_widget (assistant->button_size_group, child);
|
|
|
|
|
assistant->extra_buttons += 1;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
|
|
|
|
update_actions_size (assistant);
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->constructed && assistant->use_header_bar)
|
2014-01-29 02:27:26 +00:00
|
|
|
|
add_to_header_bar (assistant, child);
|
|
|
|
|
else
|
|
|
|
|
add_to_action_area (assistant, child);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_remove_action_widget:
|
2006-01-28 06:03:50 +00:00
|
|
|
|
* @assistant: a #GtkAssistant
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* @child: a #GtkWidget
|
|
|
|
|
*
|
|
|
|
|
* Removes a widget from the action area of a #GtkAssistant.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_remove_action_widget (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *child)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (child));
|
|
|
|
|
|
|
|
|
|
if (GTK_IS_BUTTON (child))
|
2011-04-17 00:45:26 +00:00
|
|
|
|
{
|
2020-05-05 01:36:00 +00:00
|
|
|
|
gtk_size_group_remove_widget (assistant->button_size_group, child);
|
|
|
|
|
assistant->extra_buttons -= 1;
|
2011-04-17 00:45:26 +00:00
|
|
|
|
if (gtk_widget_get_mapped (GTK_WIDGET (assistant)))
|
|
|
|
|
update_actions_size (assistant);
|
|
|
|
|
}
|
2006-01-18 22:39:14 +00:00
|
|
|
|
|
2020-05-09 12:26:52 +00:00
|
|
|
|
gtk_box_remove (GTK_BOX (assistant->action_area), child);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_set_page_title:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
2006-07-17 03:43:29 +00:00
|
|
|
|
* @page: a page of @assistant
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* @title: the new title for @page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
|
|
|
|
* Sets a title for @page.
|
|
|
|
|
*
|
|
|
|
|
* The title is displayed in the header area of the assistant
|
|
|
|
|
* when @page is the current page.
|
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_set_page_title (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page,
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *title)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info;
|
|
|
|
|
GList *child;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (page));
|
|
|
|
|
|
|
|
|
|
child = find_page (assistant, page);
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (child != NULL);
|
|
|
|
|
|
|
|
|
|
page_info = (GtkAssistantPage*) child->data;
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_object_set (page_info, "title", title, NULL);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_page_title:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
* @page: a page of @assistant
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the title for @page.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: the title for @page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *
|
2006-01-18 22:39:14 +00:00
|
|
|
|
gtk_assistant_get_page_title (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
child = find_page (assistant, page);
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (child != NULL, NULL);
|
|
|
|
|
|
|
|
|
|
page_info = (GtkAssistantPage*) child->data;
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
return page_info->title;
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_set_page_type:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
2006-07-17 03:43:29 +00:00
|
|
|
|
* @page: a page of @assistant
|
2006-01-18 22:39:14 +00:00
|
|
|
|
* @type: the new type for @page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
|
|
|
|
* Sets the page type for @page.
|
|
|
|
|
*
|
|
|
|
|
* The page type determines the page behavior in the @assistant.
|
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_set_page_type (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page,
|
|
|
|
|
GtkAssistantPageType type)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info;
|
|
|
|
|
GList *child;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (page));
|
|
|
|
|
|
|
|
|
|
child = find_page (assistant, page);
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (child != NULL);
|
|
|
|
|
|
|
|
|
|
page_info = (GtkAssistantPage*) child->data;
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_object_set (page_info, "page-type", type, NULL);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_page_type:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
* @page: a page of @assistant
|
|
|
|
|
*
|
|
|
|
|
* Gets the page type of @page.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: the page type of @page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
GtkAssistantPageType
|
|
|
|
|
gtk_assistant_get_page_type (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
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_complete:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
2006-07-17 03:43:29 +00:00
|
|
|
|
* @page: a page of @assistant
|
2006-01-28 06:03:50 +00:00
|
|
|
|
* @complete: the completeness status of the page
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
|
|
|
|
* Sets whether @page contents are complete.
|
|
|
|
|
*
|
|
|
|
|
* This will make @assistant update the buttons state
|
|
|
|
|
* to be able to continue the task.
|
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_set_page_complete (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page,
|
|
|
|
|
gboolean complete)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
GtkAssistantPage *page_info;
|
|
|
|
|
GList *child;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
g_return_if_fail (GTK_IS_WIDGET (page));
|
|
|
|
|
|
|
|
|
|
child = find_page (assistant, page);
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (child != NULL);
|
|
|
|
|
|
|
|
|
|
page_info = (GtkAssistantPage*) child->data;
|
|
|
|
|
|
2019-02-07 20:18:49 +00:00
|
|
|
|
g_object_set (page_info, "complete", complete, NULL);
|
2006-01-18 22:39:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_page_complete:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
* @page: a page of @assistant
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
2009-05-30 06:14:03 +00:00
|
|
|
|
* Gets whether @page is complete.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: %TRUE if @page is complete.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2006-01-18 22:39:14 +00:00
|
|
|
|
gboolean
|
|
|
|
|
gtk_assistant_get_page_complete (GtkAssistant *assistant,
|
2011-01-24 02:50:39 +00:00
|
|
|
|
GtkWidget *page)
|
2006-01-18 22:39:14 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
child = find_page (assistant, page);
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (child != NULL, FALSE);
|
|
|
|
|
|
|
|
|
|
page_info = (GtkAssistantPage*) child->data;
|
|
|
|
|
|
|
|
|
|
return page_info->complete;
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-31 16:57:18 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_update_buttons_state:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
2006-01-31 16:57:18 +00:00
|
|
|
|
* Forces @assistant to recompute the buttons state.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*
|
2020-09-12 16:01:04 +00:00
|
|
|
|
* GTK automatically takes care of this in most situations,
|
2006-01-31 16:57:18 +00:00
|
|
|
|
* e.g. when the user goes to a different page, or when the
|
|
|
|
|
* visibility or completeness of a page changes.
|
|
|
|
|
*
|
|
|
|
|
* One situation where it can be necessary to call this
|
|
|
|
|
* function is when changing a value on the current page
|
|
|
|
|
* affects the future page flow of the assistant.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2006-01-31 16:57:18 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_update_buttons_state (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
update_buttons_state (assistant);
|
2006-01-31 16:57:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-06-02 20:00:16 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_commit:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
*
|
|
|
|
|
* Erases the visited page history so the back button is not
|
|
|
|
|
* shown on the current page, and removes the cancel button
|
|
|
|
|
* from subsequent pages.
|
|
|
|
|
*
|
|
|
|
|
* Use this when the information provided up to the current
|
|
|
|
|
* page is hereafter deemed permanent and cannot be modified
|
2011-01-24 02:50:39 +00:00
|
|
|
|
* or undone. For example, showing a progress page to track
|
2010-06-02 20:00:16 +00:00
|
|
|
|
* a long-running, unreversible operation after the user has
|
|
|
|
|
* clicked apply on a confirmation page.
|
2011-01-24 02:50:39 +00:00
|
|
|
|
*/
|
2010-06-02 20:00:16 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_assistant_commit (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_ASSISTANT (assistant));
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
g_slist_free (assistant->visited_pages);
|
|
|
|
|
assistant->visited_pages = NULL;
|
2010-06-02 20:00:16 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->committed = TRUE;
|
2010-06-02 20:00:16 +00:00
|
|
|
|
|
2011-04-17 00:45:26 +00:00
|
|
|
|
update_buttons_state (assistant);
|
2010-06-02 20:00:16 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-11-29 15:40:29 +00:00
|
|
|
|
/* buildable implementation */
|
2006-06-12 03:53:19 +00:00
|
|
|
|
|
2009-04-18 05:23:20 +00:00
|
|
|
|
static GtkBuildableIface *parent_buildable_iface;
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_buildable_interface_init (GtkBuildableIface *iface)
|
|
|
|
|
{
|
|
|
|
|
parent_buildable_iface = g_type_interface_peek_parent (iface);
|
2020-05-02 19:17:20 +00:00
|
|
|
|
|
2009-04-18 05:23:20 +00:00
|
|
|
|
iface->custom_tag_start = gtk_assistant_buildable_custom_tag_start;
|
|
|
|
|
iface->custom_finished = gtk_assistant_buildable_custom_finished;
|
2019-02-07 20:18:49 +00:00
|
|
|
|
iface->add_child = gtk_assistant_buildable_add_child;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_buildable_add_child (GtkBuildable *buildable,
|
|
|
|
|
GtkBuilder *builder,
|
|
|
|
|
GObject *child,
|
|
|
|
|
const char *type)
|
|
|
|
|
{
|
|
|
|
|
if (GTK_IS_ASSISTANT_PAGE (child))
|
|
|
|
|
gtk_assistant_add_page (GTK_ASSISTANT (buildable), GTK_ASSISTANT_PAGE (child), -1);
|
|
|
|
|
else if (type && g_str_equal (type, "titlebar"))
|
|
|
|
|
{
|
|
|
|
|
GtkAssistant *assistant = GTK_ASSISTANT (buildable);
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->headerbar = GTK_WIDGET (child);
|
|
|
|
|
gtk_window_set_titlebar (GTK_WINDOW (buildable), assistant->headerbar);
|
2019-02-07 20:18:49 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2020-05-02 19:17:20 +00:00
|
|
|
|
parent_buildable_iface->add_child (buildable, builder, child, type);
|
2009-04-18 05:23:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_assistant_buildable_custom_tag_start (GtkBuildable *buildable,
|
|
|
|
|
GtkBuilder *builder,
|
|
|
|
|
GObject *child,
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *tagname,
|
2019-08-29 13:21:20 +00:00
|
|
|
|
GtkBuildableParser *parser,
|
2009-04-18 05:23:20 +00:00
|
|
|
|
gpointer *data)
|
|
|
|
|
{
|
|
|
|
|
return parent_buildable_iface->custom_tag_start (buildable, builder, child,
|
|
|
|
|
tagname, parser, data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_buildable_custom_finished (GtkBuildable *buildable,
|
|
|
|
|
GtkBuilder *builder,
|
|
|
|
|
GObject *child,
|
2020-07-24 18:40:36 +00:00
|
|
|
|
const char *tagname,
|
2009-04-18 05:23:20 +00:00
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
parent_buildable_iface->custom_finished (buildable, builder, child,
|
|
|
|
|
tagname, user_data);
|
|
|
|
|
}
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_page:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
* @child: a child of @assistant
|
|
|
|
|
*
|
|
|
|
|
* Returns the #GtkAssistantPage object for @child.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the #GtkAssistantPage for @child
|
|
|
|
|
*/
|
|
|
|
|
GtkAssistantPage *
|
|
|
|
|
gtk_assistant_get_page (GtkAssistant *assistant,
|
|
|
|
|
GtkWidget *child)
|
|
|
|
|
{
|
|
|
|
|
GList *page_info = find_page (assistant, child);
|
|
|
|
|
return (GtkAssistantPage *) (page_info ? page_info->data : NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_page_get_child:
|
|
|
|
|
* @page: a #GtkAssistantPage
|
|
|
|
|
*
|
|
|
|
|
* Returns the child to which @page belongs.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the child to which @page belongs
|
|
|
|
|
*/
|
|
|
|
|
GtkWidget *
|
|
|
|
|
gtk_assistant_page_get_child (GtkAssistantPage *page)
|
|
|
|
|
{
|
|
|
|
|
return page->page;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-13 23:27:25 +00:00
|
|
|
|
#define GTK_TYPE_ASSISTANT_PAGES (gtk_assistant_pages_get_type ())
|
|
|
|
|
G_DECLARE_FINAL_TYPE (GtkAssistantPages, gtk_assistant_pages, GTK, ASSISTANT_PAGES, GObject)
|
|
|
|
|
|
|
|
|
|
struct _GtkAssistantPages
|
|
|
|
|
{
|
|
|
|
|
GObject parent_instance;
|
|
|
|
|
GtkAssistant *assistant;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _GtkAssistantPagesClass
|
|
|
|
|
{
|
|
|
|
|
GObjectClass parent_class;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static GType
|
|
|
|
|
gtk_assistant_pages_get_item_type (GListModel *model)
|
|
|
|
|
{
|
|
|
|
|
return GTK_TYPE_ASSISTANT_PAGE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static guint
|
|
|
|
|
gtk_assistant_pages_get_n_items (GListModel *model)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistantPages *pages = GTK_ASSISTANT_PAGES (model);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
return g_list_length (pages->assistant->pages);
|
2019-02-13 23:27:25 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gpointer
|
|
|
|
|
gtk_assistant_pages_get_item (GListModel *model,
|
|
|
|
|
guint position)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistantPages *pages = GTK_ASSISTANT_PAGES (model);
|
|
|
|
|
GtkAssistantPage *page;
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
page = g_list_nth_data (pages->assistant->pages, position);
|
2019-02-13 23:27:25 +00:00
|
|
|
|
|
|
|
|
|
return g_object_ref (page);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_pages_list_model_init (GListModelInterface *iface)
|
|
|
|
|
{
|
|
|
|
|
iface->get_item_type = gtk_assistant_pages_get_item_type;
|
|
|
|
|
iface->get_n_items = gtk_assistant_pages_get_n_items;
|
|
|
|
|
iface->get_item = gtk_assistant_pages_get_item;
|
|
|
|
|
}
|
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkAssistantPages, gtk_assistant_pages, G_TYPE_OBJECT,
|
|
|
|
|
G_IMPLEMENT_INTERFACE (G_TYPE_LIST_MODEL, gtk_assistant_pages_list_model_init))
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_pages_init (GtkAssistantPages *pages)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_assistant_pages_class_init (GtkAssistantPagesClass *class)
|
|
|
|
|
{
|
|
|
|
|
}
|
2019-02-07 20:18:49 +00:00
|
|
|
|
|
2019-02-13 23:27:25 +00:00
|
|
|
|
static GtkAssistantPages *
|
|
|
|
|
gtk_assistant_pages_new (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
GtkAssistantPages *pages;
|
|
|
|
|
|
|
|
|
|
pages = g_object_new (GTK_TYPE_ASSISTANT_PAGES, NULL);
|
|
|
|
|
pages->assistant = assistant;
|
|
|
|
|
|
|
|
|
|
return pages;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-14 19:29:54 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_assistant_get_pages:
|
|
|
|
|
* @assistant: a #GtkAssistant
|
|
|
|
|
*
|
|
|
|
|
* Gets a list model of the assistant pages.
|
|
|
|
|
*
|
2020-04-27 13:46:23 +00:00
|
|
|
|
* Returns: (transfer full) (attributes element-type=GtkAssistantPage): A list model of the pages.
|
2019-02-14 19:29:54 +00:00
|
|
|
|
*/
|
2019-02-13 23:27:25 +00:00
|
|
|
|
GListModel *
|
|
|
|
|
gtk_assistant_get_pages (GtkAssistant *assistant)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), NULL);
|
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
if (assistant->model)
|
|
|
|
|
return g_object_ref (assistant->model);
|
2019-02-13 23:27:25 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
assistant->model = G_LIST_MODEL (gtk_assistant_pages_new (assistant));
|
2019-02-13 23:27:25 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
g_object_add_weak_pointer (G_OBJECT (assistant->model), (gpointer *)&assistant->model);
|
2019-02-13 23:27:25 +00:00
|
|
|
|
|
2020-05-05 01:36:00 +00:00
|
|
|
|
return assistant->model;
|
2019-02-13 23:27:25 +00:00
|
|
|
|
}
|