/** \file button.c
 * Toolbar button creation and handling
 */

/*  XTrkCad - Model Railroad CAD
 *  Copyright (C) 2005 Dave Bullis
 *
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <stdlib.h>

#define GTK_DISABLE_SINGLE_INCLUDES
#define GDK_DISABLE_DEPRECATED
#define GTK_DISABLE_DEPRECATED
#define GSEAL_ENABLE

#include <gtk/gtk.h>
#include <gdk/gdk.h>

#include "gtkint.h"
#include "i18n.h"
#include "assert.h"

#define MIN_BUTTON_WIDTH (80)

/*
 *****************************************************************************
 *
 * Simple Buttons
 *
 *****************************************************************************
 */

/**
 * Set the state of the button
 *
 * \param bb IN the button
 * \param value IN TRUE for active, FALSE for inactive
 */

void wButtonSetBusy(wButton_p bb, int value)
{
	bb->recursion++;
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bb->widget), value);
	bb->recursion--;
	bb->busy = value;
	if (!value) {
		if (bb->timer_id) {
			g_source_remove(bb->timer_id);
			bb->timer_id = 0;
		}
		bb->timer_state = -1;
	}
}

/**
 * Set the label of a button, does also allow to set an icon
 *
 * \param widget IN
 * \param option IN
 * \param labelStr IN
 * \param labelG IN
 * \param imageG IN
 */

void wlibSetLabel(
        GtkWidget *widget,
        long option,
        const char * labelStr,
        GtkLabel * * labelG,
        GtkWidget * * imageG)
{
	wIcon_p bm;
//    GdkBitmap * mask;

	if (widget == 0) {
		abort();
	}

	if (labelStr) {
		if (option&BO_ICON) {
			GdkPixbuf *pixbuf;

			bm = (wIcon_p)labelStr;

			if (bm->gtkIconType == gtkIcon_pixmap) {
				// check gdk_pixbuf header 
				assert ( *(int*)bm->bits == 0x47646b50 ||
				     *(int*)bm->bits == 0x506b6447 );
				pixbuf = gdk_pixbuf_new_from_inline( -1, bm->bits, FALSE, NULL );
				
			} else {
				pixbuf = wlibPixbufFromXBM( bm );
			}
			double scaleicon;
			wPrefGetFloat(PREFSECTION, LARGEICON, &scaleicon, 1.0);
			if (scaleicon<1.0) { scaleicon=1.0; }
			if (scaleicon>2.0) { scaleicon=2.0; }
			GdkPixbuf *pixbuf2 =
			        gdk_pixbuf_scale_simple(pixbuf, gdk_pixbuf_get_width(pixbuf)*scaleicon,
			                                gdk_pixbuf_get_height(pixbuf)*scaleicon, GDK_INTERP_BILINEAR);
			g_object_ref_sink(pixbuf);
			g_object_unref((gpointer)pixbuf);
			if (*imageG==NULL) {
				*imageG = gtk_image_new_from_pixbuf(pixbuf2);
				gtk_container_add(GTK_CONTAINER(widget), *imageG);
				gtk_widget_show(*imageG);
			} else {
				gtk_image_set_from_pixbuf(GTK_IMAGE(*imageG), pixbuf2);
			}
			g_object_ref_sink(pixbuf2);
			g_object_unref((gpointer)pixbuf2);
		} else {
			if (*labelG==NULL) {
				*labelG = (GtkLabel*)gtk_label_new(wlibConvertInput(labelStr));
				gtk_container_add(GTK_CONTAINER(widget), (GtkWidget*)*labelG);
				gtk_widget_show((GtkWidget*)*labelG);
			} else {
				gtk_label_set_text(*labelG, wlibConvertInput(labelStr));
			}
		}
	}
}

/**
 * Change only the text label of a button
 * \param bb IN button handle
 * \param labelStr IN new label string
 */

void wButtonSetLabel(wButton_p bb, const char * labelStr)
{
	wlibSetLabel(bb->widget, bb->option, labelStr, &bb->labelG, &bb->imageG);
}

