/* $Id$ */
static char const _copyright[] =
"Copyright © 2013-2019 Pierre Pronchery <khorben@defora.org>";
/* This file is part of DeforaOS Desktop Coder */
static char const _license[] =
"This program is free software: you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation, version 3 of the License.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program.  If not, see <http://www.gnu.org/licenses/>.";



#include <sys/stat.h>
#include <dirent.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <libintl.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <System.h>
#include <Desktop.h>
#include <Database.h>
#include "sequel.h"
#include "../config.h"
#define _(string) gettext(string)
#define N_(string) (string)

/* constants */
#ifndef PROGNAME_SEQUEL
# define PROGNAME_SEQUEL	"sequel"
#endif

/* macros */
#ifndef MIN
# define MIN(a, b) ((a) < (b) ? (a) : (b))
#endif


/* Sequel */
/* private */
/* types */
typedef enum _SequelLogColumn
{
	SLC_DATE = 0,
	SLC_DATE_DISPLAY,
	SLC_TYPE,
	SLC_IMAGE,
	SLC_MESSAGE
} SequelLogColumn;
#define SLC_LAST SLC_MESSAGE
#define SLC_COUNT (SLC_LAST + 1)

typedef enum _SequelLogType
{
	SLT_INFO = 0,
	SLT_ERROR,
	SLT_WARNING
} SequelLogType;
#define SLT_LAST SLT_WARNING
#define SLT_COUNT (SLT_LAST + 1)

typedef struct _SequelTab SequelTab;

struct _Sequel
{
	/* internal */
	SequelTab * tabs;
	size_t tabs_cnt;

	Database * database;

	/* widgets */
	PangoFontDescription * font;
	GtkWidget * window;
#if GTK_CHECK_VERSION(2, 18, 0)
	GtkWidget * infobar;
	GtkWidget * infobar_label;
#endif
	GtkWidget * notebook;
	GtkWidget * statusbar;
	/* log console */
	GtkWidget * lo_window;
	GtkListStore * lo_store;
	GtkWidget * lo_view;
};

struct _SequelTab
{
	GtkWidget * label;
	GtkWidget * page;
	GtkWidget * text;
	GtkListStore * store;
	GtkWidget * view;
};


/* constants */
#define COLUMN_CNT 10

static char const * _authors[] =
{
	"Pierre Pronchery <khorben@defora.org>",
	NULL
};


/* prototypes */
/* accessors */
static void _sequel_set_status(Sequel * sequel, char const * status);


/* useful */
static void _sequel_log(Sequel * sequel, SequelLogType type,
		char const * message);

static int _sequel_open_tab(Sequel * sequel);
static void _sequel_close_all(Sequel * sequel);
static void _sequel_close_tab(Sequel * sequel, unsigned int i);

static int _sequel_connect(Sequel * sequel, char const * engine,
		char const * filename, char const * section);
static int _sequel_connect_dialog(Sequel * sequel);

static void _sequel_clear(Sequel * sequel);
static int _sequel_execute(Sequel * sequel);

static int _sequel_load(Sequel * sequel, char const * filename);
static int _sequel_load_dialog(Sequel * sequel);
static int _sequel_save_as(Sequel * sequel, char const * filename);
static int _sequel_save_as_dialog(Sequel * sequel);

static int _sequel_export(Sequel * sequel, char const * filename);
static int _sequel_export_dialog(Sequel * sequel);

/* callbacks */
static void _sequel_on_close(gpointer data);
static gboolean _sequel_on_closex(gpointer data);
static void _sequel_on_connect(gpointer data);
static void _sequel_on_execute(gpointer data);
static void _sequel_on_export(gpointer data);
static void _sequel_on_load(gpointer data);
static void _sequel_on_save_as(gpointer data);

static void _sequel_on_new_tab(gpointer data);

static void _sequel_on_file_close(gpointer data);
static void _sequel_on_file_close_all(gpointer data);
static void _sequel_on_file_connect(gpointer data);
static void _sequel_on_file_new_tab(gpointer data);
static void _sequel_on_query_clear(gpointer data);
static void _sequel_on_query_execute(gpointer data);
static void _sequel_on_query_export(gpointer data);
static void _sequel_on_query_load(gpointer data);
static void _sequel_on_query_save_as(gpointer data);
static void _sequel_on_view_error_console(gpointer data);
static void _sequel_on_help_about(gpointer data);
static void _sequel_on_help_contents(gpointer data);

static void _sequel_on_tab_close(GtkWidget * widget, gpointer data);
#if GTK_CHECK_VERSION(2, 10, 0)
static void _sequel_on_tab_reordered(GtkWidget * widget, GtkWidget * child,
		guint page, gpointer data);
#endif
static void _sequel_on_tab_switched(GtkWidget * widget, GtkWidget * child,
		guint page, gpointer data);


/* constants */
/* menubar */
static const DesktopMenu _sequel_file_menu[] =
{
	{ N_("New _tab"), G_CALLBACK(_sequel_on_file_new_tab), "tab-new",
		GDK_CONTROL_MASK, GDK_KEY_T },
	{ "", NULL, NULL, 0, 0 },
	{ N_("C_onnect..."), G_CALLBACK(_sequel_on_file_connect), NULL,
		GDK_CONTROL_MASK, GDK_KEY_O },
	{ "", NULL, NULL, 0, 0 },
	{ N_("_Close"), G_CALLBACK(_sequel_on_file_close), GTK_STOCK_CLOSE,
		GDK_CONTROL_MASK, GDK_KEY_W },
	{ N_("Close _All tabs"), G_CALLBACK(_sequel_on_file_close_all), NULL, 0,
		0 },
	{ NULL, NULL, NULL, 0, 0 }
};

static const DesktopMenu _sequel_query_menu[] =
{
	{ N_("Clear"), G_CALLBACK(_sequel_on_query_clear),
		GTK_STOCK_CLEAR, GDK_CONTROL_MASK, GDK_KEY_L },
	{ N_("Execute"), G_CALLBACK(_sequel_on_query_execute),
		GTK_STOCK_EXECUTE, GDK_CONTROL_MASK, GDK_KEY_Return },
	{ "", NULL, NULL, 0, 0 },
	{ N_("Load..."), G_CALLBACK(_sequel_on_query_load),
		GTK_STOCK_OPEN, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GDK_KEY_O },
	{ N_("Save as..."), G_CALLBACK(_sequel_on_query_save_as),
		GTK_STOCK_SAVE_AS, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
		GDK_KEY_S },
	{ "", NULL, NULL, 0, 0 },
	{ N_("Export..."), G_CALLBACK(_sequel_on_query_export),
		"stock_insert-table", GDK_CONTROL_MASK | GDK_SHIFT_MASK,
		GDK_KEY_E },
	{ NULL, NULL, NULL, 0, 0 }
};

