/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

/* nemo-column-chooser.h - A column chooser widget

   Copyright (C) 2004 Novell, Inc.

   The Gnome Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The Gnome 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the Gnome Library; see the column COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 51 Franklin Street - Suite 500,
   Boston, MA 02110-1335, USA.

   Authors: Dave Camp <dave@ximian.com>
*/

#include <config.h>
#include "nemo-column-chooser.h"

#include <string.h>
#include <gtk/gtk.h>
#include <glib/gi18n.h>

#include "nemo-column-utilities.h"

struct _NemoColumnChooserDetails
{
	GtkTreeView *view;
	GtkListStore *store;

	GtkWidget *move_up_button;
	GtkWidget *move_down_button;
	GtkWidget *use_default_button;

	NemoFile *file;
};

enum {
	COLUMN_VISIBLE,
	COLUMN_LABEL,
	COLUMN_NAME,
    COLUMN_TOGGLE_SENSITIVE,
	NUM_COLUMNS
};

enum {
	PROP_FILE = 1,
	NUM_PROPERTIES
};

enum {
	CHANGED,
	USE_DEFAULT,
	LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };


G_DEFINE_TYPE(NemoColumnChooser, nemo_column_chooser, GTK_TYPE_BOX);

static void nemo_column_chooser_constructed (GObject *object);

static void
nemo_column_chooser_set_property (GObject *object,
				      guint param_id,
				      const GValue *value,
				      GParamSpec *pspec)
{
	NemoColumnChooser *chooser;

	chooser = NEMO_COLUMN_CHOOSER (object);

	switch (param_id) {
		case PROP_FILE:
			chooser->details->file = g_value_get_object (value);
			break;
		default:
			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
			break;
	}
}

static void
nemo_column_chooser_class_init (NemoColumnChooserClass *chooser_class)
{
	GObjectClass *oclass;

	oclass = G_OBJECT_CLASS (chooser_class);

	oclass->set_property = nemo_column_chooser_set_property;
	oclass->constructed = nemo_column_chooser_constructed;

	signals[CHANGED] = g_signal_new
		("changed",
		 G_TYPE_FROM_CLASS (chooser_class),
		 G_SIGNAL_RUN_LAST,
		 G_STRUCT_OFFSET (NemoColumnChooserClass,
				  changed),
		 NULL, NULL,
		 g_cclosure_marshal_VOID__VOID,
		 G_TYPE_NONE, 0);

	signals[USE_DEFAULT] = g_signal_new
		("use_default",
		 G_TYPE_FROM_CLASS (chooser_class),
		 G_SIGNAL_RUN_LAST,
		 G_STRUCT_OFFSET (NemoColumnChooserClass,
				  use_default),
		 NULL, NULL,
		 g_cclosure_marshal_VOID__VOID,
		 G_TYPE_NONE, 0);

	g_object_class_install_property (oclass,
	                                 PROP_FILE,
	                                 g_param_spec_object ("file",
	                                                      "File",
	                                                      "The file this column chooser is for",
	                                                      NEMO_TYPE_FILE,
	                                                      G_PARAM_CONSTRUCT_ONLY |
	                                                      G_PARAM_WRITABLE));

	g_type_class_add_private (chooser_class, sizeof (NemoColumnChooserDetails));
}

static void 
update_buttons (NemoColumnChooser *chooser)
{
	GtkTreeSelection *selection;
	GtkTreeIter iter;
	
	selection = gtk_tree_view_get_selection (chooser->details->view);

	if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
		gboolean visible;
		gboolean top;
		gboolean bottom;
		GtkTreePath *first;
		GtkTreePath *path;
		
		gtk_tree_model_get (GTK_TREE_MODEL (chooser->details->store),
				    &iter, 
				    COLUMN_VISIBLE, &visible, 
				    -1);
		
		path = gtk_tree_model_get_path (GTK_TREE_MODEL (chooser->details->store),
						&iter);
		first = gtk_tree_path_new_first ();
		
		top = (gtk_tree_path_compare (path, first) == 0);

		gtk_tree_path_free (path);
		gtk_tree_path_free (first);
		
		bottom = !gtk_tree_model_iter_next (GTK_TREE_MODEL (chooser->details->store),
						    &iter);

		gtk_widget_set_sensitive (chooser->details->move_up_button,
					  !top);
		gtk_widget_set_sensitive (chooser->details->move_down_button,
					  !bottom);
	} else {
		gtk_widget_set_sensitive (chooser->details->move_up_button,
					  FALSE);
		gtk_widget_set_sensitive (chooser->details->move_down_button,
					  FALSE);
	}
}