/**
 * Perform the user callback function
 *
 * \param bb IN button handle
 */

void wlibButtonDoAction(
        wButton_p bb)
{
	if (bb->action) {
		bb->action(bb->data);
	}
}


/**
 * Signal handler for button push
 * \param widget IN the widget or NULL for autorepeat
 * \param value IN the button handle (same as widget???)
 */

static void pushButt(
        GtkWidget *widget,
        gpointer value)
{
	wButton_p b = (wButton_p)value;

	if (debugWindow >= 2) {
		printf("%s button pushed\n", b->labelStr?b->labelStr:"No label");
	}

	if (b->recursion) {
		return;
	}

	wlibStringUpdate();
	if (b->action) {
		b->action(b->data);
	}


}

#define REPEAT_STAGE0_DELAY 500
#define REPEAT_STAGE1_DELAY 150
#define REPEAT_STAGE2_DELAY 100

/* Timer callback function! */
static int timer_func ( void * data)
{
	wButton_p bb = (wButton_p)data;
	if (bb->timer_id == 0) {
		bb->timer_state = -1;
		return FALSE;
	}
	/* Autorepeat state machine */
	switch (bb->timer_state) {
	case 0: /* Enable slow auto-repeat */
		g_source_remove(bb->timer_id);
		bb->timer_id = 0;
		bb->timer_state = 1;
		bb->timer_id = g_timeout_add( REPEAT_STAGE1_DELAY, timer_func, bb);
		bb->timer_count = 0;
		break;
	case 1: /* Check if it's time for fast repeat yet */
		if (bb->timer_count++ > 10) {
			bb->timer_state = 2;
		}
		break;
	case 2: /* Start fast auto-repeat */
		g_source_remove(bb->timer_id);
		bb->timer_id = 0;
		bb->timer_state = 3;
		bb->timer_id = g_timeout_add( REPEAT_STAGE2_DELAY, timer_func, bb);
		break;
	case 3:
		break;
	default:
		g_source_remove(bb->timer_id);
		bb->timer_id = 0;
		bb->timer_state = -1;
		return FALSE;
		break;
	}

	pushButt(NULL,bb);

	return TRUE;

}

static gint pressButt(
        GtkWidget *widget,
        GdkEventButton *event,
        wButton_p bb)
{

	if ( debugWindow >= 1 ) {
		printf( "buttonPress: %s\n", bb->labelStr );
	}
	if (bb->recursion) {
		return TRUE;

	}


	if (bb->option & BO_REPEAT)  {
		/* Remove an existing timer */
		if (bb->timer_id) {
			g_source_remove(bb->timer_id);
		}

		/* Setup a timer */
		bb->timer_id = g_timeout_add( REPEAT_STAGE0_DELAY, timer_func, bb);
		bb->timer_state = 0;

	}

	if (!bb->busy) {
		bb->recursion++;
		int sensitive = gtk_widget_get_sensitive (GTK_WIDGET(bb->widget));
		if (sensitive) {
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bb->widget), TRUE);
		}
		bb->recursion--;
	}


	return TRUE;

}

static gint releaseButt(
        GtkWidget *widget,
        GdkEventButton *event,
        wButton_p bb)
{

	if ( debugWindow >= 1 ) {
		printf( "buttonRelease: %s\n", bb->labelStr );
	}
	/* Remove any existing timer */
	if (bb->timer_id) {
		g_source_remove(bb->timer_id);
		bb->timer_id = 0;
	}

	bb->timer_state = -1;

	pushButt(widget,bb);   //Do here to simulate "clicked"

	if (!bb->busy) {
		bb->recursion++;
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bb->widget), FALSE);
		bb->recursion--;
	}
	return TRUE;
}


/**
 * Called after expose event default hander - allows the button to be outlined
 */
static wBool_t exposeButt(
        GtkWidget *widget,
        GdkEventExpose *event,
        gpointer g)
{
	wControl_p b = (wControl_p)g;
	return wControlExpose(widget,event,b);
}