static const DesktopMenu _sequel_view_menu[] =
{
	{ N_("_Log console"), G_CALLBACK(_sequel_on_view_error_console), NULL,
		0, 0 },
	{ NULL, NULL, NULL, 0, 0 }
};

static const DesktopMenu _sequel_help_menu[] =
{
	{ N_("_Contents"), G_CALLBACK(_sequel_on_help_contents),
		"help-contents", 0, GDK_KEY_F1 },
#if GTK_CHECK_VERSION(2, 6, 0)
	{ N_("_About"), G_CALLBACK(_sequel_on_help_about), GTK_STOCK_ABOUT, 0,
		0 },
#else
	{ N_("About"), G_CALLBACK(_sequel_on_help_about), NULL, 0, 0 },
#endif
	{ NULL, NULL, NULL, 0, 0 }
};

static const DesktopMenubar _sequel_menubar[] =
{
	{ N_("_File"), _sequel_file_menu },
	{ N_("_Query"), _sequel_query_menu },
	{ N_("_View"), _sequel_view_menu },
	{ N_("_Help"), _sequel_help_menu },
	{ NULL, NULL }
};


/* variables */
/* toolbar */
static DesktopToolbar _sequel_toolbar[] =
{
	{ N_("New tab"), G_CALLBACK(_sequel_on_new_tab), "tab-new", 0, 0,
		NULL },
	{ "", NULL, NULL, 0, 0, NULL },
	{ N_("Connect"), G_CALLBACK(_sequel_on_connect), GTK_STOCK_CONNECT, 0,
		0, NULL },
	{ "", NULL, NULL, 0, 0, NULL },
	{ N_("Execute"), G_CALLBACK(_sequel_on_execute), GTK_STOCK_EXECUTE, 0,
		0, NULL },
	{ "", NULL, NULL, 0, 0, NULL },
	{ N_("Load..."), G_CALLBACK(_sequel_on_load), GTK_STOCK_OPEN, 0, 0,
		NULL },
	{ N_("Save as..."), G_CALLBACK(_sequel_on_save_as), GTK_STOCK_SAVE_AS,
		0, 0, NULL },
	{ N_("Export..."), G_CALLBACK(_sequel_on_export), "stock_insert-table",
		0, 0, NULL },
	{ NULL, NULL, NULL, 0, 0, NULL }
};


/* public */
/* functions */
/* sequel_new */
Sequel * sequel_new(void)
{
	Sequel * sequel;
	GtkAccelGroup * group;
	GtkWidget * vbox;
	GtkWidget * widget;

	if((sequel = object_new(sizeof(*sequel))) == NULL)
		return NULL;
	sequel->tabs = NULL;
	sequel->tabs_cnt = 0;
	sequel->font = NULL;
	sequel->window = NULL;
	sequel->database = NULL;
	/* widgets */
	group = gtk_accel_group_new();
	sequel->font = pango_font_description_new();
	pango_font_description_set_family(sequel->font, "Monospace");
	sequel->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_add_accel_group(GTK_WINDOW(sequel->window), group);
	gtk_window_set_default_size(GTK_WINDOW(sequel->window), 640, 480);
#if GTK_CHECK_VERSION(2, 6, 0)
	gtk_window_set_icon_name(GTK_WINDOW(sequel->window),
			"stock_insert-table");
#endif
	gtk_window_set_title(GTK_WINDOW(sequel->window), _("Sequel"));
	g_signal_connect_swapped(sequel->window, "delete-event", G_CALLBACK(
				_sequel_on_closex), sequel);
#if GTK_CHECK_VERSION(3, 0, 0)
	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
	vbox = gtk_vbox_new(FALSE, 0);
#endif
	/* menubar */
	widget = desktop_menubar_create(_sequel_menubar, sequel, group);
	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
	/* toolbar */
	widget = desktop_toolbar_create(_sequel_toolbar, sequel, group);
	g_object_unref(group);
	gtk_widget_set_sensitive(GTK_WIDGET(_sequel_toolbar[4].widget), FALSE);
	gtk_widget_set_sensitive(GTK_WIDGET(_sequel_toolbar[8].widget), FALSE);
	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
	/* infobar */
	sequel->infobar = gtk_info_bar_new_with_buttons(GTK_STOCK_CLOSE,
			GTK_RESPONSE_CLOSE, NULL);
	gtk_info_bar_set_message_type(GTK_INFO_BAR(sequel->infobar),
			GTK_MESSAGE_ERROR);
	g_signal_connect(sequel->infobar, "close", G_CALLBACK(gtk_widget_hide),
			NULL);
	g_signal_connect(sequel->infobar, "response", G_CALLBACK(
				gtk_widget_hide), NULL);
	widget = gtk_info_bar_get_content_area(GTK_INFO_BAR(sequel->infobar));
	sequel->infobar_label = gtk_label_new(NULL);
	gtk_widget_show(sequel->infobar_label);
	gtk_box_pack_start(GTK_BOX(widget), sequel->infobar_label, TRUE, TRUE,
			0);
	gtk_widget_set_no_show_all(sequel->infobar, TRUE);
	gtk_box_pack_start(GTK_BOX(vbox), sequel->infobar, FALSE, TRUE, 0);
#endif
	/* view */
	sequel->notebook = gtk_notebook_new();
#if GTK_CHECK_VERSION(2, 10, 0)
	g_signal_connect(sequel->notebook, "page-reordered", G_CALLBACK(
				_sequel_on_tab_reordered), sequel);
#endif
	g_signal_connect(sequel->notebook, "switch-page", G_CALLBACK(
				_sequel_on_tab_switched), sequel);
	gtk_box_pack_start(GTK_BOX(vbox), sequel->notebook, TRUE, TRUE, 0);
	/* statusbar */
	sequel->statusbar = gtk_statusbar_new();
	gtk_box_pack_start(GTK_BOX(vbox), sequel->statusbar, FALSE, TRUE, 0);
	gtk_container_add(GTK_CONTAINER(sequel->window), vbox);
	/* error console */
	sequel->lo_window = NULL;
	sequel->lo_store = gtk_list_store_new(SLC_COUNT, G_TYPE_UINT,
			G_TYPE_STRING, G_TYPE_UINT, GDK_TYPE_PIXBUF,
			G_TYPE_STRING, G_TYPE_STRING);
	_sequel_set_status(sequel, _("Not connected"));
	gtk_widget_show_all(vbox);
	if(_sequel_open_tab(sequel) != 0)
	{
		sequel_delete(sequel);
		return NULL;
	}
	gtk_widget_show(sequel->window);
	return sequel;
}