static void
list_changed (NemoColumnChooser *chooser) 
{
	update_buttons (chooser);
	g_signal_emit (chooser, signals[CHANGED], 0);
}

static void
visible_toggled_callback (GtkCellRendererToggle *cell, 
			  char *path_string,
			  gpointer user_data)
{
	NemoColumnChooser *chooser;
	GtkTreePath *path;
	GtkTreeIter iter;
	gboolean visible;
	
	chooser = NEMO_COLUMN_CHOOSER (user_data);

	path = gtk_tree_path_new_from_string (path_string);
	gtk_tree_model_get_iter (GTK_TREE_MODEL (chooser->details->store), 
				 &iter, path);
	gtk_tree_model_get (GTK_TREE_MODEL (chooser->details->store),
			    &iter, COLUMN_VISIBLE, &visible, -1);
	gtk_list_store_set (chooser->details->store,
			    &iter, COLUMN_VISIBLE, !visible, -1);
	gtk_tree_path_free (path);
	list_changed (chooser);
}

static void
selection_changed_callback (GtkTreeSelection *selection, gpointer user_data)
{
	update_buttons (NEMO_COLUMN_CHOOSER (user_data));
}

static void
row_deleted_callback (GtkTreeModel *model, 
		       GtkTreePath *path,
		       gpointer user_data)
{
	list_changed (NEMO_COLUMN_CHOOSER (user_data));
}

static void
add_tree_view (NemoColumnChooser *chooser)
{
	GtkWidget *scrolled;
	GtkWidget *view;
	GtkListStore *store;
	GtkCellRenderer *cell;
	GtkTreeSelection *selection;
	
	view = gtk_tree_view_new ();
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
	
	store = gtk_list_store_new (NUM_COLUMNS,
				    G_TYPE_BOOLEAN,
				    G_TYPE_STRING,
				    G_TYPE_STRING,
                    G_TYPE_BOOLEAN);

	gtk_tree_view_set_model (GTK_TREE_VIEW (view), 
				 GTK_TREE_MODEL (store));
	g_object_unref (store);

	gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
	
	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
	g_signal_connect (selection, "changed", 
			  G_CALLBACK (selection_changed_callback), chooser);

	cell = gtk_cell_renderer_toggle_new ();
	
	g_signal_connect (G_OBJECT (cell), "toggled",
			  G_CALLBACK (visible_toggled_callback), chooser);

	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
						     -1, NULL,
						     cell, 
						     "active", COLUMN_VISIBLE,
                             "sensitive", COLUMN_TOGGLE_SENSITIVE,
						     NULL);

	cell = gtk_cell_renderer_text_new ();

	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),
						     -1, NULL,
						     cell, 
						     "text", COLUMN_LABEL,
						     NULL);

	chooser->details->view = GTK_TREE_VIEW (view);
	chooser->details->store = store;

	gtk_widget_show (view);

	scrolled = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
					     GTK_SHADOW_IN);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
					GTK_POLICY_AUTOMATIC,
					GTK_POLICY_AUTOMATIC);
	gtk_widget_show (GTK_WIDGET (scrolled));
	
	gtk_container_add (GTK_CONTAINER (scrolled), view);
	gtk_box_pack_start (GTK_BOX (chooser), scrolled, TRUE, TRUE, 0);
}

static void
move_up_clicked_callback (GtkWidget *button, gpointer user_data)
{
	NemoColumnChooser *chooser;
	GtkTreeIter iter;
	GtkTreeSelection *selection;

	chooser = NEMO_COLUMN_CHOOSER (user_data);
	
	selection = gtk_tree_view_get_selection (chooser->details->view);
	
	if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
		GtkTreePath *path;
		GtkTreeIter prev;

		path = gtk_tree_model_get_path (GTK_TREE_MODEL (chooser->details->store), &iter);
		gtk_tree_path_prev (path);
		if (gtk_tree_model_get_iter (GTK_TREE_MODEL (chooser->details->store), &prev, path)) {
			gtk_list_store_move_before (chooser->details->store,
						   &iter,
						   &prev);
		}
		gtk_tree_path_free (path);
	}

	list_changed (chooser);
}

static void
move_down_clicked_callback (GtkWidget *button, gpointer user_data)
{
	NemoColumnChooser *chooser;
	GtkTreeIter iter;
	GtkTreeSelection *selection;

	chooser = NEMO_COLUMN_CHOOSER (user_data);
	
	selection = gtk_tree_view_get_selection (chooser->details->view);
	
	if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
		GtkTreeIter next;

		next = iter;
		
		if (gtk_tree_model_iter_next (GTK_TREE_MODEL (chooser->details->store), &next)) {
			gtk_list_store_move_after (chooser->details->store,
						   &iter,
						   &next);
		}
	}

	list_changed (chooser);
}