/**
 * Create a button
 *
 * \param parent IN parent window
 * \param x IN X-position
 * \param y IN Y-position
 * \param helpStr IN Help string
 * \param labelStr IN Label
 * \param option IN Options
 * \param width IN Width of button
 * \param action IN Callback
 * \param data IN User data as context
 * \returns button widget
 */

wButton_p wButtonCreate(
        wWin_p	parent,
        wWinPix_t	x,
        wWinPix_t	y,
        const char 	* helpStr,
        const char	* labelStr,
        long 	option,
        wWinPix_t 	width,
        wButtonCallBack_p action,
        void 	* data)
{
	wButton_p b;
	if (option&BO_ICON) { //The labelStr here is a wIcon_p
		b = wlibAlloc(parent, B_BUTTON, x, y, " ", sizeof *b, data);
	} else {
		b = wlibAlloc(parent, B_BUTTON, x, y, labelStr, sizeof *b, data);
	}
	b->option = option;
	b->action = action;
	wlibComputePos((wControl_p)b);

	b->widget = gtk_toggle_button_new();
	g_signal_connect(GTK_OBJECT(b->widget), "button_press_event",
	                 G_CALLBACK(pressButt), b);
	g_signal_connect(GTK_OBJECT(b->widget), "button_release_event",
	                 G_CALLBACK(releaseButt), b);
	//g_signal_connect(GTK_OBJECT(b->widget), "clicked",
	//                     G_CALLBACK(pushButt), b);
	g_signal_connect_after(GTK_OBJECT(b->widget), "expose-event",
	                       G_CALLBACK(exposeButt), b);
	if (width > 0) {
		gtk_widget_set_size_request(b->widget, width, -1);
	}

	if( labelStr ) {
		wButtonSetLabel(b, labelStr);
	}

	gtk_fixed_put(GTK_FIXED(parent->widget), b->widget, b->realX, b->realY);

	if (option & BB_DEFAULT) {
		gtk_widget_set_can_default(b->widget, GTK_CAN_DEFAULT);
		gtk_widget_grab_default(b->widget);
		gtk_window_set_default(GTK_WINDOW(parent->gtkwin), b->widget);
	}

	wlibControlGetSize((wControl_p)b);

	if (width == 0 && b->w < MIN_BUTTON_WIDTH && (b->option&BO_ICON)==0) {
		b->w = MIN_BUTTON_WIDTH;
		gtk_widget_set_size_request(b->widget, b->w, b->h);
	}

	gtk_widget_show(b->widget);
	wlibAddButton((wControl_p)b);
	wlibAddHelpString(b->widget, helpStr);
	return b;
}


/*
 *****************************************************************************
 *
 * Choice Boxes
 *
 *****************************************************************************
 */

struct wChoice_t {
	WOBJ_COMMON
	long *valueP;
	wChoiceCallBack_p action;
	int recursion;
};


/**
 * Get the state of a group of buttons. If the group consists of
 * radio buttons, the return value is the index of the selected button
 * or -1 for none. If toggle buttons are checked, a bit is set for each
 * button that is active.
 *
 * \param bc IN
 * \returns state of group
 */

static long choiceGetValue(
        wChoice_p bc)
{
	GList * child, * children;
	long value, inx;

	if (bc->type == B_TOGGLE) {
		value = 0;
	} else {
		value = -1;
	}

	for (children=child=gtk_container_get_children(GTK_CONTAINER(bc->widget)),inx=0;
	     child; child=child->next,inx++) {
		if (gtk_toggle_button_get_active(child->data)) {
			if (bc->type == B_TOGGLE) {
				value |= (1<<inx);
			} else {
				value = inx;
			}
		}
	}

	if (children) {
		g_list_free(children);
	}

	return value;
}

/**
 * Set the active radio button in a group
 *
 * \param bc IN button group
 * \param value IN index of active button
 */

void wRadioSetValue(
        wChoice_p bc,		/* Radio box */
        long value)		/* Value */
{
	GList * child, * children;
	long inx;

	for (children=child=gtk_container_get_children(GTK_CONTAINER(bc->widget)),inx=0;
	     child; child=child->next,inx++) {
		if (inx == value) {
			bc->recursion++;
			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(child->data), TRUE);
			bc->recursion--;
		}
	}

	if (children) {
		g_list_free(children);
	}
}

