/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * Copyright (C) 2001 CodeFactory AB
 * Copyright (C) 2001 Mikael Hallendal <micke@codefactory.se>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author: Mikael Hallendal <micke@codefactory.se>
 *
 * Celltype for drawing a spinbutton in a cell. 
 *
 * Used ECellPopup by Damon Chaplin <damon@ximian.com> as base for 
 * buttondrawings.
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gtk/gtksignal.h>
#include <gal/e-table/e-table-item.h>
#include <gal/e-table/e-table-model.h>
#include <gal/e-table/e-cell-float.h>
#include <gal/e-table/e-cell-number.h>
#include <gal/util/e-util.h>
#include "e-cell-spin-button.h"

#define E_CELL_SPIN_BUTTON_ARROW_WIDTH  16
#define PARENT_TYPE e_cell_get_type ()

static void e_cell_spin_button_class_init   (GtkObjectClass   *klass);
static void e_cell_spin_button_init         (GtkObject        *object);

static void         ecsb_destroy      (GtkObject	*object);

/* ECell Functions */
static ECellView *  ecsb_new_view     (ECell                 *ecell,
				       ETableModel           *etm,
				       void                  *eti_view);
static void         ecsb_realize      (ECellView             *ecv);
static void         ecsb_kill_view    (ECellView             *ecv);
static void         ecsb_unrealize    (ECellView             *ecv);
static void         ecsb_draw         (ECellView             *ecv, 
				       GdkDrawable           *drawable, 
				       int                    model_col, 
				       int                    view_col, 
				       int                    row, 
				       ECellFlags             flags, 
				       int                    x1, 
				       int                    y1, 
				       int                    x2, 
				       int                    y2); 

static gint         ecsb_event        (ECellView             *ecv, 
				       GdkEvent              *event, 
				       int                    model_col, 
				       int                    view_col, 
				       int                    row,
				       ECellFlags             flags, 
				       ECellActions          *actions); 

static gint         ecsb_height       (ECellView             *ecv,
				       int                    model_col,
				       int                    view_col,
				       int                    row);

static void *       ecsb_enter_edit   (ECellView             *ecv,
				       int                    model_col, 
				       int                    view_col, 
				       int                    row);

static void         ecsb_leave_edit   (ECellView             *ecv,
				       int                    model_col, 
				       int                    view_col, 
				       int                    row, 
				       void                  *context);
static void         ecsb_focus        (ECellView             *ecell_view,
				       int                    model_col,
				       int                    view_col,
				       int                    row,
				       int                    x1,
				       int                    y1,
				       int                    x2,
				       int                    y2);
static void         ecsb_unfocus      (ECellView             *ecell_view);

static void         ecsb_show_tooltip (ECellView             *ecv,
				       int                    model_col, 
				       int                    view_col, 
				       int                    row, 
				       int                    col_width, 
				       ETableTooltip          *tooltip);

typedef struct {
	ECellView    cell_view;
	
	ECellView   *child_view;
} ECellSpinButtonView;

enum {
	STEP,
	LAST_SIGNAL
};

static gint     signals[LAST_SIGNAL] = { 0 };
static ECell   *parent_class;

static void 
e_cell_spin_button_class_init     (GtkObjectClass   *klass)
{
        ECellClass             *ecc    = (ECellClass *) klass;  
	ECellSpinButtonClass   *ecsbc  = (ECellSpinButtonClass *) klass;
        
        klass->destroy     = ecsb_destroy;

	ecc->realize       = ecsb_realize;
	ecc->unrealize     = ecsb_unrealize;
	ecc->new_view      = ecsb_new_view;
	ecc->kill_view     = ecsb_kill_view;
	ecc->draw          = ecsb_draw;
	ecc->event         = ecsb_event;
	ecc->height        = ecsb_height;
	ecc->enter_edit    = ecsb_enter_edit;
	ecc->leave_edit    = ecsb_leave_edit;
	ecc->focus         = ecsb_focus;
	ecc->unfocus       = ecsb_unfocus;	ecc->print         = NULL;
	ecc->print_height  = NULL;
	ecc->max_width     = NULL;
	ecc->show_tooltip  = ecsb_show_tooltip;

	ecsbc->step        = NULL;

        parent_class       = gtk_type_class (E_CELL_TYPE);

	signals[STEP] =
		gtk_signal_new ("step",
				GTK_RUN_LAST,
				klass->type,
				GTK_SIGNAL_OFFSET (ECellSpinButtonClass, step),
				e_marshal_NONE__POINTER_INT_INT_INT,
				GTK_TYPE_NONE,
				4, GTK_TYPE_POINTER, GTK_TYPE_INT, 
				GTK_TYPE_INT, GTK_TYPE_INT);
	
	gtk_object_class_add_signals (klass, signals, LAST_SIGNAL);
}

