/*
* This program 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) version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see <http://www.gnu.org/licenses/>
*
*
* Authors:
* Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include "e-config.h"
#include <glib/gi18n.h>
#define E_CONFIG_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE \
((obj), E_TYPE_CONFIG, EConfigPrivate))
#define d(x)
struct _EConfigFactory {
gchar *id;
EConfigFactoryFunc func;
gpointer user_data;
};
struct _menu_node {
GSList *menu;
EConfigItemsFunc free;
EConfigItemsFunc abort;
EConfigItemsFunc commit;
gpointer data;
};
struct _widget_node {
EConfig *config;
struct _menu_node *context;
EConfigItem *item;
GtkWidget *widget; /* widget created by the factory, if any */
GtkWidget *frame; /* if created by us */
guint empty:1; /* set if empty (i.e. hidden) */
};
struct _check_node {
gchar *pageid;
EConfigCheckFunc check;
gpointer data;
};
struct _finish_page_node {
gchar *pageid;
gboolean is_finish;
gint orig_type;
};
struct _EConfigPrivate {
GList *menus;
GList *widgets;
GList *checks;
GList *finish_pages;
};
static gpointer parent_class;
static void
config_finalize (GObject *object)
{
EConfig *emp = (EConfig *)object;
EConfigPrivate *p = emp->priv;
GList *link;
d(printf("finalising EConfig %p\n", o));
g_free(emp->id);
link = p->menus;
while (link != NULL) {
struct _menu_node *node = link->data;
if (node->free)
node->free (emp, node->menu, node->data);
g_free (node);
link = g_list_delete_link (link, link);
}
link = p->widgets;
while (link != NULL) {
struct _widget_node *node = link->data;
/* disconnect the gtk_widget_destroyed function from the widget */
if (node->widget)
g_signal_handlers_disconnect_matched (
node->widget, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, &node->widget);
g_free (node);
link = g_list_delete_link (link, link);
}
link = p->checks;
while (link != NULL) {
struct _check_node *node = link->data;
g_free (node->pageid);
g_free (node);
link = g_list_delete_link (link, link);
}
link = p->finish_pages;
while (link != NULL) {
struct _finish_page_node *node = link->data;
g_free (node->pageid);
g_free (node);
link = g_list_delete_link (link, link);
}
/* Chain up to parent's finalize() method. */
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
config_target_free (EConfig *config,
EConfigTarget *target)
{
g_free (target);
g_object_unref (config);
}
static void
config_set_target (EConfig *config,
EConfigTarget *target)
{
if (config->target != NULL)
e_config_target_free (config, target);
config->target = target;
}
static void
config_class_init (EConfigClass *class)
{
GObjectClass *object_class;
parent_class = g_type_class_peek_parent (class);
g_type_class_add_private (class, sizeof (EConfigPrivate));
object_class = G_OBJECT_CLASS (class);
object_class->finalize = config_finalize;
class->set_target = config_set_target;
class->target_free = config_target_free;
}
static void
config_init (EConfig *config)
{
config->priv = E_CONFIG_GET_PRIVATE (config);
}
/**
* e_config_get_type:
*
* Standard GObject method. Used to subclass for the concrete
* implementations.
*
* Return value: EConfig type.
**/
GType
e_config_get_type (void)
{
static GType type = 0;
if (G_UNLIKELY (type == 0)) {
static const GTypeInfo type_info = {
sizeof (EConfigClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) config_class_init,
(GClassFinalizeFunc) NULL,
NULL, /* class_data */
sizeof (EConfig),
0, /* n_preallocs */
(GInstanceInitFunc) config_init,
NULL /* value_table */
};
type = g_type_register_static (
G_TYPE_OBJECT, "EConfig", &type_info, 0);
}
return type;
}
/**
* e_config_construct:
* @ep: The instance to initialise.
* @type: The type of configuration manager, @E_CONFIG_BOOK or
* @E_CONFIG_ASSISTANT.
* @id: The name of the configuration window this manager drives.
*
* Used by implementing classes to initialise base parameters.
*
* Return value: @ep is returned.
**/
EConfig *
e_config_construct (EConfig *ep, gint type, const gchar *id)
{
g_return_val_if_fail (type == E_CONFIG_BOOK || type == E_CONFIG_ASSISTANT, NULL);
ep->type = type;
ep->id = g_strdup (id);
return ep;
}
/**
* e_config_add_items:
* @ec: An initialised implementing instance of EConfig.
* @items: A list of EConfigItem's to add to the configuration manager
* @ec.
* @commitfunc: If supplied, called to commit the configuration items
* to persistent storage.
* @abortfunc: If supplied, called to abort/undo the storage of these
* items permanently.
* @freefunc: If supplied, called to free the item list (and/or items)
* once they are no longer needed.
* @data: Data for the callback methods.
*
* Add new EConfigItems to the configuration window. Nothing will be
* done with them until the widget is built.
*
* TODO: perhaps commit and abort should just be signals.
**/
void
e_config_add_items(EConfig *ec, GSList *items, EConfigItemsFunc commitfunc, EConfigItemsFunc abortfunc, EConfigItemsFunc freefunc, gpointer data)
{
struct _menu_node *node;
node = g_malloc(sizeof(*node));
node->menu = items;
node->commit = commitfunc;
node->abort = abortfunc;
node->free = freefunc;
node->data = data;
ec->priv->menus = g_list_append (ec->priv->menus, node);
}
/**
* e_config_add_page_check:
* @ec: Initialised implemeting instance of EConfig.
* @pageid: pageid to check.
* @check: checking callback.
* @data: user-data for the callback.
*
* Add a page-checking function callback. It will be called to validate the
* data in the given page or pages. If @pageid is NULL then it will be called
* to validate every page, or the whole configuration window.
*
* In the latter case, the pageid in the callback will be either the
* specific page being checked, or NULL when the whole config window
* is being checked.
*
* The page check function is used to validate input before allowing
* the assistant to continue or the notebook to close.
**/
void
e_config_add_page_check(EConfig *ec, const gchar *pageid, EConfigCheckFunc check, gpointer data)
{
struct _check_node *cn;
cn = g_malloc0(sizeof(*cn));
cn->pageid = g_strdup(pageid);
cn->check = check;
cn->data = data;
ec->priv->checks = g_list_append (ec->priv->checks, cn);
}
static struct _finish_page_node *
find_page_finish (EConfig *config, const gchar *pageid)
{
GList *link;
link = config->priv->finish_pages;
while (link != NULL) {
struct _finish_page_node *node = link->data;
if (g_str_equal (node->pageid, pageid))
return node;
link = g_list_next (link);
}
return NULL;
}
/**
* e_config_set_page_is_finish:
* @ec: Initialised implementing instance of EConfig.
* @pageid: pageid to change the value on.
* @can_finish: whether the pageid can finish immediately or not.
*
* With is_finish set on the pageid the page is treated as the last page in an assistant.
**/
void
e_config_set_page_is_finish (EConfig *ec, const gchar *pageid, gboolean is_finish)
{
struct _finish_page_node *fp;
fp = find_page_finish (ec, pageid);
if (is_finish) {
if (!fp) {
fp = g_malloc0 (sizeof (*fp));
fp->pageid = g_strdup (pageid);
ec->priv->finish_pages = g_list_append (
ec->priv->finish_pages, fp);
}
fp->is_finish = TRUE;
} else {
if (fp)
fp->is_finish = FALSE;
}
}
static void
ec_add_static_items (EConfig *config)
{
EConfigClass *class;
GList *link;
class = E_CONFIG_GET_CLASS (config);
for (link = class->factories; link != NULL; link = link->next) {
EConfigFactory *factory = link->data;
if (factory->id == NULL || strcmp (factory->id, config->id) == 0)
factory->func (config, factory->user_data);
}
}
static gint
ep_cmp(gconstpointer ap, gconstpointer bp)
{
struct _widget_node *a = *((gpointer *)ap);
struct _widget_node *b = *((gpointer *)bp);
return strcmp(a->item->path, b->item->path);
}
static struct _widget_node *
ec_assistant_find_page (EConfig *ec, GtkWidget *page, gint *page_index)
{
struct _widget_node *wn = NULL;
GList *link;
g_return_val_if_fail (ec != NULL, NULL);
g_return_val_if_fail (GTK_IS_ASSISTANT (ec->widget), NULL);
g_return_val_if_fail (page != NULL, NULL);
link = ec->priv->widgets;
while (link != NULL) {
wn = link->data;
if (wn->frame == page
&& (wn->item->type == E_CONFIG_PAGE
|| wn->item->type == E_CONFIG_PAGE_START
|| wn->item->type == E_CONFIG_PAGE_FINISH))
break;
link = g_list_next (link);
}
g_return_val_if_fail (wn != NULL, NULL);
if (wn->frame != page)
wn = NULL;
if (page_index) {
if (wn) {
GtkAssistant *assistant = GTK_ASSISTANT (ec->widget);
gint index, count = gtk_assistant_get_n_pages (assistant);
for (index = 0; index < count; index++) {
if (gtk_assistant_get_nth_page (assistant, index) == page)
break;
}
if (index == count)
index = -1;
*page_index = index;
} else {
*page_index = -1;
}
}
return wn;
}
static void
ec_assistant_check_current (EConfig *ec)
{
struct _widget_node *wn;
struct _finish_page_node *fp;
GtkAssistant *assistant;
GtkWidget *page;
gint page_no;
g_return_if_fail (GTK_IS_ASSISTANT (ec->widget));
assistant = GTK_ASSISTANT (ec->widget);
page_no = gtk_assistant_get_current_page (assistant);
/* no page selected yet */
if (page_no == -1)
return;
page = gtk_assistant_get_nth_page (assistant, page_no);
g_return_if_fail (page != NULL);
wn = ec_assistant_find_page (ec, page, NULL);
g_return_if_fail (wn != NULL);
/* this should come first, as the check function can change the finish state of the page */
gtk_assistant_set_page_complete (assistant, page, e_config_page_check (ec, wn->item->path));
fp = find_page_finish (ec, wn->item->path);
if (fp) {
GtkAssistantPageType pt = gtk_assistant_get_page_type (assistant, page);
if (fp->is_finish && pt != GTK_ASSISTANT_PAGE_CONFIRM) {
if (fp->orig_type == GTK_ASSISTANT_PAGE_CONTENT)
fp->orig_type = pt;
gtk_assistant_set_page_type (assistant, page, GTK_ASSISTANT_PAGE_CONFIRM);
} else if (!fp->is_finish && pt != fp->orig_type) {
gtk_assistant_set_page_type (assistant, page, fp->orig_type);
}
}
gtk_assistant_update_buttons_state (assistant);
}
static gint
ec_assistant_forward (gint current_page, gpointer user_data)
{
EConfig *ec = user_data;
struct _widget_node *wn;
gint next_page = current_page + 1;
GList *link = NULL;
d(printf("next page from '%d'\n", current_page));
wn = ec_assistant_find_page (ec, gtk_assistant_get_nth_page (GTK_ASSISTANT (ec->widget), current_page), NULL);
/* XXX This is a little kludgy. We have to find
* the GList node for the page we just found. */
if (wn != NULL)
link = g_list_find (ec->priv->widgets, wn);
if (link && link->next) {
for (link = link->next; link->next; link = link->next) {
wn = link->data;
if (!wn->empty && wn->frame != NULL
&& (wn->item->type == E_CONFIG_PAGE
|| wn->item->type == E_CONFIG_PAGE_START
|| wn->item->type == E_CONFIG_PAGE_FINISH))
break;
}
}
if (link && link->next) {
wn = link->data;
ec_assistant_find_page (ec, wn->frame, &next_page);
d(printf(" is %s (%d)\n",wn->item->path, next_page));
}
return next_page;
}
static void
ec_rebuild (EConfig *emp)
{
EConfigPrivate *p = emp->priv;
struct _widget_node *sectionnode = NULL, *pagenode = NULL;
GtkWidget *book = NULL, *page = NULL, *section = NULL, *root = NULL, *assistant = NULL;
gint pageno = 0, sectionno = 0, itemno = 0;
struct _widget_node *last_active_page = NULL;
gboolean is_assistant;
GList *link;
d(printf("target changed, rebuilding:\n"));
/* TODO: This code is pretty complex, and will probably just
* become more complex with time. It could possibly be split
* into the two base types, but there would be a lot of code
* duplication */
/* because rebuild destroys pages, and destroying active page causes crashes */
is_assistant = emp->widget && GTK_IS_ASSISTANT (emp->widget);
if (is_assistant) {
gint page_index = gtk_assistant_get_current_page (GTK_ASSISTANT (emp->widget));
if (page_index != -1)
last_active_page = ec_assistant_find_page (emp, gtk_assistant_get_nth_page (GTK_ASSISTANT (emp->widget), page_index), NULL);
gtk_assistant_set_current_page (GTK_ASSISTANT (emp->widget), 0);
}
for (link = p->widgets; link != NULL; link = g_list_next (link)) {
struct _widget_node *wn = link->data;
struct _EConfigItem *item = wn->item;
const gchar *translated_label = NULL;
GtkWidget *w;
d(printf(" '%s'\n", item->path));
if (item->label != NULL)
translated_label = gettext (item->label);
/* If the last section doesn't contain anything, hide it */
if (sectionnode != NULL
&& sectionnode->frame != NULL
&& (item->type == E_CONFIG_PAGE_START
|| item->type == E_CONFIG_PAGE_FINISH
|| item->type == E_CONFIG_PAGE
|| item->type == E_CONFIG_SECTION
|| item->type == E_CONFIG_SECTION_TABLE)) {
if ( (sectionnode->empty = itemno == 0) ) {
gtk_widget_hide(sectionnode->frame);
sectionno--;
} else
gtk_widget_show(sectionnode->frame);
d(printf("%s section '%s' [sections=%d]\n", sectionnode->empty?"hiding":"showing", sectionnode->item->path, sectionno));
}
/* If the last page doesn't contain anything, hide it */
if (pagenode != NULL
&& pagenode->frame != NULL
&& (item->type == E_CONFIG_PAGE_START
|| item->type == E_CONFIG_PAGE_FINISH
|| item->type == E_CONFIG_PAGE)) {
if ( (pagenode->empty = sectionno == 0) ) {
gtk_widget_hide(pagenode->frame);
pageno--;
} else
gtk_widget_show(pagenode->frame);
d(printf("%s page '%s' [section=%d]\n", pagenode->empty?"hiding":"showing", pagenode->item->path, pageno));
}
/* Now process the item */
switch (item->type) {
case E_CONFIG_BOOK:
case E_CONFIG_ASSISTANT:
/* Only one of BOOK or ASSISTANT may be define, it
is used by the defining code to mark the
type of the config window. It is
cross-checked with the code's defined
type. */
if (root != NULL) {
g_warning("EConfig book/assistant redefined at: %s", item->path);
break;
}
if (wn->widget == NULL) {
if (item->type != emp->type) {
g_warning("EConfig book/assistant type mismatch");
break;
}
if (item->factory) {
root = item->factory(emp, item, NULL, wn->widget, wn->context->data);
} else if (item->type == E_CONFIG_BOOK) {
root = gtk_notebook_new();
gtk_widget_show (root);
} else if (item->type == E_CONFIG_ASSISTANT) {
root = gtk_assistant_new ();
} else
abort();
if (item->type == E_CONFIG_ASSISTANT) {
g_signal_connect_swapped (
root, "apply",
G_CALLBACK (e_config_commit), emp);
g_signal_connect_swapped (
root, "cancel",
G_CALLBACK (e_config_abort), emp);
g_signal_connect (
root, "cancel",
G_CALLBACK (gtk_widget_destroy), emp);
g_signal_connect (
root, "close",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect_swapped (
root, "prepare",
G_CALLBACK (ec_assistant_check_current), emp);
gtk_assistant_set_forward_page_func (
GTK_ASSISTANT (root),
ec_assistant_forward, emp, NULL);
}
emp->widget = root;
wn->widget = root;
} else {
root = wn->widget;
}
if (item->type == E_CONFIG_BOOK)
book = root;
else
assistant = root;
page = NULL;
pagenode = NULL;
section = NULL;
sectionnode = NULL;
pageno = 0;
sectionno = 0;
break;
case E_CONFIG_PAGE_START:
case E_CONFIG_PAGE_FINISH:
if (root == NULL) {
g_warning("EConfig page defined before container widget: %s", item->path);
break;
}
if (emp->type != E_CONFIG_ASSISTANT) {
g_warning("EConfig assistant start/finish pages can't be used on E_CONFIG_BOOKs");
break;
}
if (item->type == E_CONFIG_PAGE_FINISH || wn->widget == NULL) {
/* always rebuild finish page, to have it as the last page */
if (item->factory) {
page = item->factory(emp, item, root, wn->frame, wn->context->data);
} else {
page = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (page), 12);
if (pagenode) {
/* put after */
gint index = -1;
ec_assistant_find_page (emp, pagenode->frame, &index);
gtk_assistant_insert_page (GTK_ASSISTANT (assistant), page, index + 1);
} else {
gtk_assistant_prepend_page (GTK_ASSISTANT (assistant), page);
}
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), page, item->type == E_CONFIG_PAGE_START ? GTK_ASSISTANT_PAGE_INTRO : GTK_ASSISTANT_PAGE_CONFIRM);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, translated_label);
gtk_widget_show_all (page);
}
if (wn->widget != NULL && wn->widget != page) {
gtk_widget_destroy (wn->widget);
}
wn->frame = page;
wn->widget = page;
if (page) {
const gchar *empty_xpm_img[] = {
"75 1 2 1",
" c None",
". c #FFFFFF",
" "};
/* left side place with a blue background on a start and finish page */
GdkPixbuf *spacer = gdk_pixbuf_new_from_xpm_data (empty_xpm_img);
gtk_assistant_set_page_side_image (GTK_ASSISTANT (assistant), page, spacer);
g_object_unref (spacer);
}
}
pageno++;
page = NULL;
pagenode = wn; /* need this for previous page linking */
section = NULL;
sectionnode = NULL;
sectionno = 1; /* never want to hide these */
break;
case E_CONFIG_PAGE: {
/* CONFIG_PAGEs depend on the config type.
E_CONFIG_BOOK:
The page is a VBox, stored in the notebook.
E_CONFIG_ASSISTANT
The page is a VBox, stored in the GtkAssistant,
any sections automatically added inside it. */
sectionno = 0;
if (root == NULL) {
g_warning("EConfig page defined before container widget: %s", item->path);
break;
}
if (item->factory) {
page = item->factory(emp, item, root, wn->frame, wn->context->data);
if (emp->type == E_CONFIG_ASSISTANT) {
wn->frame = page;
} else {
wn->frame = page;
if (page)
gtk_notebook_reorder_child((GtkNotebook *)book, page, pageno);
}
if (page)
sectionno = 1;
} else if (wn->widget == NULL) {
if (emp->type == E_CONFIG_ASSISTANT) {
page = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (page), 12);
if (pagenode) {
/* put after */
gint index = -1;
ec_assistant_find_page (emp, pagenode->frame, &index);
gtk_assistant_insert_page (GTK_ASSISTANT (assistant), page, index + 1);
} else {
gtk_assistant_prepend_page (GTK_ASSISTANT (assistant), page);
}
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), page, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), page, translated_label);
gtk_widget_show_all (page);
wn->frame = page;
} else {
w = gtk_label_new_with_mnemonic (translated_label);
gtk_widget_show(w);
page = gtk_vbox_new(FALSE, 12);
gtk_container_set_border_width((GtkContainer *)page, 12);
gtk_widget_show(page);
gtk_notebook_insert_page((GtkNotebook *)book, page, w, pageno);
wn->frame = page;
}
} else
page = wn->widget;
d(printf("page %d:%s widget %p\n", pageno, item->path, page));
if (wn->widget && wn->widget != page) {
d(printf("destroy old widget for page '%s' (%p)\n", item->path, wn->widget));
gtk_widget_destroy (wn->widget);
}
pageno++;
pagenode = wn;
section = NULL;
sectionnode = NULL;
wn->widget = page;
if (page)
g_signal_connect(page, "destroy", G_CALLBACK(gtk_widget_destroyed), &wn->widget);
break; }
case E_CONFIG_SECTION:
case E_CONFIG_SECTION_TABLE:
/* The section factory is always called with
the parent vbox object. Even for assistant pages. */
if (page == NULL) {
/*g_warning("EConfig section '%s' has no parent page", item->path);*/
section = NULL;
wn->widget = NULL;
wn->frame = NULL;
goto nopage;
}
itemno = 0;
if (item->factory) {
section = item->factory(emp, item, page, wn->widget, wn->context->data);
wn->frame = section;
if (section)
itemno = 1;
if (section
&& ((item->type == E_CONFIG_SECTION && !GTK_IS_BOX(section))
|| (item->type == E_CONFIG_SECTION_TABLE && !GTK_IS_TABLE(section))))
g_warning("EConfig section type is wrong");
} else {
GtkWidget *frame;
GtkWidget *label = NULL;
if (wn->frame) {
d(printf("Item %s, clearing generated section widget\n", wn->item->path));
gtk_widget_destroy(wn->frame);
wn->widget = NULL;
wn->frame = NULL;
}
if (translated_label != NULL) {
gchar *txt = g_markup_printf_escaped("<span weight=\"bold\">%s</span>", translated_label);
label = g_object_new(gtk_label_get_type(),
"label", txt,
"use_markup", TRUE,
"xalign", 0.0, NULL);
g_free(txt);
}
if (item->type == E_CONFIG_SECTION)
section = gtk_vbox_new(FALSE, 6);
else {
section = gtk_table_new(1, 1, FALSE);
gtk_table_set_col_spacings((GtkTable *)section, 6);
gtk_table_set_row_spacings((GtkTable *)section, 6);
}
frame = g_object_new(gtk_frame_get_type(),
"shadow_type", GTK_SHADOW_NONE,
"label_widget", label,
"child", g_object_new(gtk_alignment_get_type(),
"left_padding", 12,
"top_padding", 6,
"child", section, NULL),
NULL);
gtk_widget_show_all(frame);
gtk_box_pack_start((GtkBox *)page, frame, FALSE, FALSE, 0);
wn->frame = frame;
}
nopage:
if (wn->widget && wn->widget != section) {
d(printf("destroy old widget for section '%s'\n", item->path));
gtk_widget_destroy(wn->widget);
}
d(printf("Item %s, setting section widget\n", wn->item->path));
sectionno++;
wn->widget = section;
if (section)
g_signal_connect(section, "destroy", G_CALLBACK(gtk_widget_destroyed), &wn->widget);
sectionnode = wn;
break;
case E_CONFIG_ITEM:
case E_CONFIG_ITEM_TABLE:
/* generated sections never retain their widgets on a rebuild */
if (sectionnode->item->factory == NULL)
wn->widget = NULL;
/* ITEMs are called with the section parent.
The type depends on the section type,
either a GtkTable, or a GtkVBox */
w = NULL;
if (section == NULL) {
wn->widget = NULL;
wn->frame = NULL;
g_warning("EConfig item has no parent section: %s", item->path);
} else if ((item->type == E_CONFIG_ITEM && !GTK_IS_BOX(section))
|| (item->type == E_CONFIG_ITEM_TABLE && !GTK_IS_TABLE(section)))
g_warning("EConfig item parent type is incorrect: %s", item->path);
else if (item->factory)
w = item->factory(emp, item, section, wn->widget, wn->context->data);
d(printf("item %d:%s widget %p\n", itemno, item->path, w));
if (wn->widget && wn->widget != w) {
d(printf("destroy old widget for item '%s'\n", item->path));
gtk_widget_destroy(wn->widget);
}
wn->widget = w;
if (w) {
g_signal_connect(w, "destroy", G_CALLBACK(gtk_widget_destroyed), &wn->widget);
itemno++;
}
break;
}
}
/* If the last section doesn't contain anything, hide it */
if (sectionnode != NULL && sectionnode->frame != NULL) {
if ( (sectionnode->empty = itemno == 0) ) {
gtk_widget_hide(sectionnode->frame);
sectionno--;
} else
gtk_widget_show(sectionnode->frame);
d(printf("%s section '%s' [sections=%d]\n", sectionnode->empty?"hiding":"showing", sectionnode->item->path, sectionno));
}
/* If the last page doesn't contain anything, hide it */
if (pagenode != NULL && pagenode->frame != NULL) {
if ( (pagenode->empty = sectionno == 0) ) {
gtk_widget_hide(pagenode->frame);
pageno--;
} else
gtk_widget_show(pagenode->frame);
d(printf("%s page '%s' [section=%d]\n", pagenode->empty?"hiding":"showing", pagenode->item->path, pageno));
}
if (book) {
/* make this depend on flags?? */
if (gtk_notebook_get_n_pages((GtkNotebook *)book) == 1) {
gtk_notebook_set_show_tabs((GtkNotebook *)book, FALSE);
gtk_notebook_set_show_border((GtkNotebook *)book, FALSE);
}
}
if (is_assistant && last_active_page) {
gint page_index = -1;
ec_assistant_find_page (emp, last_active_page->frame, &page_index);
gtk_assistant_set_current_page (GTK_ASSISTANT (emp->widget), page_index);
}
}
/**
* e_config_set_target:
* @emp: An initialised EConfig.
* @target: A target allocated from @emp.
*
* Sets the target object for the config window. Generally the target
* is set only once, and will supply its own "changed" signal which
* can be used to drive the modal. This is a virtual method so that
* the implementing class can connect to the changed signal and
* initiate a e_config_target_changed() call where appropriate.
**/
void
e_config_set_target(EConfig *emp, EConfigTarget *target)
{
if (emp->target != target)
((EConfigClass *)G_OBJECT_GET_CLASS(emp))->set_target(emp, target);
}
static void
ec_widget_destroy(GtkWidget *w, EConfig *ec)
{
if (ec->target) {
e_config_target_free(ec, ec->target);
ec->target = NULL;
}
g_object_unref(ec);
}
/**
* e_config_create_widget:
* @emp: An initialised EConfig object.
*
* Create the widget described by @emp. Only the core widget
* appropriate for the given type is created, i.e. a GtkNotebook for
* the E_CONFIG_BOOK type and a GtkAssistant for the E_CONFIG_ASSISTANT
* type.
*
* This object will be self-driving, but will not close itself once
* complete.
*
* Unless reffed otherwise, the management object @emp will be
* finalized when the widget is.
*
* Return value: The widget, also available in @emp.widget
**/
GtkWidget *
e_config_create_widget(EConfig *emp)
{
EConfigPrivate *p = emp->priv;
GPtrArray *items = g_ptr_array_new();
GList *link;
GSList *l;
/*char *domain = NULL;*/
gint i;
g_return_val_if_fail (emp->target != NULL, NULL);
ec_add_static_items(emp);
/* FIXME: need to override old ones with new names */
link = p->menus;
while (link != NULL) {
struct _menu_node *mnode = link->data;
for (l=mnode->menu; l; l = l->next) {
struct _EConfigItem *item = l->data;
struct _widget_node *wn = g_malloc0(sizeof(*wn));
wn->item = item;
wn->context = mnode;
wn->config = emp;
g_ptr_array_add(items, wn);
}
link = g_list_next (link);
}
qsort(items->pdata, items->len, sizeof(items->pdata[0]), ep_cmp);
for (i=0;i<items->len;i++)
p->widgets = g_list_append (p->widgets, items->pdata[i]);
g_ptr_array_free(items, TRUE);
ec_rebuild(emp);
/* auto-unref it */
g_signal_connect(emp->widget, "destroy", G_CALLBACK(ec_widget_destroy), emp);
/* FIXME: for some reason ec_rebuild puts the widget on page 1, this is just to override that */
if (emp->type == E_CONFIG_BOOK)
gtk_notebook_set_current_page((GtkNotebook *)emp->widget, 0);
else {
gtk_window_set_position (GTK_WINDOW (emp->widget), GTK_WIN_POS_CENTER);
gtk_widget_show (emp->widget);
}
return emp->widget;
}
static void
ec_dialog_response(GtkWidget *d, gint id, EConfig *ec)
{
if (id == GTK_RESPONSE_OK)
e_config_commit(ec);
else
e_config_abort(ec);
gtk_widget_destroy(d);
}
/**
* e_config_create_window:
* @emp: Initialised and configured EMConfig derived instance.
* @parent: Parent window or NULL.
* @title: Title of window or dialog.
*
* Create a managed GtkWindow object from @emp. This window will be
* fully driven by the EConfig @emp. If @emp.type is
* @E_CONFIG_ASSISTANT, then this will be a toplevel GtkWindow containing
* a GtkAssistant. If it is @E_CONFIG_BOOK then it will be a GtkDialog
* containing a Notebook.
*
* Unless reffed otherwise, the management object @emp will be
* finalized when the widget is.
*
* Return value: The window widget. This is also stored in @emp.window.
**/
GtkWidget *
e_config_create_window(EConfig *emp, GtkWindow *parent, const gchar *title)
{
GtkWidget *w;
e_config_create_widget(emp);
if (emp->type == E_CONFIG_BOOK) {
w = gtk_dialog_new_with_buttons(title, parent,
GTK_DIALOG_DESTROY_WITH_PARENT |
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_signal_connect(w, "response", G_CALLBACK(ec_dialog_response), emp);
gtk_widget_ensure_style (w);
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (w))), 0);
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (GTK_DIALOG (w))), 12);
gtk_box_pack_start((GtkBox *)gtk_dialog_get_content_area (((GtkDialog *)w)), emp->widget, TRUE, TRUE, 0);
} else {
/* response is handled directly by the assistant stuff */
w = emp->widget;
gtk_window_set_title ((GtkWindow *)w, title);
}
emp->window = w;
gtk_widget_show(w);
return w;
}
static void
ec_call_page_check (EConfig *emp)
{
if (emp->type == E_CONFIG_ASSISTANT) {
ec_assistant_check_current (emp);
} else {
if (emp->window) {
if (e_config_page_check(emp, NULL)) {
gtk_dialog_set_response_sensitive((GtkDialog *)emp->window, GTK_RESPONSE_OK, TRUE);
} else {
gtk_dialog_set_response_sensitive((GtkDialog *)emp->window, GTK_RESPONSE_OK, FALSE);
}
}
}
}
static gboolean
ec_idle_handler_for_rebuild (gpointer data)
{
EConfig *emp = (EConfig*) data;
ec_rebuild (emp);
ec_call_page_check (emp);
return FALSE;
}
/**
* e_config_target_changed:
* @emp:
* @how:
*
* Indicate that the target has changed. This may be called by the
* self-aware target itself, or by the driving code. If @how is
* %E_CONFIG_TARGET_CHANGED_REBUILD, then the entire configuration
* widget may be recreated based on the changed target.
*
* This is used to sensitise Assistant next/back buttons and the Apply
* button for the Notebook mode.
**/
void e_config_target_changed(EConfig *emp, e_config_target_change_t how)
{
if (how == E_CONFIG_TARGET_CHANGED_REBUILD) {
g_idle_add (ec_idle_handler_for_rebuild, emp);
} else {
ec_call_page_check (emp);
}
/* virtual method/signal? */
}
/**
* e_config_abort:
* @ec:
*
* Signify that the stateful configuration changes must be discarded
* to all listeners. This is used by self-driven assistant or notebook, or
* may be used by code using the widget directly.
**/
void
e_config_abort (EConfig *config)
{
GList *link;
g_return_if_fail (E_IS_CONFIG (config));
/* TODO: should these just be signals? */
link = config->priv->menus;
while (link != NULL) {
struct _menu_node *node = link->data;
if (node->abort != NULL)
node->abort (config, node->menu, node->data);
link = g_list_next (link);
}
}
/**
* e_config_commit:
* @ec:
*
* Signify that the stateful configuration changes should be saved.
* This is used by the self-driven assistant or notebook, or may be used
* by code driving the widget directly.
**/
void
e_config_commit (EConfig *config)
{
GList *link;
g_return_if_fail (E_IS_CONFIG (config));
/* TODO: should these just be signals? */
link = config->priv->menus;
while (link != NULL) {
struct _menu_node *node = link->data;
if (node->commit != NULL)
node->commit (config, node->menu, node->data);
link = g_list_next (link);
}
}
/**
* e_config_page_check:
* @config: an #EConfig
* @pageid: the path of the page item
*
* Check that a given page is complete. If @pageid is NULL, then check
* the whole config. No check is made that the page actually exists.
*
* Return value: FALSE if the data is inconsistent/incomplete.
**/
gboolean
e_config_page_check (EConfig *config, const gchar *pageid)
{
GList *link;
link = config->priv->checks;
while (link != NULL) {
struct _check_node *node = link->data;
if ((pageid == NULL
|| node->pageid == NULL
|| strcmp (node->pageid, pageid) == 0)
&& !node->check (config, pageid, node->data)) {
return FALSE;
}
link = g_list_next (link);
}
return TRUE;
}
/**
* e_config_page_get:
* @ec:
* @pageid: The path of the page item.
*
* Retrieve the page widget corresponding to @pageid.
*
* Return value: The page widget. It will be the root GtkNotebook
* container or the GtkVBox object inside the assistant.
**/
GtkWidget *
e_config_page_get(EConfig *ec, const gchar *pageid)
{
GList *link;
link = ec->priv->widgets;
while (link != NULL) {
struct _widget_node *wn = link->data;
if (!wn->empty
&& (wn->item->type == E_CONFIG_PAGE
|| wn->item->type == E_CONFIG_PAGE_START
|| wn->item->type == E_CONFIG_PAGE_FINISH)
&& !strcmp(wn->item->path, pageid))
return wn->frame;
link = g_list_next (link);
}
return NULL;
}
/**
* e_config_page_next:
* @ec:
* @pageid: The path of the page item.
*
* Find the path of the next visible page after @pageid. If @pageid
* is NULL then find the first visible page.
*
* Return value: The path of the next page, or @NULL if @pageid was the
* last configured and visible page.
**/
const gchar *
e_config_page_next(EConfig *ec, const gchar *pageid)
{
GList *link;
gint found;
link = g_list_first (ec->priv->widgets);
found = pageid == NULL ? 1:0;
while (link != NULL) {
struct _widget_node *wn = link->data;
if (!wn->empty
&& (wn->item->type == E_CONFIG_PAGE
|| wn->item->type == E_CONFIG_PAGE_START
|| wn->item->type == E_CONFIG_PAGE_FINISH)) {
if (found)
return wn->item->path;
else if (strcmp(wn->item->path, pageid) == 0)
found = 1;
}
link = g_list_next (link);
}
return NULL;
}
/**
* e_config_page_next:
* @ec:
* @pageid: The path of the page item.
*
* Find the path of the previous visible page before @pageid. If @pageid
* is NULL then find the last visible page.
*
* Return value: The path of the previous page, or @NULL if @pageid was the
* first configured and visible page.
**/
const gchar *
e_config_page_prev(EConfig *ec, const gchar *pageid)
{
GList *link;
gint found;
link = g_list_last (ec->priv->widgets);
found = pageid == NULL ? 1:0;
while (link != NULL) {
struct _widget_node *wn = link->data;
if (!wn->empty
&& (wn->item->type == E_CONFIG_PAGE
|| wn->item->type == E_CONFIG_PAGE_START
|| wn->item->type == E_CONFIG_PAGE_FINISH)) {
if (found)
return wn->item->path;
else if (strcmp(wn->item->path, pageid) == 0)
found = 1;
}
link = g_list_previous (link);
}
return NULL;
}
/* ********************************************************************** */
/**
* e_config_class_add_factory:
* @class: Implementing class pointer.
* @id: The name of the configuration window you're interested in.
* This may be NULL to be called for all windows.
* @func: An EConfigFactoryFunc to call when the window @id is being
* created.
* @data: Callback data.
*
* Add a config factory which will be called to add_items() any
* extra items's if wants to, to the current Config window.
*
* TODO: Make the id a pattern?
*
* Return value: A handle to the factory.
**/
EConfigFactory *
e_config_class_add_factory (EConfigClass *class,
const gchar *id,
EConfigFactoryFunc func,
gpointer user_data)
{
EConfigFactory *factory;
g_return_val_if_fail (E_IS_CONFIG_CLASS (class), NULL);
g_return_val_if_fail (func != NULL, NULL);
factory = g_slice_new0 (EConfigFactory);
factory->id = g_strdup (id);
factory->func = func;
factory->user_data = user_data;
class->factories = g_list_append (class->factories, factory);
return factory;
}
/**
* e_config_class_remove_factory:
* @factory: an #EConfigFactory
*
* Removes a config factory.
**/
void
e_config_class_remove_factory (EConfigClass *class,
EConfigFactory *factory)
{
g_return_if_fail (E_IS_CONFIG_CLASS (class));
g_return_if_fail (factory != NULL);
class->factories = g_list_remove (class->factories, factory);
g_free (factory->id);
g_slice_free (EConfigFactory, factory);
}
/**
* e_config_target_new:
* @ep: Parent EConfig object.
* @type: type, up to implementor
* @size: Size of object to allocate.
*
* Allocate a new config target suitable for this class. Implementing
* classes will define the actual content of the target.
**/
gpointer e_config_target_new(EConfig *ep, gint type, gsize size)
{
EConfigTarget *t;
if (size < sizeof(EConfigTarget)) {
g_warning ("Size is less than size of EConfigTarget\n");
size = sizeof (EConfigTarget);
}
t = g_malloc0(size);
t->config = ep;
g_object_ref(ep);
t->type = type;
return t;
}
/**
* e_config_target_free:
* @ep: Parent EConfig object.
* @o: The target to fre.
*
* Free a target. The implementing class can override this method to
* free custom targets.
**/
void
e_config_target_free(EConfig *ep, gpointer o)
{
EConfigTarget *t = o;
((EConfigClass *)G_OBJECT_GET_CLASS(ep))->target_free(ep, t);
}
/* ********************************************************************** */
/* Config menu plugin handler */
/*
<e-plugin
class="org.gnome.mail.plugin.config:1.0"
id="org.gnome.mail.plugin.config.item:1.0"
type="shlib"
location="/opt/gnome2/lib/camel/1.0/libcamelimap.so"
name="imap"
description="IMAP4 and IMAP4v1 mail store">
<hook class="org.gnome.mail.configMenu:1.0"
handler="HandleConfig">
<menu id="any" target="select">
<item
type="item|toggle|radio|image|submenu|bar"
active
path="foo/bar"
label="label"
icon="foo"
activate="ep_view_emacs"/>
</menu>
</extension>
*/
static gpointer emph_parent_class;
#define emph ((EConfigHook *)eph)
static const EPluginHookTargetKey ech_item_types[] = {
{ "book", E_CONFIG_BOOK },
{ "assistant", E_CONFIG_ASSISTANT },
{ "page", E_CONFIG_PAGE },
{ "page_start", E_CONFIG_PAGE_START },
{ "page_finish", E_CONFIG_PAGE_FINISH },
{ "section", E_CONFIG_SECTION },
{ "section_table", E_CONFIG_SECTION_TABLE },
{ "item", E_CONFIG_ITEM },
{ "item_table", E_CONFIG_ITEM_TABLE },
{ NULL },
};
static void
ech_commit(EConfig *ec, GSList *items, gpointer data)
{
struct _EConfigHookGroup *group = data;
if (group->commit && group->hook->hook.plugin->enabled)
e_plugin_invoke(group->hook->hook.plugin, group->commit, ec->target);
}
static void
ech_abort(EConfig *ec, GSList *items, gpointer data)
{
struct _EConfigHookGroup *group = data;
if (group->abort && group->hook->hook.plugin->enabled)
e_plugin_invoke(group->hook->hook.plugin, group->abort, ec->target);
}
static gboolean
ech_check(EConfig *ec, const gchar *pageid, gpointer data)
{
struct _EConfigHookGroup *group = data;
EConfigHookPageCheckData hdata;
if (!group->hook->hook.plugin->enabled)
return TRUE;
hdata.config = ec;
hdata.target = ec->target;
hdata.pageid = pageid?pageid:"";
return GPOINTER_TO_INT(e_plugin_invoke(group->hook->hook.plugin, group->check, &hdata));
}
static void
ech_config_factory(EConfig *emp, gpointer data)
{
struct _EConfigHookGroup *group = data;
d(printf("config factory called %s\n", group->id?group->id:"all menus"));
if (emp->target->type != group->target_type
|| !group->hook->hook.plugin->enabled)
return;
if (group->items)
e_config_add_items(emp, group->items, ech_commit, ech_abort, NULL, group);
if (group->check)
e_config_add_page_check(emp, NULL, ech_check, group);
}
static void
emph_free_item(struct _EConfigItem *item)
{
g_free(item->path);
g_free(item->label);
g_free(item->user_data);
g_free(item);
}
static void
emph_free_group(struct _EConfigHookGroup *group)
{
g_slist_foreach(group->items, (GFunc)emph_free_item, NULL);
g_slist_free(group->items);
g_free(group->id);
g_free(group);
}
static GtkWidget *
ech_config_widget_factory(EConfig *ec, EConfigItem *item, GtkWidget *parent, GtkWidget *old, gpointer data)
{
struct _EConfigHookGroup *group = data;
if (group->hook->hook.plugin->enabled) {
EConfigHookItemFactoryData hdata;
hdata.config = ec;
hdata.item = item;
hdata.target = ec->target;
hdata.parent = parent;
hdata.old = old;
return (GtkWidget *)e_plugin_invoke(group->hook->hook.plugin, (gchar *)item->user_data, &hdata);
} else
return NULL;
}
static struct _EConfigItem *
emph_construct_item(EPluginHook *eph, EConfigHookGroup *menu, xmlNodePtr root, EConfigHookTargetMap *map)
{
struct _EConfigItem *item;
d(printf(" loading config item\n"));
item = g_malloc0(sizeof(*item));
if ((item->type = e_plugin_hook_id(root, ech_item_types, "type")) == -1)
goto error;
item->path = e_plugin_xml_prop(root, "path");
item->label = e_plugin_xml_prop_domain(root, "label", eph->plugin->domain);
item->user_data = e_plugin_xml_prop(root, "factory");
if (item->path == NULL
|| (item->label == NULL && item->user_data == NULL))
goto error;
if (item->user_data)
item->factory = ech_config_widget_factory;
d(printf(" path=%s label=%s factory=%s\n", item->path, item->label, (gchar *)item->user_data));
return item;
error:
d(printf("error!\n"));
emph_free_item(item);
return NULL;
}
static struct _EConfigHookGroup *
emph_construct_menu(EPluginHook *eph, xmlNodePtr root)
{
struct _EConfigHookGroup *menu;
xmlNodePtr node;
EConfigHookTargetMap *map;
EConfigHookClass *class = (EConfigHookClass *)G_OBJECT_GET_CLASS(eph);
gchar *tmp;
d(printf(" loading menu\n"));
menu = g_malloc0(sizeof(*menu));
tmp = (gchar *)xmlGetProp(root, (const guchar *)"target");
if (tmp == NULL)
goto error;
map = g_hash_table_lookup(class->target_map, tmp);
xmlFree(tmp);
if (map == NULL)
goto error;
menu->target_type = map->id;
menu->id = e_plugin_xml_prop(root, "id");
if (menu->id == NULL) {
g_warning("Plugin '%s' missing 'id' field in group for '%s'\n", eph->plugin->name,
((EPluginHookClass *)G_OBJECT_GET_CLASS(eph))->id);
goto error;
}
menu->check = e_plugin_xml_prop(root, "check");
menu->commit = e_plugin_xml_prop(root, "commit");
menu->abort = e_plugin_xml_prop(root, "abort");
menu->hook = (EConfigHook *)eph;
node = root->children;
while (node) {
if (0 == strcmp((gchar *)node->name, "item")) {
struct _EConfigItem *item;
item = emph_construct_item(eph, menu, node, map);
if (item)
menu->items = g_slist_append(menu->items, item);
}
node = node->next;
}
return menu;
error:
emph_free_group(menu);
return NULL;
}
static gint
emph_construct(EPluginHook *eph, EPlugin *ep, xmlNodePtr root)
{
xmlNodePtr node;
EConfigClass *class;
d(printf("loading config hook\n"));
if (((EPluginHookClass *)emph_parent_class)->construct(eph, ep, root) == -1)
return -1;
class = ((EConfigHookClass *)G_OBJECT_GET_CLASS(eph))->config_class;
node = root->children;
while (node) {
if (strcmp((gchar *)node->name, "group") == 0) {
struct _EConfigHookGroup *group;
group = emph_construct_menu(eph, node);
if (group) {
e_config_class_add_factory(class, group->id, ech_config_factory, group);
emph->groups = g_slist_append(emph->groups, group);
}
}
node = node->next;
}
eph->plugin = ep;
return 0;
}
static void
emph_finalize(GObject *o)
{
EPluginHook *eph = (EPluginHook *)o;
g_slist_foreach(emph->groups, (GFunc)emph_free_group, NULL);
g_slist_free(emph->groups);
((GObjectClass *)emph_parent_class)->finalize(o);
}
static void
emph_class_init(EPluginHookClass *class)
{
((GObjectClass *)class)->finalize = emph_finalize;
class->construct = emph_construct;
/* this is actually an abstract implementation but list it anyway */
class->id = "org.gnome.evolution.config:1.0";
d(printf("EConfigHook: init class %p '%s'\n", class, g_type_name(((GObjectClass *)class)->g_type_class.g_type)));
((EConfigHookClass *)class)->target_map = g_hash_table_new(g_str_hash, g_str_equal);
((EConfigHookClass *)class)->config_class = g_type_class_ref(e_config_get_type());
}
/**
* e_config_hook_get_type:
*
* Standard GObject function to get the object type.
*
* Return value: The EConfigHook class type.
**/
GType
e_config_hook_get_type(void)
{
static GType type = 0;
if (!type) {
static const GTypeInfo info = {
sizeof(EConfigHookClass), NULL, NULL, (GClassInitFunc) emph_class_init, NULL, NULL,
sizeof(EConfigHook), 0, (GInstanceInitFunc) NULL,
};
emph_parent_class = g_type_class_ref(e_plugin_hook_get_type());
type = g_type_register_static(e_plugin_hook_get_type(), "EConfigHook", &info, 0);
}
return type;
}
/**
* e_config_hook_class_add_target_map:
*
* @class: The dervied EconfigHook class.
* @map: A map used to describe a single EConfigTarget type for this
* class.
*
* Add a targe tmap to a concrete derived class of EConfig. The
* target map enumates the target types available for the implenting
* class.
**/
void
e_config_hook_class_add_target_map (EConfigHookClass *class,
const EConfigHookTargetMap *map)
{
g_hash_table_insert(class->target_map, (gpointer)map->type, (gpointer)map);
}