static void
use_default_clicked_callback (GtkWidget *button, gpointer user_data)
{
	g_signal_emit (NEMO_COLUMN_CHOOSER (user_data), 
		       signals[USE_DEFAULT], 0);
}

static GtkWidget *
button_new_with_mnemonic (const gchar *stockid, const gchar *str)
{
	GtkWidget *image;
	GtkWidget *button;
	
	button = gtk_button_new_with_mnemonic (str);
	image = gtk_image_new_from_stock (stockid, GTK_ICON_SIZE_BUTTON);
	
	gtk_button_set_image (GTK_BUTTON (button), image);

	return button;
}

static void
add_buttons (NemoColumnChooser *chooser)
{
	GtkWidget *box;
	GtkWidget *separator;
	
	box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
	gtk_widget_show (box);
	
	chooser->details->move_up_button = button_new_with_mnemonic (GTK_STOCK_GO_UP,
								     _("Move _Up"));
	g_signal_connect (chooser->details->move_up_button, 
			  "clicked",  G_CALLBACK (move_up_clicked_callback),
			  chooser);
	gtk_widget_show_all (chooser->details->move_up_button);
	gtk_widget_set_sensitive (chooser->details->move_up_button, FALSE);
	gtk_box_pack_start (GTK_BOX (box), chooser->details->move_up_button,
			    FALSE, FALSE, 0);

	chooser->details->move_down_button = button_new_with_mnemonic (GTK_STOCK_GO_DOWN,
								       _("Move Dow_n"));
	g_signal_connect (chooser->details->move_down_button, 
			  "clicked",  G_CALLBACK (move_down_clicked_callback),
			  chooser);
	gtk_widget_show_all (chooser->details->move_down_button);
	gtk_widget_set_sensitive (chooser->details->move_down_button, FALSE);
	gtk_box_pack_start (GTK_BOX (box), chooser->details->move_down_button,
			    FALSE, FALSE, 0);

	separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_widget_show (separator);
	gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, 0);	

	chooser->details->use_default_button = gtk_button_new_with_mnemonic (_("Use De_fault"));
	g_signal_connect (chooser->details->use_default_button, 
			  "clicked",  G_CALLBACK (use_default_clicked_callback),
			  chooser);
	gtk_widget_show (chooser->details->use_default_button);
	gtk_box_pack_start (GTK_BOX (box), chooser->details->use_default_button,
			    FALSE, FALSE, 0);

	gtk_box_pack_start (GTK_BOX (chooser), box,
			    FALSE, FALSE, 0);
}

static void
populate_tree (NemoColumnChooser *chooser)
{
	GList *columns;
	GList *l;

	columns = nemo_get_columns_for_file (chooser->details->file);

	for (l = columns; l != NULL; l = l->next) {
		GtkTreeIter iter;
		NemoColumn *column;
		char *name;
		char *label;
		
		column = NEMO_COLUMN (l->data);
		
		g_object_get (G_OBJECT (column), 
			      "name", &name, "label", &label, 
			      NULL);

		gtk_list_store_append (chooser->details->store, &iter);
		gtk_list_store_set (chooser->details->store, &iter,
				    COLUMN_VISIBLE, FALSE,
				    COLUMN_LABEL, label,
				    COLUMN_NAME, name,
                    COLUMN_TOGGLE_SENSITIVE, g_strcmp0 (name, "name") != 0,
				    -1);

		g_free (name);
		g_free (label);
	}

	nemo_column_list_free (columns);
}

static void
nemo_column_chooser_constructed (GObject *object)
{
	NemoColumnChooser *chooser;

	chooser = NEMO_COLUMN_CHOOSER (object);

	populate_tree (chooser);

	g_signal_connect (chooser->details->store, "row_deleted", 
			  G_CALLBACK (row_deleted_callback), chooser);
}

static void
nemo_column_chooser_init (NemoColumnChooser *chooser)
{	
	chooser->details = G_TYPE_INSTANCE_GET_PRIVATE ((chooser), NEMO_TYPE_COLUMN_CHOOSER, NemoColumnChooserDetails);

	g_object_set (G_OBJECT (chooser), 
		      "homogeneous", FALSE,
		      "spacing", 8,
		      "orientation", GTK_ORIENTATION_HORIZONTAL,
		      NULL);

	add_tree_view (chooser);
	add_buttons (chooser);
}