static void 
e_cell_spin_button_init           (GtkObject        *object)
{
        ECellSpinButton   *ecsb;
	
	g_return_if_fail (object != NULL);
	g_return_if_fail (M_IS_CELL_SPIN_BUTTON (object));
	
	ecsb = E_CELL_SPIN_BUTTON (object);

	ecsb->up_pressed    = FALSE;
	ecsb->down_pressed  = FALSE;
}

static ECellView *  
ecsb_new_view     (ECell            *ecell,
		   ETableModel      *etm,
		   void             *eti_view)
{
	ECellSpinButton       *ecsb = E_CELL_SPIN_BUTTON (ecell);
	ECellSpinButtonView   *ecsb_view;

	g_return_val_if_fail (ecsb->child != NULL, NULL);

	ecsb_view = g_new0 (ECellSpinButtonView, 1);

	ecsb_view->cell_view.ecell = ecell;
	ecsb_view->cell_view.e_table_model = etm;
	ecsb_view->cell_view.e_table_item_view = eti_view;

	ecsb_view->child_view = e_cell_new_view (ecsb->child, etm, eti_view);

	return (ECellView *) ecsb_view;
}

static void         
ecsb_realize      (ECellView        *ecv)
{ 
	ECellSpinButtonView   *ecsb_view;
	
	g_return_if_fail (ecv != NULL);

	ecsb_view = (ECellSpinButtonView *) ecv;

	e_cell_realize (ecsb_view->child_view);
} 

static void         
ecsb_kill_view    (ECellView        *ecv)
{
	ECellSpinButtonView   *ecsb_view;
	
	g_return_if_fail (ecv != NULL);

	ecsb_view = (ECellSpinButtonView *) ecv;

	if (ecsb_view->child_view) {
		e_cell_kill_view (ecsb_view->child_view);
	}
	
	g_free (ecsb_view);
}

static void         
ecsb_unrealize    (ECellView        *ecv)
{ 
	ECellSpinButtonView   *ecsb_view;
	
	g_return_if_fail (ecv != NULL);

	ecsb_view = (ECellSpinButtonView *) ecv;

	e_cell_unrealize (ecsb_view->child_view);
}