/* sequel_delete */
void sequel_delete(Sequel * sequel)
{
	if(sequel->lo_window != NULL)
		gtk_widget_destroy(sequel->lo_window);
	if(sequel->database != NULL)
		database_delete(sequel->database);
	if(sequel->window != NULL)
		gtk_widget_destroy(sequel->window);
	if(sequel->font != NULL)
		pango_font_description_free(sequel->font);
	object_delete(sequel);
}


/* accessors */
/* sequel_set_status */
static void _sequel_set_status(Sequel * sequel, char const * status)
{
	GtkStatusbar * statusbar = GTK_STATUSBAR(sequel->statusbar);
	guint id;

	id = gtk_statusbar_get_context_id(statusbar, "");
	gtk_statusbar_pop(statusbar, id);
	gtk_statusbar_push(statusbar, id, status);
	_sequel_log(sequel, SLT_INFO, status);
}


/* useful */
/* sequel_error */
static int _error_text(char const * message, int ret);

int sequel_error(Sequel * sequel, char const * message, int ret)
{
#if !GTK_CHECK_VERSION(2, 18, 0)
	GtkWidget * dialog;
#endif

	if(sequel == NULL)
		return _error_text(message, ret);
#if GTK_CHECK_VERSION(2, 18, 0)
	gtk_label_set_text(GTK_LABEL(sequel->infobar_label), message);
	gtk_widget_show(sequel->infobar);
#else
	dialog = gtk_message_dialog_new(GTK_WINDOW(sequel->window),
			GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR,
			GTK_BUTTONS_CLOSE,
# if GTK_CHECK_VERSION(2, 6, 0)
			"%s", _("Error"));
	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
# endif
			"%s", message);
	gtk_window_set_title(GTK_WINDOW(dialog), _("Error"));
	gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);
#endif
	_sequel_log(sequel, SLT_ERROR, message);
	return ret;
}

static int _error_text(char const * message, int ret)
{
	fprintf(stderr, PROGNAME_SEQUEL ": %s\n", message);
	return ret;
}


/* sequel_show_console */
static void _console_window(Sequel * sequel);
/* callbacks */
static void _console_on_clear(gpointer data);
static gboolean _console_on_closex(gpointer data);

void sequel_show_console(Sequel * sequel, gboolean show)
{
	if(sequel->lo_window == NULL)
		_console_window(sequel);
	if(show)
		gtk_window_present(GTK_WINDOW(sequel->lo_window));
	else
		gtk_widget_hide(sequel->lo_window);
}

static void _console_window(Sequel * sequel)
{
	GtkWidget * vbox;
	GtkWidget * widget;
	GtkToolItem * toolitem;
	GtkCellRenderer * renderer;
	GtkTreeViewColumn * column;

	sequel->lo_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(sequel->lo_window), 400, 300);
#if GTK_CHECK_VERSION(2, 6, 0)
	gtk_window_set_icon_name(GTK_WINDOW(sequel->lo_window), "logviewer");
#endif
	gtk_window_set_title(GTK_WINDOW(sequel->lo_window), _("Log console"));
	g_signal_connect_swapped(sequel->lo_window, "delete-event", G_CALLBACK(
				_console_on_closex), sequel);
#if GTK_CHECK_VERSION(3, 0, 0)
	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
	vbox = gtk_vbox_new(FALSE, 0);
#endif
	/* toolbar */
	widget = gtk_toolbar_new();
	toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_CLEAR);
	g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK(
				_console_on_clear), sequel);
	gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
	gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
	/* view */
	widget = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	sequel->lo_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
				sequel->lo_store));
	/* columns */
	renderer = gtk_cell_renderer_pixbuf_new();
	column = gtk_tree_view_column_new_with_attributes("", renderer,
			"pixbuf", SLC_IMAGE, NULL);
	gtk_tree_view_column_set_sort_column_id(column, SLC_TYPE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(sequel->lo_view), column);
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(_("Timestamp"),
			renderer, "text", SLC_DATE_DISPLAY, NULL);
	gtk_tree_view_column_set_sort_column_id(column, SLC_DATE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(sequel->lo_view), column);
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(_("Message"),
			renderer, "text", SLC_MESSAGE, NULL);
	gtk_tree_view_column_set_sort_column_id(column, SLC_MESSAGE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(sequel->lo_view), column);
	gtk_container_add(GTK_CONTAINER(widget), sequel->lo_view);
	gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 0);
	gtk_widget_show_all(vbox);
	gtk_container_add(GTK_CONTAINER(sequel->lo_window), vbox);
}

static void _console_on_clear(gpointer data)
{
	Sequel * sequel = data;

	gtk_list_store_clear(sequel->lo_store);
}

static gboolean _console_on_closex(gpointer data)
{
	Sequel * sequel = data;

	gtk_widget_hide(sequel->lo_window);
	return TRUE;
}


/* private */
/* functions */
/* sequel_clear */
static void _sequel_clear(Sequel * sequel)
{
	gint i;
	GtkWidget * text;
	GtkTextBuffer * tbuf;

	i = gtk_notebook_get_current_page(GTK_NOTEBOOK(sequel->notebook));
	text = sequel->tabs[i].text;
	tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
	gtk_text_buffer_set_text(tbuf, "", 0);
}


/* sequel_close_all */
static void _sequel_close_all(Sequel * sequel)
{
	gtk_widget_hide(sequel->window);
	gtk_main_quit();
}


/* sequel_close_tab */
static void _sequel_close_tab(Sequel * sequel, unsigned int i)
{
	gtk_notebook_remove_page(GTK_NOTEBOOK(sequel->notebook), i);
	memmove(&sequel->tabs[i], &sequel->tabs[i + 1],
			(sequel->tabs_cnt - (i + 1)) * sizeof(*sequel->tabs));
	if(--sequel->tabs_cnt == 0)
		gtk_main_quit();
}