/**
 * Get the active button from a group of radio buttons
 *
 * \param bc IN
 * \returns
 */

long wRadioGetValue(
        wChoice_p bc)		/* Radio box */
{
	return choiceGetValue(bc);
}

/**
 * Set a group of toggle buttons from a bitfield
 *
 * \param bc IN button group
 * \param value IN bitfield
 */

void wToggleSetValue(
        wChoice_p bc,		/* Toggle box */
        long value)		/* Values */
{
	GList * child, * children;
	long inx;
	bc->recursion++;

	for (children=child=gtk_container_get_children(GTK_CONTAINER(bc->widget)),inx=0;
	     child; child=child->next,inx++) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(child->data),
		                             (value&(1<<inx))!=0);
	}

	if (children) {
		g_list_free(children);
	}

	bc->recursion--;
}


/**
 * Get the active buttons from a group of toggle buttons
 *
 * \param b IN
 * \returns
 */

long wToggleGetValue(
        wChoice_p b)		/* Toggle box */
{
	return choiceGetValue(b);
}

/**
 * Signal handler for button selection in radio buttons and toggle
 * button group
 *
 * \param widget IN the button group
 * \param b IN user data (button group????)
 * \returns always 1
 */

static int pushChoice(
        GtkWidget *widget,
        gpointer b)
{
	wChoice_p bc = (wChoice_p)b;
	long value = choiceGetValue(bc);

	if (debugWindow >= 2) {
		printf("%s choice pushed = %ld\n", bc->labelStr?bc->labelStr:"No label",
		       value);
	}

	if (bc->type == B_RADIO &&
	    !(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))) {
		return 1;
	}

	if (bc->recursion) {
		return 1;
	}

	if (bc->valueP) {
		*bc->valueP = value;
	}

	if (bc->action) {
		bc->action(value, bc->data);
	}

	return 1;
}

/**
 * Signal handler used to draw a frame around a widget, used to visually
 * group several buttons together
 *
 * \param b IN  widget
 */

static void choiceRepaint(
        wControl_p b)
{
	wChoice_p bc = (wChoice_p)b;

	if (gtk_widget_get_visible(b->widget)) {
		wlibDrawBox(bc->parent, wBoxBelow, bc->realX-1, bc->realY-1, bc->w+1, bc->h+1);
	}
}

/**
 * Create a group of radio buttons.
 *
 * \param parent IN parent window
 * \param x IN X-position
 * \param y IN Y-position
 * \param helpStr IN Help string
 * \param labelStr IN Label
 * \param option IN Options
 * \param labels IN Labels
 * \param valueP IN Selected value
 * \param action IN Callback
 * \param data IN User data as context
 * \returns radio button widget
 */