static void         
ecsb_draw         (ECellView        *ecv, 
		   GdkDrawable      *drawable, 
		   int               model_col, 
		   int               view_col, 
		   int               row, 
		   ECellFlags        flags, 
		   int               x1, 
		   int               y1, 
		   int               x2, 
		   int               y2)
{
	ECellSpinButton        *ecsb;
	ECellSpinButtonView    *ecsb_view;
	ETableItem             *eti;
	GtkWidget              *canvas;
	GtkShadowType           shadow = GTK_SHADOW_OUT;
	GdkRectangle            rect;
	
	g_return_if_fail (ecv != NULL);
	
	ecsb_view   = (ECellSpinButtonView *) ecv;
	ecsb        = E_CELL_SPIN_BUTTON (ecsb_view->cell_view.ecell);
	
	eti         = E_TABLE_ITEM (ecsb_view->cell_view.e_table_item_view);
	canvas      = GTK_WIDGET (GNOME_CANVAS_ITEM (eti)->canvas);
	
	if (eti->editing_col == view_col && 
	    eti->editing_row == row) {

		/* Draw child (Whats shown under the buttons) */
		e_cell_draw (ecsb_view->child_view, 
			     drawable, model_col, view_col,
			     row, flags, 
			     x1, y1, 
			     x2 - E_CELL_SPIN_BUTTON_ARROW_WIDTH, y2); 

		/* Draw down-arrow */
		rect.x       = x2 - E_CELL_SPIN_BUTTON_ARROW_WIDTH;
		rect.y       = y1 + (y2 - y1) / 2;
		rect.width   = E_CELL_SPIN_BUTTON_ARROW_WIDTH;
		rect.height  = (y2 - y1) / 2;
		
		if (ecsb->down_pressed) {
			shadow = GTK_SHADOW_IN;
		} else {
			shadow = GTK_SHADOW_OUT;
		}
		
		gtk_paint_box (canvas->style, drawable, 
			       GTK_STATE_NORMAL, shadow,
			       &rect, canvas, "ecellspinbutton_down",
			       rect.x, rect.y, rect.width, rect.height);

		gtk_paint_arrow (canvas->style, drawable,
				 GTK_STATE_NORMAL, shadow,
				 &rect, canvas, NULL,
				 GTK_ARROW_DOWN, TRUE,
				 rect.x,
				 rect.y,
				 rect.width,
				 rect.height);

		/* Draw up-arrow */
		rect.y       = y1;
		
		if (ecsb->up_pressed) {
			shadow = GTK_SHADOW_IN;
		} else {
			shadow = GTK_SHADOW_OUT;
		}

		gtk_paint_box (canvas->style, drawable, 
			       GTK_STATE_NORMAL, shadow,
			       &rect, canvas, "ecellspinbutton_up",
			       rect.x, rect.y, rect.width, rect.height);

		gtk_paint_arrow (canvas->style, drawable,
				 GTK_STATE_NORMAL, shadow,
				 &rect, canvas, NULL,
				 GTK_ARROW_UP, TRUE,
				 rect.x,
				 rect.y,
				 rect.width,
				 rect.height);
	} else {
		/* Draw child */
		e_cell_draw (ecsb_view->child_view, 
			     drawable, model_col, view_col,
			     row, flags, 
			     x1, y1, 
			     x2, y2); 
	}
}

static gint         
ecsb_event        (ECellView        *ecv, 
		   GdkEvent         *event, 
		   int               model_col, 
		   int               view_col, 
		   int               row,
		   ECellFlags        flags, 
		   ECellActions     *actions)
{
	ECellSpinButton       *ecsb;
	ECellSpinButtonClass  *ecsb_class;
	ECellSpinButtonView   *ecsb_view;
	ETableItem            *eti;
	gint                   height, width;
	
	g_return_val_if_fail (ecv != NULL, FALSE);
		
	ecsb_view   = (ECellSpinButtonView *) ecv;
	ecsb        = E_CELL_SPIN_BUTTON (ecsb_view->cell_view.ecell);
	ecsb_class  = E_CELL_SPIN_BUTTON_CLASS (GTK_OBJECT(ecsb)->klass);
	eti         = E_TABLE_ITEM (ecsb_view->cell_view.e_table_item_view);
	
	switch (event->type) {
	case GDK_BUTTON_PRESS:
		if (eti->editing_col == view_col &&
		    eti->editing_row == row) {
			width = e_table_header_col_diff (eti->header,
							 view_col,
							 view_col + 1);
			height = e_table_item_row_diff (eti, row, row + 1);

			/* Check if inside a button */
			if (event->button.x >= width - E_CELL_SPIN_BUTTON_ARROW_WIDTH) {
				/* Yep, which one? */
				if (event->button.y <= height / 2) {
					ecsb->up_pressed = TRUE;
					gtk_signal_emit (GTK_OBJECT(ecsb),
							 signals[STEP],
							 ecv,
							 STEP_UP,
							 view_col,
							 row);
				} else {
					ecsb->down_pressed = TRUE;
					gtk_signal_emit (GTK_OBJECT(ecsb),
							 signals[STEP],
							 ecv,
							 STEP_DOWN,
							 view_col,
							 row);
				}

				e_table_item_redraw_range (eti,
							   view_col,
							   row,
							   view_col,
							   row);
				
			}
		} 
		
		break;
	case GDK_BUTTON_RELEASE:
		ecsb->up_pressed = FALSE;
		ecsb->down_pressed = FALSE;
		e_table_item_redraw_range (eti,
					   view_col,
					   row,
					   view_col,
					   row);
		break;
	case GDK_KEY_PRESS:
		break;
	default:
		break;
	}

	return e_cell_event (ecsb_view->child_view, event, model_col,
			     view_col, row, flags, actions);
}