/* sequel_connect */
static int _sequel_connect(Sequel * sequel, char const * engine,
		char const * filename, char const * section)
{
	Config * config;
	gchar * buf;

	if(engine == NULL || filename == NULL)
		return _sequel_connect_dialog(sequel);
	if(sequel->database != NULL)
	{
		database_delete(sequel->database);
		sequel->database = NULL;
	}
	if((config = config_new()) != NULL
			&& config_load(config, filename) == 0)
		sequel->database = database_new(engine, config, section);
	if(sequel->database == NULL)
	{
		sequel_error(sequel, error_get(NULL), 1);
		gtk_widget_set_sensitive(GTK_WIDGET(_sequel_toolbar[4].widget),
				FALSE);
	}
	else
	{
		gtk_widget_set_sensitive(GTK_WIDGET(_sequel_toolbar[4].widget),
				TRUE);
		/* update the title */
		buf = g_strdup_printf("%s - %s%s%s", _("Sequel"), filename,
				(section != NULL && strlen(section)) ? " - "
				: "", (section != NULL && strlen(section))
				? section : "");
		gtk_window_set_title(GTK_WINDOW(sequel->window), buf);
		g_free(buf);
		/* update the status */
		buf = g_strdup_printf(_("Connected to %s"), engine);
		_sequel_set_status(sequel, buf);
		g_free(buf);
	}
	if(config != NULL)
		config_delete(config);
	return (sequel->database != NULL) ? 0 : -1;
}


/* sequel_connect_dialog */
static void _connect_dialog_engines(GtkListStore * store);
static void _connect_dialog_on_file_set(GtkWidget * widget, gpointer data);
static void _connect_dialog_config_foreach(char const * section, void * data);

static int _sequel_connect_dialog(Sequel * sequel)
{
	int ret;
	GtkSizeGroup * group;
	GtkWidget * dialog;
	GtkWidget * vbox;
	GtkWidget * hbox;
	GtkWidget * label;
	GtkListStore * store;
	GtkTreeIter iter;
	GtkWidget * entry1;
	GtkCellRenderer * renderer;
	GtkWidget * filesel;
	GtkFileFilter * filter;
	GtkWidget * entry2;
	gchar * engine;
	gchar * filename;
	gchar const * section;

	dialog = gtk_dialog_new_with_buttons(_("Connect..."),
			GTK_WINDOW(sequel->window),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_CONNECT, GTK_RESPONSE_ACCEPT, NULL);
	group = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
#if GTK_CHECK_VERSION(2, 14, 0)
	vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
#else
	vbox = GTK_DIALOG(dialog)->vbox;
#endif
	gtk_box_set_spacing(GTK_BOX(vbox), 4);
	/* engine */
#if GTK_CHECK_VERSION(3, 0, 0)
	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
	hbox = gtk_hbox_new(FALSE, 4);
#endif
	label = gtk_label_new(_("Engine:"));
#if GTK_CHECK_VERSION(3, 0, 0)
	g_object_set(label, "halign", GTK_ALIGN_START, NULL);
#else
	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
#endif
	gtk_size_group_add_widget(group, label);
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
	/* engine */
	store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
	entry1 = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
	renderer = gtk_cell_renderer_text_new();
	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(entry1), renderer, TRUE);
	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(entry1), renderer,
			"text", 1, NULL);
	_connect_dialog_engines(store);
	if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter) == TRUE)
		gtk_combo_box_set_active(GTK_COMBO_BOX(entry1), 0);
	gtk_box_pack_start(GTK_BOX(hbox), entry1, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
	/* filename */
#if GTK_CHECK_VERSION(3, 0, 0)
	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
	hbox = gtk_hbox_new(FALSE, 4);
#endif
	label = gtk_label_new(_("Connection file:"));
#if GTK_CHECK_VERSION(3, 0, 0)
	g_object_set(label, "halign", GTK_ALIGN_START, NULL);
#else
	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
#endif
	gtk_size_group_add_widget(group, label);
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
	filesel = gtk_file_chooser_button_new(_("Open connection file..."),
			GTK_FILE_CHOOSER_ACTION_OPEN);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("Connection files"));
	gtk_file_filter_add_pattern(filter, "*.conf");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("All files"));
	gtk_file_filter_add_pattern(filter, "*");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel), filter);
	gtk_box_pack_start(GTK_BOX(hbox), filesel, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
	/* section */
#if GTK_CHECK_VERSION(3, 0, 0)
	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
	hbox = gtk_hbox_new(FALSE, 4);
#endif
	label = gtk_label_new(_("Section:"));
#if GTK_CHECK_VERSION(3, 0, 0)
	g_object_set(label, "halign", GTK_ALIGN_START, NULL);
#else
	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
#endif
	gtk_size_group_add_widget(group, label);
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 24, 0)
	entry2 = gtk_combo_box_text_new();
#else
	entry2 = gtk_combo_box_new_text();
#endif
	gtk_box_pack_start(GTK_BOX(hbox), entry2, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
	gtk_widget_show_all(vbox);
	g_signal_connect(filesel, "file-set", G_CALLBACK(
				_connect_dialog_on_file_set), entry2);
	if(gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT)
	{
		gtk_widget_destroy(dialog);
		return 0;
	}
	gtk_widget_hide(dialog);
	if(gtk_combo_box_get_active_iter(GTK_COMBO_BOX(entry1), &iter))
		gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &engine,
				-1);
	else
		engine = NULL;
	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filesel));
#if GTK_CHECK_VERSION(2, 24, 0)
	section = gtk_combo_box_text_get_active_text(
			GTK_COMBO_BOX_TEXT(entry2));
#else
	section = gtk_combo_box_get_active_text(GTK_COMBO_BOX(entry2));
#endif
	if(engine == NULL || filename == NULL)
		/* FIXME report error */
		ret = -1;
	else
		ret = _sequel_connect(sequel, engine, filename, section);
	g_free(filename);
	g_free(engine);
	gtk_widget_destroy(dialog);
	return ret;
}