wChoice_p wRadioCreate(
        wWin_p	parent,
        wWinPix_t	x,
        wWinPix_t	y,
        const char 	* helpStr,
        const char	* labelStr,
        long	option,
        const char	* const *labels,
        long	*valueP,
        wChoiceCallBack_p action,
        void 	*data)
{
	wChoice_p b;
	const char * const * label;
	GtkWidget *butt0=NULL, *butt;

	if ((option & BC_NOBORDER)==0) {
		if (x>=0) {
			x++;
		} else {
			x--;
		}

		if (y>=0) {
			y++;
		} else {
			y--;
		}
	}

	b = wlibAlloc(parent, B_RADIO, x, y, labelStr, sizeof *b, data);
	b->option = option;
	b->action = action;
	b->valueP = valueP;
	wlibComputePos((wControl_p)b);

	((wControl_p)b)->outline = FALSE;

	if (option&BC_HORZ) {
		b->widget = gtk_hbox_new(FALSE, 0);
	} else {
		b->widget = gtk_vbox_new(FALSE, 0);
	}

	if (b->widget == 0) {
		abort();
	}

	for (label=labels; *label; label++) {
		butt = gtk_radio_button_new_with_label(
		               butt0?gtk_radio_button_get_group(GTK_RADIO_BUTTON(butt0)):NULL, _(*label));

		if (butt0==NULL) {
			butt0 = butt;
		}

		gtk_box_pack_start(GTK_BOX(b->widget), butt, TRUE, TRUE, 0);
		gtk_widget_show(butt);
		g_signal_connect(GTK_OBJECT(butt), "toggled",
		                 G_CALLBACK(pushChoice), b);
		g_signal_connect_after(GTK_OBJECT(b->widget), "expose-event",
		                       G_CALLBACK(exposeButt), b);
		wlibAddHelpString(butt, helpStr);
	}

	if (option & BB_DEFAULT) {
		gtk_widget_set_can_default(b->widget, TRUE);
		gtk_widget_grab_default(b->widget);
	}

	if (valueP) {
		wRadioSetValue(b, *valueP);
	}

	if ((option & BC_NOBORDER)==0) {
		b->repaintProc = choiceRepaint;
		b->w += 2;
		b->h += 2;
	}

	gtk_fixed_put(GTK_FIXED(parent->widget), b->widget, b->realX, b->realY);
	wlibControlGetSize((wControl_p)b);

	if (labelStr) {
		b->labelW = wlibAddLabel((wControl_p)b, labelStr);
	}

	gtk_widget_show(b->widget);
	wlibAddButton((wControl_p)b);
	return b;
}

/**
 * Create a group of toggle buttons.
 *
 * \param parent IN parent window
 * \param x IN X-position
 * \param y IN Y-position
 * \param helpStr IN Help string
 * \param labelStr IN Label
 * \param option IN Options
 * \param labels IN Labels
 * \param valueP IN Selected value
 * \param action IN Callback
 * \param data IN User data as context
 * \returns toggle button widget
 */

wChoice_p wToggleCreate(
        wWin_p	parent,
        wWinPix_t	x,
        wWinPix_t	y,
        const char 	* helpStr,
        const char	* labelStr,
        long	option,
        const char * const * labels,
        long	*valueP,
        wChoiceCallBack_p action,
        void 	*data)
{
	wChoice_p b;
	const char * const * label;

	if ((option & BC_NOBORDER)==0) {
		if (x>=0) {
			x++;
		} else {
			x--;
		}

		if (y>=0) {
			y++;
		} else {
			y--;
		}
	}

	b = wlibAlloc(parent, B_TOGGLE, x, y, labelStr, sizeof *b, data);
	b->option = option;
	b->action = action;
	wlibComputePos((wControl_p)b);

	((wControl_p)b)->outline = FALSE;

	if (option&BC_HORZ) {
		b->widget = gtk_hbox_new(FALSE, 0);
	} else {
		b->widget = gtk_vbox_new(FALSE, 0);
	}

	if (b->widget == 0) {
		abort();
	}

	for (label=labels; *label; label++) {
		GtkWidget *butt;

		butt = gtk_check_button_new_with_label(_(*label));
		gtk_box_pack_start(GTK_BOX(b->widget), butt, TRUE, TRUE, 0);
		gtk_widget_show(butt);
		g_signal_connect(GTK_OBJECT(butt), "toggled",
		                 G_CALLBACK(pushChoice), b);
		g_signal_connect_after(GTK_OBJECT(b->widget), "expose-event",
		                       G_CALLBACK(exposeButt), b);
		wlibAddHelpString(butt, helpStr);
	}

	if (valueP) {
		wToggleSetValue(b, *valueP);
	}

	if ((option & BC_NOBORDER)==0) {
		b->repaintProc = choiceRepaint;
		b->w += 2;
		b->h += 2;
	}

	gtk_fixed_put(GTK_FIXED(parent->widget), b->widget, b->realX, b->realY);
	wlibControlGetSize((wControl_p)b);

	if (labelStr) {
		b->labelW = wlibAddLabel((wControl_p)b, labelStr);
	}

	gtk_widget_show(b->widget);
	wlibAddButton((wControl_p)b);
	return b;
}