static gint         
ecsb_height       (ECellView        *ecv,
		   int               model_col,
		   int               view_col,
		   int               row)
{
	ECellSpinButtonView   *ecsb_view;
	
	g_return_val_if_fail (ecv != NULL, -1);
	
	ecsb_view = (ECellSpinButtonView *) ecv;

	return e_cell_height (ecsb_view->child_view, model_col, view_col, row);
}

static void *       
ecsb_enter_edit   (ECellView        *ecv,
		   int               model_col, 
		   int               view_col, 
		   int               row)
{
	ECellSpinButtonView   *ecsb_view;
	
	g_return_val_if_fail (ecv != NULL, NULL);

	ecsb_view = (ECellSpinButtonView *) ecv;

	return e_cell_enter_edit (ecsb_view->child_view, model_col,
				  view_col, row);
}


static void         
ecsb_leave_edit   (ECellView        *ecv,
		   int               model_col, 
		   int               view_col, 
		   int               row, 
		   void             *context)
{
	ECellSpinButtonView   *ecsb_view;
	
	g_return_if_fail (ecv != NULL);
	
	ecsb_view = (ECellSpinButtonView *) ecv;

	e_cell_leave_edit (ecsb_view->child_view, model_col, view_col, 
			   row, context);
}

static void
ecsb_focus        (ECellView        *ecell_view,
		   int               model_col,
		   int               view_col,
		   int               row,
		   int		     x1,
		   int		     y1,
		   int		     x2,
		   int		     y2)
{
	ECellClass  *klass;
	ECellSpinButtonView   *ecsb_view;
	
	ecsb_view = (ECellSpinButtonView *) ecell_view;

	klass = E_CELL_CLASS (GTK_OBJECT (ecell_view->ecell)->klass);

	if (klass->focus) {
		klass->focus (ecell_view, model_col, view_col, row, 
			      x1, y1, x2, y2);
	}
}

static void
ecsb_unfocus      (ECellView        *ecell_view)
{
	ECellClass  *klass;
	ECellSpinButtonView   *ecsb_view;
	
	ecsb_view = (ECellSpinButtonView *) ecell_view;
	klass = E_CELL_CLASS (GTK_OBJECT (ecell_view->ecell)->klass);

	if (klass->unfocus) {
		klass->unfocus (ecell_view);
	}
	
}

static void         
ecsb_show_tooltip (ECellView        *ecv,
		   int               model_col, 
		   int               view_col, 
		   int               row, 
		   int               col_width, 
		   ETableTooltip    *tooltip)
{
	ECellSpinButtonView   *ecsb_view;
	
	g_return_if_fail (ecv != NULL);

	ecsb_view = (ECellSpinButtonView *) ecv;
	
	e_cell_show_tooltip (ecsb_view->child_view, model_col, view_col, 
			     row, col_width, tooltip);
}

static void 
ecsb_destroy        (GtkObject	*object)
{
	ECellSpinButton *mcsp;

	g_return_if_fail (object != NULL);
	g_return_if_fail (M_IS_CELL_SPIN_BUTTON (object));
	
	mcsp = E_CELL_SPIN_BUTTON (object);
	
	GTK_OBJECT_CLASS (parent_class)->destroy (object);
}