static void _connect_dialog_engines(GtkListStore * store)
{
	char const path[] = LIBDIR "/Database/engine";
	DIR * dir;
	struct dirent * de;
#ifdef __APPLE__
	char const ext[] = ".dylib";
#else
	char const ext[] = ".so";
#endif
	size_t len;
	GtkTreeIter iter;
	Plugin * plugin;
	DatabaseEngineDefinition * database;
	String * engine;

	if((dir = opendir(path)) == NULL)
		return;
	while((de = readdir(dir)) != NULL)
	{
		if(strcmp(de->d_name, ".") == 0
				|| strcmp(de->d_name, "..") == 0)
			continue;
		if((len = strlen(de->d_name)) < sizeof(ext))
			continue;
		if(strcmp(&de->d_name[len - sizeof(ext) + 1], ext) != 0)
			continue;
		de->d_name[len - sizeof(ext) + 1] = '\0';
		if((plugin = plugin_new(LIBDIR, "Database", "engine",
						de->d_name)) != NULL
				&& (database = plugin_lookup(plugin,
						"database")) != NULL)
			engine = database->name;
		else
			engine = NULL;
#if GTK_CHECK_VERSION(2, 6, 0)
		gtk_list_store_insert_with_values(store, &iter, -1,
#else
		gtk_list_store_append(store, &iter);
		gtk_list_store_set(store, &iter,
#endif
				0, de->d_name,
				1, (engine != NULL) ? engine : de->d_name, -1);
		if(plugin != NULL)
			plugin_delete(plugin);
	}
	closedir(dir);
}

static void _connect_dialog_on_file_set(GtkWidget * widget, gpointer data)
{
	GtkWidget * entry2 = data;
	GtkTreeModel * model;
	GtkListStore * store;
	gchar * filename;
	Config * config;

	model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry2));
	store = GTK_LIST_STORE(model);
	gtk_list_store_clear(store);
	if((filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget)))
			== NULL)
		return;
	if((config = config_new()) != NULL)
		config_load(config, filename);
	g_free(filename);
	if(config == NULL)
		return;
	config_foreach(config, _connect_dialog_config_foreach, entry2);
	config_delete(config);
}

static void _connect_dialog_config_foreach(char const * section, void * data)
{
	GtkWidget * entry2 = data;

#if GTK_CHECK_VERSION(2, 24, 0)
	gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(entry2), section);
#else
	gtk_combo_box_append_text(GTK_COMBO_BOX(entry2), section);
#endif
	gtk_combo_box_set_active(GTK_COMBO_BOX(entry2), 0);
}


/* sequel_execute */
static int _execute_on_callback(void * data, int argc, char ** argv,
		char ** columns);
static GtkListStore * _execute_on_callback_store(GtkTreeView * view, int argc,
		char ** columns);

static int _sequel_execute(Sequel * sequel)
{
	gint i;
	GtkTextBuffer * buffer;
	GtkTextIter start;
	GtkTextIter end;
	gchar * query;
	int res;

	if(sequel->database == NULL)
		return _sequel_connect_dialog(sequel);
	i = gtk_notebook_get_current_page(GTK_NOTEBOOK(sequel->notebook));
	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(sequel->tabs[i].text));
	gtk_text_buffer_get_start_iter(buffer, &start);
	gtk_text_buffer_get_end_iter(buffer, &end);
	query = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
	if(sequel->tabs[i].store != NULL)
	{
		gtk_list_store_clear(sequel->tabs[i].store);
		gtk_tree_view_set_model(GTK_TREE_VIEW(sequel->tabs[i].view),
				NULL);
		g_object_unref(sequel->tabs[i].store);
		sequel->tabs[i].store = NULL;
	}
	res = database_query(sequel->database, query, _execute_on_callback,
			sequel);
	g_free(query);
	gtk_widget_set_sensitive(GTK_WIDGET(_sequel_toolbar[8].widget),
			(sequel->tabs[i].store != NULL) ? TRUE : FALSE);
	if(res != 0)
		return -sequel_error(sequel, error_get(NULL), 1);
	return 0;
}

static int _execute_on_callback(void * data, int argc, char ** argv,
		char ** columns)
{
	Sequel * sequel = data;
	gint i;
	GtkListStore * store;
	GtkTreeView * view;
	GtkTreeIter iter;

	i = gtk_notebook_get_current_page(GTK_NOTEBOOK(sequel->notebook));
	if((store = sequel->tabs[i].store) == NULL)
	{
		view = GTK_TREE_VIEW(sequel->tabs[i].view);
		sequel->tabs[i].store = _execute_on_callback_store(view, argc,
				columns);
		store = sequel->tabs[i].store;
	}
	gtk_list_store_append(store, &iter);
	if(argv != NULL)
		for(i = 0; i < MIN(argc, COLUMN_CNT); i++)
			/* XXX the data may not be valid UTF-8 */
			gtk_list_store_set(store, &iter, i, argv[i], -1);
	return 0;
}

static GtkListStore * _execute_on_callback_store(GtkTreeView * view, int argc,
		char ** columns)
{
	GtkListStore * store;
	GList * l;
	GtkCellRenderer * renderer;
	GtkTreeViewColumn * c;
	GtkWidget * widget;
	GList * p;
	gint i;

	/* create the current store */
	/* XXX no longer hard-code the number of columns */
	store = gtk_list_store_new(COLUMN_CNT,
			G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
			G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
			G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
			G_TYPE_STRING);
	gtk_tree_view_set_model(view, GTK_TREE_MODEL(store));
	if((l = gtk_tree_view_get_columns(view)) == NULL)
	{
		/* create the rendering columns */
		for(i = 0; i < COLUMN_CNT; i++)
		{
			renderer = gtk_cell_renderer_text_new();
			c = gtk_tree_view_column_new_with_attributes("",
					renderer, "text", i, NULL);
			/* use our own label as the column title */
			widget = gtk_label_new(NULL);
			gtk_widget_show(widget);
			gtk_tree_view_column_set_widget(c, widget);
			gtk_tree_view_column_set_resizable(c, TRUE);
			gtk_tree_view_column_set_sort_column_id(c, i);
			gtk_tree_view_append_column(view, c);
		}
		l = gtk_tree_view_get_columns(view);
	}
	/* set the visible columns (and their respective title) */
	for(p = l, i = 0; p != NULL && i < MIN(argc, COLUMN_CNT);
			p = p->next, i++)
	{
		gtk_tree_view_column_set_title(p->data, columns[i]);
		widget = gtk_tree_view_column_get_widget(p->data);
		gtk_label_set_text(GTK_LABEL(widget), columns[i]);
		gtk_tree_view_column_set_visible(p->data, TRUE);
	}
	/* hide the remaining columns */
	for(; p != NULL && i < COLUMN_CNT; p = p->next, i++)
		gtk_tree_view_column_set_visible(p->data, FALSE);
	gtk_tree_view_columns_autosize(view);
	g_list_free(l);
	return store;
}