static void 
set_visible_columns (NemoColumnChooser *chooser,
		     char **visible_columns)
{
	GHashTable *visible_columns_hash;
	GtkTreeIter iter;
	int i;

	visible_columns_hash = g_hash_table_new (g_str_hash, g_str_equal);
	for (i = 0; visible_columns[i] != NULL; ++i) {
		g_hash_table_insert (visible_columns_hash,
				     visible_columns[i],
				     visible_columns[i]);
	}

	if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (chooser->details->store),
					   &iter)) {
		do {
			char *name;
			gboolean visible;			
			
			gtk_tree_model_get (GTK_TREE_MODEL (chooser->details->store),
					    &iter,
					    COLUMN_NAME, &name,
					    -1);

			visible = (g_hash_table_lookup (visible_columns_hash, name) != NULL);

			gtk_list_store_set (chooser->details->store,
					    &iter,
					    COLUMN_VISIBLE, visible,
					    -1);
			g_free (name);
			
		} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (chooser->details->store), &iter));
	}

	g_hash_table_destroy (visible_columns_hash);
}

static char **
get_column_names (NemoColumnChooser *chooser, gboolean only_visible)
{
	GPtrArray *ret;
	GtkTreeIter iter;

	ret = g_ptr_array_new ();
	if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (chooser->details->store),
					   &iter)) {
		do {
			char *name;
			gboolean visible;
			gtk_tree_model_get (GTK_TREE_MODEL (chooser->details->store),
					    &iter,
					    COLUMN_VISIBLE, &visible,
					    COLUMN_NAME, &name,
					    -1);
			if (!only_visible || visible) {
				/* give ownership to the array */
				g_ptr_array_add (ret, name);
			}

		} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (chooser->details->store), &iter));
	}
	g_ptr_array_add (ret, NULL);

	return (char **) g_ptr_array_free (ret, FALSE);
}

static gboolean
get_column_iter (NemoColumnChooser *chooser, 
		 NemoColumn *column,
		 GtkTreeIter *iter)
{
	char *column_name;

	g_object_get (NEMO_COLUMN (column), "name", &column_name, NULL);

	if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (chooser->details->store),
					   iter)) {
		do {
			char *name;

			
			gtk_tree_model_get (GTK_TREE_MODEL (chooser->details->store),
					    iter,
					    COLUMN_NAME, &name,
					    -1);
			if (!strcmp (name, column_name)) {
				g_free (column_name);
				g_free (name);
				return TRUE;
			}

			g_free (name);
		} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (chooser->details->store), iter));
	}
	g_free (column_name);
	return FALSE;
}

static void
set_column_order (NemoColumnChooser *chooser,
		  char **column_order)

{
	GList *columns;
	GList *l;
	GtkTreePath *path;

	columns = nemo_get_columns_for_file (chooser->details->file);	
	columns = nemo_sort_columns (columns, column_order);

	g_signal_handlers_block_by_func (chooser->details->store,
					 G_CALLBACK (row_deleted_callback), 
					 chooser);

	path = gtk_tree_path_new_first ();
	for (l = columns; l != NULL; l = l->next) {
		GtkTreeIter iter;
		
		if (get_column_iter (chooser, NEMO_COLUMN (l->data), &iter)) {
			GtkTreeIter before;
			if (path) {
				gtk_tree_model_get_iter (GTK_TREE_MODEL (chooser->details->store),
							 &before, path);
				gtk_list_store_move_after (chooser->details->store,
							   &iter, &before);
				gtk_tree_path_next (path);
				
			} else {		
				gtk_list_store_move_after (chooser->details->store,
							   &iter, NULL);
			}
		}
	}
	gtk_tree_path_free (path);
	g_signal_handlers_unblock_by_func (chooser->details->store, 
					   G_CALLBACK (row_deleted_callback), 
					   chooser);
	
	nemo_column_list_free (columns);
}

void
nemo_column_chooser_set_settings (NemoColumnChooser *chooser,
				      char **visible_columns,
				      char **column_order)
{
	g_return_if_fail (NEMO_IS_COLUMN_CHOOSER (chooser));
	g_return_if_fail (visible_columns != NULL);
	g_return_if_fail (column_order != NULL);

	set_visible_columns (chooser, visible_columns);
	set_column_order (chooser, column_order);

	list_changed (chooser);
}

void
nemo_column_chooser_get_settings (NemoColumnChooser *chooser,
				      char ***visible_columns,
				      char ***column_order)
{
	g_return_if_fail (NEMO_IS_COLUMN_CHOOSER (chooser));
	g_return_if_fail (visible_columns != NULL);
	g_return_if_fail (column_order != NULL);

	*visible_columns = get_column_names (chooser, TRUE);
	*column_order = get_column_names (chooser, FALSE);
}

GtkWidget *
nemo_column_chooser_new (NemoFile *file)
{
	return g_object_new (NEMO_TYPE_COLUMN_CHOOSER, "file", file, NULL);
}