ECell *
e_cell_spin_button_new (gint     min,
			gint     max,
			gint     step,
			ECell   *child_cell)
{
	ECellSpinButton   *ecsb;
	
	ecsb = gtk_type_new (E_CELL_SPIN_BUTTON_TYPE);

	if (!child_cell) {
		child_cell = e_cell_number_new (NULL, 
						GTK_JUSTIFY_LEFT);
		
		gtk_signal_connect (GTK_OBJECT (ecsb), "step",
				    e_cell_spin_button_step, 
				    NULL);
	}
	
	ecsb->child   = child_cell;
	ecsb->min.i   = min;
	ecsb->max.i   = max;
	ecsb->step.i  = step;

	return E_CELL (ecsb);
}

ECell *
e_cell_spin_button_new_float (gfloat    min,
			      gfloat    max,
			      gfloat    step,
			      ECell    *child_cell)
{
	ECellSpinButton   *ecsb;
	
	ecsb = gtk_type_new (E_CELL_SPIN_BUTTON_TYPE);

	if (!child_cell) {
		child_cell = e_cell_float_new (NULL, GTK_JUSTIFY_LEFT);
		gtk_signal_connect (GTK_OBJECT (ecsb), "step",
				    e_cell_spin_button_step_float, 
				    NULL);
	}
	
	ecsb->child   = child_cell;
	ecsb->min.f   = min;
	ecsb->max.f   = max;
	ecsb->step.f  = step;

	return E_CELL (ecsb);
}

void
e_cell_spin_button_step   (ECellSpinButton       *ecsb,
			   ECellView             *ecv,
			   ECellSpinButtonStep    direction,
			   gint                   col,
			   gint                   row)
{
 	ECellSpinButtonView   *ecsb_view; 
	
	ETableModel           *etm;
	gint                   value;
	gint                   new_value;
	
	g_return_if_fail (ecsb != NULL);
	g_return_if_fail (M_IS_CELL_SPIN_BUTTON (ecsb));
	g_return_if_fail (ecv != NULL);
	
 	ecsb_view  = (ECellSpinButtonView *) ecv; 
	etm        = ecsb_view->cell_view.e_table_model;
	
	value  = GPOINTER_TO_INT (e_table_model_value_at (etm, col, row));
	new_value = value;
	
	switch (direction) {
	case STEP_UP:
		new_value = CLAMP (value + ecsb->step.i, 
				   ecsb->min.i, ecsb->max.i);
		break;
	case STEP_DOWN:
		new_value = CLAMP (value - ecsb->step.i, 
				   ecsb->min.i, ecsb->max.i);
		break;
	default:
		break;
	};

	e_table_model_set_value_at (etm, col, row, GINT_TO_POINTER(new_value));
}

void
e_cell_spin_button_step_float  (ECellSpinButton       *ecsb,
				ECellView             *ecv,
				ECellSpinButtonStep    direction,
				gint                   col,
				gint                   row)
{
 	ECellSpinButtonView   *ecsb_view; 
	
	ETableModel           *etm;
	gfloat                 value;
	gfloat                 new_value;
	
	g_return_if_fail (ecsb != NULL);
	g_return_if_fail (M_IS_CELL_SPIN_BUTTON (ecsb));
	g_return_if_fail (ecv != NULL);
	
 	ecsb_view  = (ECellSpinButtonView *) ecv; 
	etm        = ecsb_view->cell_view.e_table_model;
	
	value  = *(gfloat *) e_table_model_value_at (etm, col, row);

	switch (direction) {
	case STEP_UP:
		new_value = CLAMP (value + ecsb->step.f, 
				   ecsb->min.f, ecsb->max.f);
		break;
	case STEP_DOWN:
		new_value = CLAMP (value - ecsb->step.f, 
				   ecsb->min.f, ecsb->max.f);
		break;
	default:
		break;
	};

	e_table_model_set_value_at (etm, col, row, &new_value);
}

E_MAKE_TYPE (e_cell_spin_button, "ECellSpinButton", ECellSpinButton, 
	     e_cell_spin_button_class_init, e_cell_spin_button_init, 
	     PARENT_TYPE);