/* sequel_export */
static int _sequel_export(Sequel * sequel, char const * filename)
{
	struct stat st;
	GtkWidget * dialog;
	gboolean res;
	FILE * fp;
	gint i;
	GtkWidget * view;
	GtkTreeModel * model;
	GList * columns;
	gboolean valid;
	GtkTreeIter iter;
	gchar * buf;
	char const * sep = "";
	size_t len;
	GList * p;

	if(filename == NULL)
		return _sequel_export_dialog(sequel);
	if(stat(filename, &st) == 0)
	{
		dialog = gtk_message_dialog_new(GTK_WINDOW(sequel->window),
				GTK_DIALOG_MODAL
				| GTK_DIALOG_DESTROY_WITH_PARENT,
				GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
#if GTK_CHECK_VERSION(2, 6, 0)
				"%s", _("Question"));
		gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(
					dialog),
#endif
				"%s", _("This file already exists."
					" Overwrite?"));
		gtk_window_set_title(GTK_WINDOW(dialog), _("Question"));
		res = gtk_dialog_run(GTK_DIALOG(dialog));
		gtk_widget_destroy(dialog);
		if(res == GTK_RESPONSE_NO)
			return -1;
	}
	i = gtk_notebook_get_current_page(GTK_NOTEBOOK(sequel->notebook));
	if(i < 0)
		return -1;
	view = sequel->tabs[i].view;
	model = GTK_TREE_MODEL(sequel->tabs[i].store);
	if((fp = fopen(filename, "w")) == NULL)
		return -sequel_error(sequel, strerror(errno), 1);
	columns = gtk_tree_view_get_columns(GTK_TREE_VIEW(view));
	for(valid = gtk_tree_model_get_iter_first(model, &iter);
			valid; valid = gtk_tree_model_iter_next(model, &iter))
	{
		for(p = columns, i = 0; p != NULL; p = p->next, i++)
		{
			if(gtk_tree_view_column_get_visible(p->data) != TRUE)
				break;
			gtk_tree_model_get(model, &iter, i, &buf, -1);
			/* XXX buf may contain commas */
			len = (buf != NULL) ? strlen(buf) : 0;
			if(fwrite(sep, sizeof(*sep), strlen(sep), fp)
					!= strlen(sep)
					|| fwrite(buf, sizeof(*buf), len, fp)
					!= len)
			{
				g_free(buf);
				fclose(fp);
				unlink(filename);
				return -sequel_error(sequel, strerror(errno),
						1);
			}
			g_free(buf);
			sep = ",";
		}
		if(fwrite("\n", sizeof(char), 1, fp) != sizeof(char))
		{
			fclose(fp);
			unlink(filename);
			return -sequel_error(sequel, strerror(errno), 1);
		}
		sep = "";
	}
	if(fclose(fp) != 0)
	{
		unlink(filename);
		return -sequel_error(sequel, strerror(errno), 1);
	}
	return 0;
}


/* sequel_export_dialog */
static int _sequel_export_dialog(Sequel * sequel)
{
	int ret;
	GtkWidget * dialog;
	GtkFileFilter * filter;
	gchar * filename = NULL;

	dialog = gtk_file_chooser_dialog_new(_("Export..."),
			GTK_WINDOW(sequel->window),
			GTK_FILE_CHOOSER_ACTION_SAVE,
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("CSV files"));
	gtk_file_filter_add_mime_type(filter, "text/csv");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("All files"));
	gtk_file_filter_add_pattern(filter, "*");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(
					dialog));
	gtk_widget_destroy(dialog);
	if(filename == NULL)
		return FALSE;
	ret = _sequel_export(sequel, filename);
	g_free(filename);
	return ret;
}


/* sequel_load */
static int _sequel_load(Sequel * sequel, char const * filename)
{
	int ret = 0;
	gint i;
	GtkWidget * text;
	GtkTextBuffer * tbuf;
	FILE * fp;
	char buf[BUFSIZ];
	size_t size;
	GtkTextIter iter;

	if(filename == NULL)
		return _sequel_load_dialog(sequel);
	if((fp = fopen(filename, "r")) == NULL)
		return -sequel_error(sequel, strerror(errno), 1);
	i = gtk_notebook_get_current_page(GTK_NOTEBOOK(sequel->notebook));
	text = sequel->tabs[i].text;
	tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
	gtk_text_buffer_set_text(tbuf, "", 0);
	while((size = fread(buf, sizeof(*buf), sizeof(buf), fp)) > 0)
	{
		gtk_text_buffer_get_end_iter(tbuf, &iter);
		gtk_text_buffer_insert(tbuf, &iter, buf, size);
	}
	if(ferror(fp))
		ret = -sequel_error(sequel, strerror(errno), 1);
	fclose(fp);
	return ret;
}


/* sequel_load_dialog */
static int _sequel_load_dialog(Sequel * sequel)
{
	int ret;
	GtkWidget * dialog;
	GtkFileFilter * filter;
	gchar * filename = NULL;

	dialog = gtk_file_chooser_dialog_new(_("Load query..."),
			GTK_WINDOW(sequel->window),
			GTK_FILE_CHOOSER_ACTION_OPEN,
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("SQL files"));
	gtk_file_filter_add_mime_type(filter, "text/x-sql");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("All files"));
	gtk_file_filter_add_pattern(filter, "*");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(
					dialog));
	gtk_widget_destroy(dialog);
	if(filename == NULL)
		return FALSE;
	ret = _sequel_load(sequel, filename);
	g_free(filename);
	return ret;
}


/* sequel_log */
static void _sequel_log(Sequel * sequel, SequelLogType type,
		char const * message)
{
	GtkTreeIter iter;
	time_t date;
	struct tm t;
	char buf[32];
	const char * icons[SLT_COUNT] = { GTK_STOCK_DIALOG_INFO,
		GTK_STOCK_DIALOG_WARNING, GTK_STOCK_DIALOG_ERROR };
	GtkIconTheme * icontheme;
	GdkPixbuf * pixbuf;

	date = time(NULL);
	localtime_r(&date, &t);
	strftime(buf, sizeof(buf), "%d/%m/%Y %H:%M:%S", &t);
	icontheme = gtk_icon_theme_get_default();
	pixbuf = gtk_icon_theme_load_icon(icontheme, icons[type],
			GTK_ICON_SIZE_BUTTON, 0, NULL);
#if GTK_CHECK_VERSION(2, 6, 0)
	gtk_list_store_insert_with_values(sequel->lo_store, &iter, -1,
#else
	gtk_list_store_append(sequel->lo_store, &iter);
	gtk_list_store_set(sequel->lo_store, &iter,
#endif
			SLC_DATE, date, SLC_DATE_DISPLAY, buf, SLC_TYPE, type,
			SLC_IMAGE, pixbuf, SLC_MESSAGE, message, -1);
	g_object_unref(pixbuf);
}


/* sequel_open_tab */
static int _sequel_open_tab(Sequel * sequel)
{
	SequelTab * p;
	GtkWidget * paned;
	GtkWidget * widget;
	char buf[24];

	if((p = realloc(sequel->tabs, sizeof(*p) * (sequel->tabs_cnt + 1)))
			== NULL)
		return -1;
	sequel->tabs = p;
	p = &sequel->tabs[sequel->tabs_cnt++];
	/* create the tab */
#if GTK_CHECK_VERSION(3, 0, 0)
	p->label = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
	p->label = gtk_hbox_new(FALSE, 4);
#endif
	snprintf(buf, sizeof(buf), _("Tab %lu"), sequel->tabs_cnt);
	gtk_box_pack_start(GTK_BOX(p->label), gtk_label_new(buf), TRUE, TRUE,
			0);
	widget = gtk_button_new();
	g_signal_connect(widget, "clicked", G_CALLBACK(_sequel_on_tab_close),
			sequel);
	gtk_container_add(GTK_CONTAINER(widget), gtk_image_new_from_stock(
				GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU));
	gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NONE);
	gtk_box_pack_start(GTK_BOX(p->label), widget, FALSE, TRUE, 0);
	gtk_widget_show_all(p->label);
#if GTK_CHECK_VERSION(3, 0, 0)
	paned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
#else
	paned = gtk_vpaned_new();
#endif
	p->page = paned;
	/* text area */
	widget = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	p->text = gtk_text_view_new();
#if GTK_CHECK_VERSION(3, 0, 0)
	gtk_widget_override_font(p->text, sequel->font);
#else
	gtk_widget_modify_font(p->text, sequel->font);
#endif
	gtk_container_add(GTK_CONTAINER(widget), p->text);
	gtk_paned_add1(GTK_PANED(paned), widget);
	/* results area */
	p->store = NULL;
	p->view = gtk_tree_view_new();
	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(p->view), TRUE);
	widget = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_container_add(GTK_CONTAINER(widget), p->view);
	gtk_paned_add2(GTK_PANED(paned), widget);
	gtk_widget_show_all(paned);
	gtk_notebook_append_page(GTK_NOTEBOOK(sequel->notebook), paned,
			p->label);
#if GTK_CHECK_VERSION(2, 10, 0)
	gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(sequel->notebook), paned,
			TRUE);
#endif
	return 0;
}


/* sequel_save_as */
static int _sequel_save_as(Sequel * sequel, char const * filename)
{
	struct stat st;
	GtkWidget * dialog;
	gboolean res;
	FILE * fp;
	gint i;
	GtkWidget * text;
	GtkTextBuffer * tbuf;
	GtkTextIter start;
	GtkTextIter end;
	gchar * buf;
	size_t len;

	if(filename == NULL)
		return _sequel_save_as_dialog(sequel);
	if(stat(filename, &st) == 0)
	{
		dialog = gtk_message_dialog_new(GTK_WINDOW(sequel->window),
				GTK_DIALOG_MODAL
				| GTK_DIALOG_DESTROY_WITH_PARENT,
				GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
#if GTK_CHECK_VERSION(2, 6, 0)
				"%s", _("Question"));
		gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(
					dialog),
#endif
				"%s", _("This file already exists."
					" Overwrite?"));
		gtk_window_set_title(GTK_WINDOW(dialog), _("Question"));
		res = gtk_dialog_run(GTK_DIALOG(dialog));
		gtk_widget_destroy(dialog);
		if(res == GTK_RESPONSE_NO)
			return -1;
	}
	i = gtk_notebook_get_current_page(GTK_NOTEBOOK(sequel->notebook));
	if(i < 0)
		return -1;
	text = sequel->tabs[i].text;
	tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
	if((fp = fopen(filename, "w")) == NULL)
		return -sequel_error(sequel, strerror(errno), 1);
	/* XXX allocating the complete file is not optimal */
	gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(tbuf), &start);
	gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(tbuf), &end);
	buf = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(tbuf), &start, &end,
			FALSE);
	len = strlen(buf);
	if(fwrite(buf, sizeof(*buf), len, fp) != len)
	{
		g_free(buf);
		fclose(fp);
		unlink(filename);
		return -sequel_error(sequel, strerror(errno), 1);
	}
	g_free(buf);
	if(fclose(fp) != 0)
	{
		unlink(filename);
		return -sequel_error(sequel, strerror(errno), 1);
	}
	return 0;
}


/* sequel_save_as_dialog */
static int _sequel_save_as_dialog(Sequel * sequel)
{
	int ret;
	GtkWidget * dialog;
	GtkFileFilter * filter;
	gchar * filename = NULL;

	dialog = gtk_file_chooser_dialog_new(_("Save as..."),
			GTK_WINDOW(sequel->window),
			GTK_FILE_CHOOSER_ACTION_SAVE,
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("SQL files"));
	gtk_file_filter_add_mime_type(filter, "text/x-sql");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("All files"));
	gtk_file_filter_add_pattern(filter, "*");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(
					dialog));
	gtk_widget_destroy(dialog);
	if(filename == NULL)
		return FALSE;
	ret = _sequel_save_as(sequel, filename);
	g_free(filename);
	return ret;
}


/* callbacks */
/* sequel_on_close */
static void _sequel_on_close(gpointer data)
{
	Sequel * sequel = data;
	gint i;

	i = gtk_notebook_get_current_page(GTK_NOTEBOOK(sequel->notebook));
	if(i < 0)
		return;
	_sequel_close_tab(sequel, i);
}


/* sequel_on_closex */
static gboolean _on_closex_confirm(Sequel * sequel);

static gboolean _sequel_on_closex(gpointer data)
{
	Sequel * sequel = data;

	if(sequel->tabs_cnt > 1 && _on_closex_confirm(sequel) != TRUE)
		return TRUE;
	_sequel_close_all(sequel);
	return TRUE;
}

static gboolean _on_closex_confirm(Sequel * sequel)
{
	GtkWidget * dialog;
	gboolean res;

	dialog = gtk_message_dialog_new(GTK_WINDOW(sequel->window),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
#if GTK_CHECK_VERSION(2, 6, 0)
			"%s", _("Question"));
	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
#endif
			"%s", _("There are multiple tabs opened.\n"
				"Do you really want to close every tab"
				" opened in this window?"));
	gtk_dialog_add_buttons(GTK_DIALOG(dialog),
			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
			GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
	gtk_window_set_title(GTK_WINDOW(dialog), _("Question"));
	res = gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);
	return (res == GTK_RESPONSE_CLOSE) ? TRUE : FALSE;
}


/* sequel_on_connect */
static void _sequel_on_connect(gpointer data)
{
	Sequel * sequel = data;

	_sequel_connect_dialog(sequel);
}


/* sequel_on_execute */
static void _sequel_on_execute(gpointer data)
{
	Sequel * sequel = data;

	_sequel_execute(sequel);
}


/* sequel_on_export */
static void _sequel_on_export(gpointer data)
{
	Sequel * sequel = data;

	_sequel_export_dialog(sequel);
}


/* sequel_on_file_close */
static void _sequel_on_file_close(gpointer data)
{
	Sequel * sequel = data;

	_sequel_on_close(sequel);
}


/* sequel_on_file_close */
static void _sequel_on_file_close_all(gpointer data)
{
	Sequel * sequel = data;

	_sequel_close_all(sequel);
}


/* sequel_on_file_connect */
static void _sequel_on_file_connect(gpointer data)
{
	Sequel * sequel = data;

	_sequel_on_connect(sequel);
}


/* sequel_on_file_new_tab */
static void _sequel_on_file_new_tab(gpointer data)
{
	Sequel * sequel = data;

	_sequel_on_new_tab(sequel);
}


/* sequel_on_help_about */
static void _sequel_on_help_about(gpointer data)
{
	Sequel * sequel = data;
	GtkWidget * dialog;

	dialog = desktop_about_dialog_new();
	gtk_window_set_transient_for(GTK_WINDOW(dialog),
			GTK_WINDOW(sequel->window));
	desktop_about_dialog_set_authors(dialog, _authors);
	desktop_about_dialog_set_comments(dialog,
			_("SQL console for the DeforaOS desktop"));
	desktop_about_dialog_set_copyright(dialog, _copyright);
	desktop_about_dialog_set_license(dialog, _license);
	desktop_about_dialog_set_logo_icon_name(dialog, "stock_insert-table");
	desktop_about_dialog_set_name(dialog, "Sequel");
	desktop_about_dialog_set_version(dialog, VERSION);
	desktop_about_dialog_set_website(dialog, "https://www.defora.org/");
	gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_destroy(dialog);
}


/* sequel_on_help_contents */
static void _sequel_on_help_contents(gpointer data)
{
	(void) data;

	desktop_help_contents(PACKAGE, PROGNAME_SEQUEL);
}


/* sequel_on_load */
static void _sequel_on_load(gpointer data)
{
	Sequel * sequel = data;

	_sequel_load_dialog(sequel);
}


/* sequel_on_new_tab */
static void _sequel_on_new_tab(gpointer data)
{
	Sequel * sequel = data;

	_sequel_open_tab(sequel);
}


/* sequel_on_query_clear */
static void _sequel_on_query_clear(gpointer data)
{
	Sequel * sequel = data;

	_sequel_clear(sequel);
}


/* sequel_on_query_execute */
static void _sequel_on_query_execute(gpointer data)
{
	Sequel * sequel = data;

	_sequel_execute(sequel);
}


/* sequel_on_query_export */
static void _sequel_on_query_export(gpointer data)
{
	Sequel * sequel = data;

	_sequel_export_dialog(sequel);
}


/* sequel_on_query_load */
static void _sequel_on_query_load(gpointer data)
{
	Sequel * sequel = data;

	_sequel_load_dialog(sequel);
}


/* sequel_on_query_save_as */
static void _sequel_on_query_save_as(gpointer data)
{
	Sequel * sequel = data;

	_sequel_save_as_dialog(sequel);
}


/* sequel_on_save_as */
static void _sequel_on_save_as(gpointer data)
{
	Sequel * sequel = data;

	_sequel_save_as_dialog(sequel);
}


/* sequel_on_tab_close */
static void _sequel_on_tab_close(GtkWidget * widget, gpointer data)
{
	Sequel * sequel = data;
	size_t i;

	widget = gtk_widget_get_parent(widget);
	for(i = 0; i < sequel->tabs_cnt; i++)
		if(sequel->tabs[i].label == widget)
			break;
	if(i >= sequel->tabs_cnt)
		/* should not happen */
		return;
	_sequel_close_tab(sequel, i);
}


#if GTK_CHECK_VERSION(2, 10, 0)
/* sequel_on_tab_reordered */
static void _sequel_on_tab_reordered(GtkWidget * widget, GtkWidget * child,
		guint page, gpointer data)
{
	Sequel * sequel = data;
	SequelTab tab;
	guint old = 0;
	size_t i;
	(void) widget;
	(void) data;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%u)\n", __func__, page);
#endif
	for(i = 0; i < sequel->tabs_cnt; i++)
		if(sequel->tabs[i].page == child)
		{
			old = i;
			break;
		}
	if(i == sequel->tabs_cnt)
		return;
	memcpy(&tab, &sequel->tabs[old], sizeof(tab));
	memcpy(&sequel->tabs[old], &sequel->tabs[page], sizeof(tab));
	memcpy(&sequel->tabs[page], &tab, sizeof(tab));
}
#endif


/* sequel_on_tab_switched */
static void _sequel_on_tab_switched(GtkWidget * widget, GtkWidget * child,
		guint page, gpointer data)
{
	Sequel * sequel = data;
	GtkListStore * store;
	gboolean active;
	(void) child;
	(void) widget;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%u)\n", __func__, page);
#endif
	active = ((store = sequel->tabs[page].store) != NULL) ? TRUE : FALSE;
	gtk_widget_set_sensitive(GTK_WIDGET(_sequel_toolbar[8].widget), active);
}


/* sequel_on_view_error_console */
static void _sequel_on_view_error_console(gpointer data)
{
	Sequel * sequel = data;

	sequel_show_console(sequel, TRUE);
}