#include "Gtk_Funcs.h"

const unsigned char numbers[6] = {1, 2, 3, 4, 5, 6};
struct NewGameWindow ng;
struct Player_Conf_Objs *pco;
uint32_t new_game_win_open = 0;


//temporaries used for new game window
struct Ng_Tmps{
	uint32_t Num_Players;
	uint32_t Dice;
	uint32_t Simulation;
	uint32_t Min_Get_Onboard;
	uint32_t Straight_Score;
	uint32_t Three_Pairs_Score;
	//struct All_Gtk_Widgets gtk;
	struct Player_Data *pd;
}ng_tmps;


//static uint8_t Create_Cairo_Dice(void);
static void on_destroy(GtkWidget *widget, gpointer mw);
static gboolean on_dice_select(GtkWidget *widget, GdkEventButton *event, gpointer num);
static gboolean Create_NewGameWindow(GtkWidget *widget, GdkEventButton *event, gpointer num);
static gboolean on_num_players_chng(GtkWidget *widget, gpointer data);

//static gboolean on_expose_cairo(GtkWidget *widget, GdkEventExpose *event);
static gboolean on_expose_cairo(GtkWidget *widget, gpointer data);
static gboolean on_dice_roll(GtkWidget *widget, gpointer data);
static gboolean on_end_turn(GtkWidget *widget, gpointer data);
static gboolean on_text_refresh(GtkWidget *widget, gpointer data);

static void Adjust_NG_Table(void);
static void on_start_button(GtkWidget *widget, gpointer mw);
static void on_toggle_AI(GtkWidget *widget, gpointer mw);

void Print_Status(const gchar *text){
	//add string to Status text view buffer
	//WARNING: string must be null terminated !
	GtkTextIter iter1;
	GtkTextIter iter2;
	uint32_t num1 = 0;
	num1 = gtk_text_buffer_get_line_count(gtk.ta_status_text_b);
	if(num1 < 10){
		gtk_text_buffer_get_start_iter(gtk.ta_status_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_status_text_b, &iter1, text, -1);
	}else{
		gtk_text_buffer_get_iter_at_line(gtk.ta_status_text_b, &iter1, 10);
		gtk_text_buffer_get_end_iter(gtk.ta_status_text_b, &iter2);
		gtk_text_buffer_delete(gtk.ta_status_text_b, &iter1, &iter2);
		gtk_text_buffer_get_start_iter(gtk.ta_status_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_status_text_b, &iter1, text, -1);
	}
}

void Print_Score(const gchar *text){
	GtkTextIter iter1;
	GtkTextIter iter2;
	uint32_t num1 = 0;
	num1 = gtk_text_buffer_get_line_count(gtk.ta_score_text_b);
	if(num1 < 10){
		gtk_text_buffer_get_start_iter(gtk.ta_score_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_score_text_b, &iter1, text, -1);
	}else{
		gtk_text_buffer_get_iter_at_line(gtk.ta_score_text_b, &iter1, 10);
		gtk_text_buffer_get_end_iter(gtk.ta_score_text_b, &iter2);
		gtk_text_buffer_delete(gtk.ta_score_text_b, &iter1, &iter2);
		gtk_text_buffer_get_start_iter(gtk.ta_score_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_score_text_b, &iter1, text, -1);
	}
}

static void on_destroy(GtkWidget *widget, gpointer mw){
	if(mw == NULL){
		gs.Exit_Program = 1;
		if(new_game_win_open){
			gtk_widget_destroy(ng.win);
			//free(ng_tmps.pd);
			//free(pco);
		}
		gtk_main_quit();
	}else{
		gtk_widget_destroy(ng.win);
		//free(ng_tmps.pd);
		//free(pco);
		new_game_win_open = 0;
	}
}

static gboolean on_dice_select(GtkWidget *widget, GdkEventButton *event, gpointer num){
	//printf("Dice %u selected\n", *(const unsigned char *)num);
	uint8_t sel = *(const unsigned char *)num;
	//if(sel > gs.rdc)
	//	return FALSE;
	sel--;

	if(gs.Dice_Blank[sel] == 1)
		return FALSE;

//	if( Valid_Dice_Selection(sel) ){

	gs.Dice_Selected[sel] ^= 1;
//	}
	//g_print ("Event box clicked at coordinates %f,%f\n",
    //       event->x, event->y);
	//if it's a LOCAL_PLAYER turn 
		//mark the selected dice
	//else return
//buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (app->cfg_space));
//gtk_text_buffer_set_text (buffer, text, -1);
//gtk_text_buffer_set_modified (buffer, FALSE);
//gchar *str1 = "STATUS:";
//gchar *str2 = "SCORE:";
//GtkTextIter iter1;
//GtkTextIter iter2;
	//uint32_t num1 = 0;
	//gchar *ret_sel;
	gchar buff[24];
	(void)memset(buff, '\0', 24);

	if(gs.Dice_Selected[sel])
		(void)sprintf(buff, "Dice %u selected\n", *(const unsigned char *)num);
	else
		(void)sprintf(buff, "Dice %u deselected\n", *(const unsigned char *)num);
	Print_Status(buff);
	//Print_Score(buff);
/*
	(void)memset(buff, '\0', 1024);
	(void)sprintf(buff, "Cumulative Score %u\n", pd[gs.Cur_Player].cumulative_score);
	Print_Score(buff);
	(void)memset(buff, '\0', 1024);
	(void)sprintf(buff, "Turn Score %u\n", pd[gs.Cur_Player].turn_score);
	Print_Score(buff);
*/
    if(on_expose_cairo(gtk.da_cairo[0], NULL) == FALSE){
        printf("Error!\n");
        return FALSE;
    }


/*
//	gtk_text_buffer_set_text(gtk.ta_status_text_b, (const gchar *)buff, -1);
//	gtk_text_buffer_set_text(gtk.ta_score_text_b, (const gchar *)buff, -1);

	//gtk_text_buffer_get_end_iter(gtk.ta_status_text_b, &iter1);
	//num1 = gtk_text_iter_get_line((const GtkTextIter *)&iter1);
	num1 = gtk_text_buffer_get_line_count(gtk.ta_status_text_b);
	if(num1 < 10){
		//gtk_text_buffer_get_iter_at_line(gtk.ta_status_text_b, iter, 0);
		gtk_text_buffer_get_start_iter(gtk.ta_status_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_status_text_b, &iter1, (const gchar *)buff, -1);
	}else{
		gtk_text_buffer_get_iter_at_line(gtk.ta_status_text_b, &iter1, 10);
		gtk_text_buffer_get_end_iter(gtk.ta_status_text_b, &iter2);
		gtk_text_buffer_delete(gtk.ta_status_text_b, &iter1, &iter2);
		gtk_text_buffer_get_start_iter(gtk.ta_status_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_status_text_b, &iter1, (const gchar *)buff, -1);
	}

	num1 = gtk_text_buffer_get_line_count(gtk.ta_score_text_b);
	if(num1 < 10){
		gtk_text_buffer_get_start_iter(gtk.ta_score_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_score_text_b, &iter1, (const gchar *)buff, -1);
	}else{
		gtk_text_buffer_get_iter_at_line(gtk.ta_score_text_b, &iter1, 10);
		gtk_text_buffer_get_end_iter(gtk.ta_score_text_b, &iter2);
		gtk_text_buffer_delete(gtk.ta_score_text_b, &iter1, &iter2);
		gtk_text_buffer_get_start_iter(gtk.ta_score_text_b, &iter1);
		gtk_text_buffer_insert(gtk.ta_score_text_b, &iter1, (const gchar *)buff, -1);
	}
		//gtk_text_buffer_get_start_iter(gtk.ta_status_text_b, &iter1);
		//gtk_text_buffer_get_iter_at_line(gtk.ta_status_text_b, &iter2, 10);
		//gtk_text_buffer_get_iter_at_line_offset(gtk.ta_status_text_b, &iter2, 9, 0);
		//ret_sel = gtk_text_buffer_get_text(gtk.ta_status_text_b, &iter1, &iter2, FALSE);
//	}


	//gtk_text_buffer_get_iter_at_line(gtk.ta_score_text_b, iter, 0);
	gtk_text_buffer_get_start_iter(gtk.ta_score_text_b, &iter2);
	gtk_text_buffer_insert(gtk.ta_score_text_b, &iter2, (const gchar *)buff, -1);
	}else{
		gtk_text_buffer_get_start_iter(gtk.ta_status_text_b, &iter1);
		gtk_text_buffer_get_end_iter(gtk.ta_status_text_b, &iter2);
		gtk_text_buffer_get_slice(gtk.ta_status_text_b, &iter1, &iter2, FALSE);
		gtk_text_buffer_set_text
gtk_text_buffer_delete (GtkTextBuffer *buffer,GtkTextIter *start, GtkTextIter *end);
	}
*/
	return TRUE;
}
static gboolean on_text_refresh(GtkWidget *widget, gpointer data){
	//char buff[1024];
	//const gchar *str1 = "STATUS:";
	//const gchar *str2 = "SCORE:";
	//(void)strcpy(buff, "STATUS:");
	//gtk_text_buffer_set_text(gtk.ta_status_text_b, str1, -1);
	//(void)strcpy(buff, "SCORE:");
	//gtk_text_buffer_set_text(gtk.ta_score_text_b, str2, -1);
	//gtk_widget_show_all(gtk.ta_status_text_v);
	//gtk_widget_show_all(gtk.ta_score_text_v);
	gtk_widget_show_all(gtk.main_win);
	return TRUE;
}
//gtk_combo_box_get_active        (GtkComboBox *
static void on_toggle_AI(GtkWidget *widget, gpointer mw){
	/*
   //     g_signal_connect(G_OBJECT(pco[num1].type), "changed", G_CALLBACK(on_toggle_AI), (gpointer)(ng.win));
        if(pd[num1].type == COMPUTER_PLAYER){
            pco[num1].dice_adj  = (GtkAdjustment *)gtk_adjustment_new(pd[num1].min_dice_will_roll, 1.0, Dice, 1.0, 1.0, 0.0);
            pco[num1].score_adj = (GtkAdjustment *)gtk_adjustment_new(pd[num1].min_score_will_keep, 0.0, 8000.0, 50.0, 50.0, 0.0);
            pco[num1].dice_b  = gtk_spin_button_new(pco[num1].dice_adj, 1, 1);
            pco[num1].score_b = gtk_spin_button_new(pco[num1].score_adj, 1, 1);
            gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].dice_b,  2, 3, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
            gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].score_b,  3, 4, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
        }
	gtk_widget_hide(
	gtk_widget_show(

	if(gtk_combo_box_get_active((GtkComboBox *)widget) == LOCAL_PLAYER){
		gtk_widget_hide( GTK_WIDGET( ((struct Player_Conf_Objs *)mw)->dice_b) );
		gtk_widget_hide( GTK_WIDGET( ((struct Player_Conf_Objs *)mw)->score_b) );
	}else if(gtk_combo_box_get_active((GtkComboBox *)widget) == COMPUTER_PLAYER){
		gtk_widget_show( GTK_WIDGET( ((struct Player_Conf_Objs *)mw)->dice_b) );
		gtk_widget_show( GTK_WIDGET( ((struct Player_Conf_Objs *)mw)->score_b) );
	}
	*/
	uint32_t num1 = 0;
	gtk_widget_show_all(ng.win);
	for(num1=0; num1<ng_tmps.Num_Players; num1++){
		if(gtk_combo_box_get_active((GtkComboBox *)(pco[num1].type)) == LOCAL_PLAYER){
			gtk_widget_hide( GTK_WIDGET(pco[num1].dice_b) );
			gtk_widget_hide( GTK_WIDGET(pco[num1].score_b) );
		}
	}
	//gtk_widget_show_all(widget);
}
/*
void on_col_chng(GtkSpinButton *widget, gpointer data){
    //struct PortTab *ptr = data;
    //GTK_SPIN_BUTTON(
    Port_win.port_cols = gtk_spin_button_get_value_as_int(widget);
    //Port_win.port_rows = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
    printf("col: %d\n", Port_win.port_cols );
    port_adj_col();
    gtk_widget_show_all(GTK_WIDGET((GtkSpinButton *)data));
}
*/

static gboolean on_num_players_chng(GtkWidget *widget, gpointer data){
	//ng_tmps.Num_Players = gtk_spin_button_get_value_as_int(widget);
	//printf("changed number players: %d\n", ng_tmps.Num_Players );
	uint32_t num1 = 0;
	Adjust_NG_Table();
	for(num1=0; num1<ng_tmps.Num_Players; num1++){
		if(gtk_combo_box_get_active((GtkComboBox *)(pco[num1].type)) == LOCAL_PLAYER){
			gtk_widget_hide( GTK_WIDGET(pco[num1].dice_b) );
			gtk_widget_hide( GTK_WIDGET(pco[num1].score_b) );
			//gtk_widget_hide( GTK_WIDGET(((struct Player_Conf_Objs *)mw)->dice_b) );
			//gtk_widget_hide( GTK_WIDGET(((struct Player_Conf_Objs *)mw)->score_b) );
		}
	}
	//gtk_widget_show_all(GTK_WIDGET((GtkSpinButton *)widget));
	return TRUE;
}

static void Adjust_NG_Table(void){
	//static uint8_t has_been_called = 0;
	uint32_t num1 = 0;
	uint32_t num2 = 0;
	uint32_t num3 = 0;
	//uint32_t rows_added = 0;
	char tmp[4];

	//delete the whole table and start fresh ?
	uint32_t new_Num_Players = gtk_spin_button_get_value_as_int((GtkSpinButton *)ng.Num_Players_b);
	if(new_Num_Players == ng_tmps.Num_Players)
		return;
	/*
	if(has_been_called == 0){
		//initialize all ng_tmp members
		ng_tmps.Num_Players = Num_Players;
		ng_tmps.Dice = Dice;
		ng_tmps.Simulations = 0;
		ng_tmps.Min_Get_Onboard = Min_Get_Onboard;
		ng_tmps.Straight_Score = Straight_Score;
		ng_tmps.Three_Pairs_Score = Three_Pairs_Score;
		ng_tmps.pd = (struct Player_Data *)malloc(sizeof(struct Player_Data) * ng_tmps.Num_Players);
		has_been_called = 1;
	}
	*/
	//remove/add widgets
	//if(new_Num_Players > ng_tmps.Num_Players){
		//players/rows were added
		//rows_added = new_Num_Players - ng_tmps.Num_Players;

	if(new_Num_Players < ng_tmps.Num_Players){
		for(num1=new_Num_Players; num1<ng_tmps.Num_Players; num1++){
			gtk_widget_destroy(pco[num1].label);
			gtk_widget_destroy(pco[num1].type);
			//gtk_widget_destroy(G_OBJECT(pco[num1].dice_adj));
			//gtk_widget_destroy(G_OBJECT(pco[num1].score_adj));
			gtk_widget_destroy(pco[num1].dice_b);
			gtk_widget_destroy(pco[num1].score_b);
		}
	}

		//resize configuration objects array
		pco = (struct Player_Conf_Objs *)realloc((void *)pco, sizeof(struct Player_Conf_Objs) * new_Num_Players);
		//resize table

		gtk_table_resize(GTK_TABLE(ng.top_table), new_Num_Players+2, 4);
		//gtk_table_resize(GTK_TABLE(ng.top_table), 4, new_Num_Players+2);
		//resize pd array and initialize values
		ng_tmps.pd = (struct Player_Data *)realloc((void *)(ng_tmps.pd), sizeof(struct Player_Data) * new_Num_Players);
		for(num1=ng_tmps.Num_Players; num1<new_Num_Players; num1++){
			//((ng_tmps.pd)[num1]).rseed = pd[0].rseed + num1;
			((ng_tmps.pd)[num1]).onboard = 0;
			((ng_tmps.pd)[num1]).min_dice_will_roll = 3;
			((ng_tmps.pd)[num1]).type = COMPUTER_PLAYER;
			((ng_tmps.pd)[num1]).min_score_will_keep = 250;
			((ng_tmps.pd)[num1]).turn_score = 0;
			((ng_tmps.pd)[num1]).cumulative_score = 0;
			((ng_tmps.pd)[num1]).wins = 0;
		}
		//setup new objects and add to table
		for(num1=ng_tmps.Num_Players; num1<new_Num_Players; num1++){
			(void)memset((void *)tmp, '\0', sizeof(char)*4);
			(void)sprintf(tmp, "%d", num1+1);
			pco[num1].label = gtk_label_new((const gchar *)tmp);
			gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].label,  0, 1, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
			pco[num1].type = gtk_combo_box_text_new();
			gtk_combo_box_text_prepend_text((GtkComboBoxText *)pco[num1].type, "User");
			gtk_combo_box_text_prepend_text((GtkComboBoxText *)pco[num1].type, "AI");
			gtk_combo_box_set_active((GtkComboBox *)pco[num1].type, COMPUTER_PLAYER);
			gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].type,  1, 2, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
			//g_signal_connect(G_OBJECT(pco[num1].type), "changed", G_CALLBACK(on_toggle_AI), (gpointer)&(pco[num1]));
			//if(gtk_combo_box_get_active((GtkComboBox *)widget) == LOCAL_PLAYER){
			//gtk_widget_show(pco[num1].dice_b);
			//gtk_widget_show(pco[num1].score_b);

			//ng_tmps.pd
			pco[num1].dice_adj  = (GtkAdjustment *)gtk_adjustment_new(((ng_tmps.pd)[num1]).min_dice_will_roll, 1.0, ng_tmps.Dice, 1.0, 1.0, 0.0);
			pco[num1].score_adj = (GtkAdjustment *)gtk_adjustment_new(((ng_tmps.pd)[num1]).min_score_will_keep, 0.0, 8000.0, 50.0, 50.0, 0.0);
			pco[num1].dice_b  = gtk_spin_button_new(pco[num1].dice_adj, 1, 1);
			pco[num1].score_b = gtk_spin_button_new(pco[num1].score_adj, 1, 1);
			gtk_widget_show(pco[num1].dice_b);
			gtk_widget_show(pco[num1].score_b);
			gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].dice_b,  2, 3, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
			gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].score_b,  3, 4, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
			//add signals
			g_signal_connect(G_OBJECT(pco[num1].type), "changed", G_CALLBACK(on_toggle_AI), (gpointer)&(pco[num1]));
			//g_signal_connect(G_OBJECT(pco[num1].type), "changed", G_CALLBACK(on_toggle_AI), (gpointer)(ng.win));

			//printf("%u set\n", gtk_spin_button_get_value_as_int((GtkSpinButton *)((pco[num1]).dice_b) ) );
		}
	//}
	//
	ng_tmps.Num_Players = new_Num_Players;
	//refresh
	gtk_widget_show_all(ng.win);
}

static gboolean on_end_turn(GtkWidget *widget, gpointer data){
	if(pd[gs.Cur_Player].type == COMPUTER_PLAYER)
		return FALSE;
	//printf("C Score: %u\n", Score_Of_Selected());
	pd[gs.Cur_Player].turn_score += Score_Of_Selected();
	Player_End_Turn();
	gchar buff[28];
	(void)memset(buff, '\0', 28);
	(void)sprintf(buff, "cumulative Score %u\n", pd[gs.Cur_Player].cumulative_score);
	Print_Score(buff);
	//printf("C Score: %u\n", pd[gs.Cur_Player].cumulative_score);
	Next_Player();
	printf("Ended turn!\n");
    //gchar buff[1024];
    //(void)memset(buff, '\0', 1024);
    //(void)sprintf(buff, "Dice %u selected\n", *(const unsigned char *)num);

	Reset_Dice_Selection();
	Print_Status("Ended turn!\n");
	if(on_expose_cairo(gtk.da_cairo[0], NULL) == FALSE){
		printf("Error!\n");
		return FALSE;
	}
	gtk_widget_show_all(gtk.main_win);

	return TRUE;
}
static void on_start_button(GtkWidget *widget, gpointer mw){
	//commit changes and start new game
	uint32_t num1 = 0;
	pd = (struct Player_Data *)realloc((void *)pd, sizeof(struct Player_Data) * ng_tmps.Num_Players);
	//(void)memcpy((void *)pd, (const void *)ng_tmps.pd, sizeof(struct Player_Data) * ng_tmps.Num_Players);
	//ng_tmps.pd
	//printf("here 1: %u\n", ng_tmps.Num_Players);
	for(num1=0; num1<ng_tmps.Num_Players; num1++){
		//pd[num1]. = 
		(pd[num1]).onboard = 0;
		(pd[num1]).type = (uint8_t)gtk_combo_box_get_active( (GtkComboBox *)(pco[num1].type) );
		//(pd[num1]).type = ((ng_tmps.pd)[num1]).type;
		//if((pd[num1]).type == COMPUTER_PLAYER){
			//printf("%u set\n", (uint32_t)gtk_spin_button_get_value_as_int( (GtkSpinButton *)((pco[num1]).dice_b) );

			//printf("a\n");
		(pd[num1]).min_dice_will_roll = (uint8_t)gtk_spin_button_get_value_as_int( (GtkSpinButton *)((pco[num1]).dice_b) );
			//printf("b\n");
			//(pd[num1]).type = ((ng_tmps.pd)[num1]).type;
			//printf("c\n");
		(pd[num1]).min_score_will_keep = (uint32_t)gtk_spin_button_get_value_as_int( (GtkSpinButton *)((pco[num1]).score_b) );
		//}
		//printf("d\n");
		(pd[num1]).turn_score = 0;
		(pd[num1]).cumulative_score = 0;
		(pd[num1]).wins = 0;
		//(pd[num1]).rseed = (pd[0]).rseed + num1;
		//printf("p: %u set\n", num1);
	}

	uint32_t new_dice = (uint32_t)gtk_spin_button_get_value_as_int((GtkSpinButton *)ng.Dice_b);

	///Need to resize main window objects and reset all values as needed
	if(new_dice < gs.Dice){
        for(num1=new_dice; num1<gs.Dice; num1++){
			//gtk_widget_destroy(GTK_WIDGET(gtk.da_images[num1]));
            //gtk_widget_destroy(GTK_WIDGET(gtk.da_event_boxs[num1]));
			gtk_widget_destroy(GTK_WIDGET(gtk.da_cairo[num1]));
			gtk_widget_destroy(GTK_WIDGET(gtk.da_event_boxs[num1]));
            //gtk_widget_destroy();
            //gtk_widget_destroy(G_OBJECT(pco[num1].dice_adj));
            //gtk_widget_destroy(G_OBJECT(pco[num1].score_adj));
            //gtk_widget_destroy(pco[num1].dice_b);
            //gtk_widget_destroy(pco[num1].score_b);
        }
    }
	//resize table
	gtk_table_resize(GTK_TABLE(gtk.da_top_table), 1, new_dice);
	//gtk_table_resize(GTK_TABLE(gtk.da_top_table), new_dice, 1);
	//create/add widgets as needed
	for(num1=gs.Dice; num1<new_dice; num1++){
		gtk.da_event_boxs[num1] = gtk_event_box_new();
		gtk.da_cairo[num1] = gtk_drawing_area_new();
		gtk_widget_set_size_request(gtk.da_cairo[num1], 120, 120);
		//gtk.da_images[num1] = gtk_image_new_from_file("dice1.png");
		//gtk_container_add(GTK_CONTAINER(gtk.da_event_boxs[num1]), gtk.da_images[num1]);
		gtk_container_add(GTK_CONTAINER(gtk.da_event_boxs[num1]), gtk.da_cairo[num1]);
		gtk_table_attach(GTK_TABLE(gtk.da_top_table), gtk.da_event_boxs[num1], num1, num1+1, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
		g_signal_connect(G_OBJECT(gtk.da_event_boxs[num1]), "button-release-event", G_CALLBACK(on_dice_select), (gpointer)&(numbers[num1]) );
		//g_signal_connect(G_OBJECT(gtk.da_cairo[num1]), "expose-event", G_CALLBACK(on_expose_cairo), (gpointer)&(numbers[num1]));
	}
	//resize/set dice info structures
    gs.Cur_Player = 0;
    gs.Dice_Selected = (uint8_t *)realloc(gs.Dice_Selected, sizeof(uint8_t) * new_dice);
    gs.Dice_Values = (uint8_t *)realloc(gs.Dice_Values, sizeof(uint8_t) * new_dice);
    (void)memset(gs.Dice_Selected, '\0', new_dice);
    //(void)memset(gs.Dice_Values, '\0', new_dice);
	for(num1=0; num1<new_dice; num1++){
		gs.Dice_Values[num1] = 1;
	}
	//gtk_widget_show_all(gtk.main_win);

	gs.Num_Players = ng_tmps.Num_Players;
	gs.Dice = new_dice;
    //gs.Cur_Player = 0;
    gs.Roll_Count = 0;
    gs.rdc = new_dice;

	//(uint32_t)gtk_spin_button_get_value_as_int((GtkSpinButton *)ng.Dice_b);
	gs.Simulation = 0;
	gs.Min_Get_Onboard = (uint32_t)gtk_spin_button_get_value_as_int((GtkSpinButton *)ng.Onboard_b);
	gs.Straight_Score = (uint32_t)gtk_spin_button_get_value_as_int((GtkSpinButton *)ng.Straight_b);
	gs.Three_Pairs_Score = (uint32_t)gtk_spin_button_get_value_as_int((GtkSpinButton *)ng.Three_Pair_b);
	//printf("here 2\n");
	gtk_widget_destroy(ng.win);
	new_game_win_open = 0;
	//printf("here 3\n");
	gtk_widget_show_all(gtk.main_win);
	///done. Need to resize main window objects and reset all values as needed

	//Dice has changed, need to call static gboolean on_expose_cairo(GtkWidget *widget, gpointer data)
	//g_signal_emit_by_name(G_OBJECT( ((struct GTK_Main_Window *)data)->cairo_area ), "expose-event", G_CALLBACK(on_expose_cairo), &ret_val);
	Blank_Dice();
	gboolean ret_val = FALSE;
	ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
	
	//for(num1=0; num1<Dice; num1++){
	//	ret_val = on_expose_cairo(gtk.da_cairo[num1], (gpointer)&(numbers[num1]));

		//g_signal_emit_by_name(G_OBJECT(gtk.da_cairo[num1]), "expose-event", G_CALLBACK(on_expose_cairo), &numbers[num1], &ret_val);
		if(ret_val == FALSE){
			printf("Error: cairo on_expose_cairo call !\n");
			//break;
		}
	//}
	//gchar buff[1024];
	//(void)memset(buff, '\0', 1024);
	//(void)sprintf(buff, "Dice %u selected\n", *(const unsigned char *)num);
    Print_Status("New Game Started !\n");
	//for(num1=0; num1<gs.Num_Players; num1++){  printf the scores like so 
   //Print_Score("New Game Started !\n");
	

}

/*
static void Alloc_PT_Objects(void){
	uint32_t num1;
	//player  type  gtk_widget_destroy(min_dice_will_roll  min_score_will_keep

	ng.Player_Type   = (GtkWidget **)malloc(sizeof(GtkWidget *) * Num_Players);
	//ng.player_labels = (GtkWidget ***)malloc(sizeof(GtkWidget **) * 4);
	//for(num1=0; num1<; num1++){
	//}
    ng.player_adj    = (GtkAdjustment ***)malloc(sizeof(GtkAdjustment **) * Num_Players);
	ng.player_b      = (GtkWidget ***)malloc(sizeof(GtkWidget **) * Num_Players);
	for(num1=0; num1<Num_Players; num1++){
		ng.player_adj[num1] = (GtkAdjustment **)malloc(sizeof(GtkAdjustment *) * 2);
		ng.player_b[num1]   = (GtkWidget **)malloc(sizeof(GtkWidget *) * 2);
	}

}

static void Realloc_PT_Objects(void){
	uint32_t num1;
	ng.Player_Type   = (GtkWidget **)realloc((void *)ng.Player_Type, sizeof(GtkWidget *) * Num_Players);
	ng.player_adj    = (GtkAdjustment ***)realloc((void *)ng.player_adj, sizeof(GtkAdjustment **) * Num_Players);
	ng.player_b      = (GtkWidget ***)realloc((void *)ng.player_b, sizeof(GtkWidget **) * Num_Players);
	for(num1=0; num1<Num_Players; num1++){
		if(ng.player_adj[num1] == NULL)
			ng.player_adj[num1] = (GtkAdjustment **)malloc(sizeof(GtkAdjustment *) * 2);
		//else
		//	ng.player_adj[num1] = (GtkAdjustment **)realloc(sizeof(GtkAdjustment *) * 2);
		if(ng.player_b[num1] == NULL)
			ng.player_b[num1]   = (GtkWidget **)malloc(sizeof(GtkWidget *) * 2);
		//else
		//	ng.player_b[num1]   = (GtkWidget **)realloc(sizeof(GtkWidget *) * 2);
	}
}

static void Free_PT_Objects(void){

}
*/
//gtk_widget_set_can_focus(widget, FALSE);

static gboolean Create_NewGameWindow(GtkWidget *widget, GdkEventButton *event, gpointer num){
	if(new_game_win_open)
		return FALSE;
	new_game_win_open = 1;
	uint32_t num1;
	char tmp[4];
	ng_tmps.Num_Players = gs.Num_Players;
	ng_tmps.Dice = gs.Dice;
	ng_tmps.Simulation = gs.Simulation;
	ng_tmps.Min_Get_Onboard = gs.Min_Get_Onboard;
	ng_tmps.Straight_Score = gs.Straight_Score;
	ng_tmps.Three_Pairs_Score = gs.Three_Pairs_Score;

//	pco = (struct Player_Conf_Objs *)malloc(sizeof(struct Player_Conf_Objs) * Num_Players);
//	ng_tmps.pd = (struct Player_Data *)malloc(sizeof(struct Player_Data) * Num_Players);
//	(void)memcpy((void *)ng_tmps.pd, (const void *)pd, sizeof(struct Player_Data) * Num_Players);

	//struct NewGameWindow ng;
	ng.win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_container_set_border_width(GTK_CONTAINER(ng.win), 2);
	gtk_window_set_default_size(GTK_WINDOW(ng.win), 600, 400);
	gtk_window_set_title(GTK_WINDOW(ng.win), "New Game Settings");
	ng.vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(ng.win), ng.vbox);
	//player  type  min_dice_will_roll  min_score_will_keep
	ng.top_table = gtk_table_new(gs.Num_Players+2, 4, TRUE);
	//ng.top_table = gtk_table_new(4, gs.Num_Players+2, TRUE);

	ng.top_table_labels[0] = gtk_label_new("Player");
	ng.top_table_labels[1] = gtk_label_new("Type");
	ng.top_table_labels[2] = gtk_label_new("Min dice will roll");
	ng.top_table_labels[3] = gtk_label_new("Min score will keep");
	gtk_table_attach(GTK_TABLE(ng.top_table), ng.top_table_labels[0],  0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.top_table), ng.top_table_labels[1],  1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.top_table), ng.top_table_labels[2],  2, 3, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.top_table), ng.top_table_labels[3],  3, 4, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	for(num1=0; num1<gs.Num_Players; num1++){
		(void)memset((void *)tmp, '\0', sizeof(char)*4);
		(void)sprintf(tmp, "%d", num1+1);
		pco[num1].label = gtk_label_new((const gchar *)tmp);
		gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].label,  0, 1, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
		pco[num1].type = gtk_combo_box_text_new();
		//(GtkComboBoxText *)

		gtk_combo_box_text_prepend_text((GtkComboBoxText *)pco[num1].type, "User");
		gtk_combo_box_text_prepend_text((GtkComboBoxText *)pco[num1].type, "AI");
		gtk_combo_box_set_active((GtkComboBox *)pco[num1].type, (gint)(pd[num1].type)); //ng_tmps.pd
		gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].type,  1, 2, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
		//static void on_toggle_AI(GtkWidget *widget, gpointer mw)
		//g_signal_connect(G_OBJECT(pco[num1].type), "changed", G_CALLBACK(on_toggle_AI), (gpointer)&(pco[num1]));

		//if(pd[num1].type == COMPUTER_PLAYER){

		pco[num1].dice_adj  = (GtkAdjustment *)gtk_adjustment_new(pd[num1].min_dice_will_roll, 1.0, gs.Dice, 1.0, 1.0, 0.0);
		pco[num1].score_adj = (GtkAdjustment *)gtk_adjustment_new(pd[num1].min_score_will_keep, 0.0, 8000.0, 50.0, 50.0, 0.0);
		pco[num1].dice_b  = gtk_spin_button_new(pco[num1].dice_adj, 1, 1);
		pco[num1].score_b = gtk_spin_button_new(pco[num1].score_adj, 1, 1);
		//if(gtk_combo_box_get_active((GtkComboBox *)(pco[num1].type)) == LOCAL_PLAYER){
		//	gtk_widget_hide(pco[num1].dice_b);
		//	gtk_widget_hide(pco[num1].score_b);
		//}else{
		//	gtk_widget_show(pco[num1].score_b);
		//	gtk_widget_show(pco[num1].dice_b);
		//}
		gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].dice_b,  2, 3, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
		gtk_table_attach(GTK_TABLE(ng.top_table), pco[num1].score_b,  3, 4, num1+2, num1+3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
		//}
		g_signal_connect(G_OBJECT(pco[num1].type), "changed", G_CALLBACK(on_toggle_AI), (gpointer)&(pco[num1]));

	}
	ng.bottom_table = gtk_table_new(4, 5, TRUE);

	ng.simulator_cb = gtk_check_button_new_with_label("Simulation Mode");

    ng.Num_Players_adj = (GtkAdjustment *)gtk_adjustment_new(gs.Num_Players, 1.0, 25.0, 1.0, 1.0, 0.0);
    ng.Dice_adj        = (GtkAdjustment *)gtk_adjustment_new(gs.Dice, 1.0, 6.0, 1.0, 1.0, 0.0);
    ng.Onboard_adj     = (GtkAdjustment *)gtk_adjustment_new(gs.Min_Get_Onboard, 1.0, 8000.0, 50.0, 50.0, 0.0);
    ng.Straight_adj    = (GtkAdjustment *)gtk_adjustment_new(gs.Straight_Score, 1.0, 8000.0, 50.0, 50.0, 0.0);
    ng.Three_Pair_adj  = (GtkAdjustment *)gtk_adjustment_new(gs.Three_Pairs_Score, 1.0, 8000.0, 50.0, 50.0, 0.0);

    ng.Num_Players_b = gtk_spin_button_new(ng.Num_Players_adj, 1, 1);
    ng.Dice_b        = gtk_spin_button_new(ng.Dice_adj, 1, 1);
    ng.Onboard_b     = gtk_spin_button_new(ng.Onboard_adj, 1, 1);
    ng.Straight_b    = gtk_spin_button_new(ng.Straight_adj, 1, 1);
    ng.Three_Pair_b  = gtk_spin_button_new(ng.Three_Pair_adj, 1, 1);

	ng.start_button = gtk_button_new_with_label("Start Game");
	ng.discard_button = gtk_button_new_with_label("Discard Changes");

	ng.bottom_labels[0] = gtk_label_new("Players");
	ng.bottom_labels[1] = gtk_label_new("Dice");
	ng.bottom_labels[2] = gtk_label_new("Get Onboard Score");
	ng.bottom_labels[3] = gtk_label_new("Straight Score");
	ng.bottom_labels[4] = gtk_label_new("Three Pair Score");
	//bottom_labels[5] = gtk_label_new("");
	//bottom_labels[6] = gtk_label_new("Ticker");

	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.bottom_labels[0],  0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.Num_Players_b,     1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.simulator_cb,      3, 4, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.bottom_labels[1],  0, 1, 1, 2, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.Dice_b,            1, 2, 1, 2, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.bottom_labels[2],  2, 3, 1, 2, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.Onboard_b,         3, 4, 1, 2, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.bottom_labels[3],  0, 1, 2, 3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.Straight_b,        1, 2, 2, 3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.bottom_labels[4],  2, 3, 2, 3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.Three_Pair_b,      3, 4, 2, 3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	//gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.bottom_labels[],  0, 1, 2, 3, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.start_button,   0, 1, 4, 5, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	gtk_table_attach(GTK_TABLE(ng.bottom_table), ng.discard_button, 3, 4, 4, 5, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);


    ng.scrolled_win = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ng.scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ng.scrolled_win), ng.top_table);
    gtk_box_pack_start(GTK_BOX(ng.vbox), ng.scrolled_win, TRUE, TRUE, 3);
    gtk_box_pack_end(GTK_BOX(ng.vbox), ng.bottom_table, FALSE, FALSE, 3);

	g_signal_connect(ng.win, "destroy", G_CALLBACK(on_destroy), (gpointer)(ng.win));
	g_signal_connect(G_OBJECT(ng.discard_button), "clicked", G_CALLBACK(on_destroy), (gpointer)(ng.win));
	g_signal_connect(G_OBJECT(ng.start_button), "clicked", G_CALLBACK(on_start_button), (gpointer)(ng.win));
	//gtk_spin_button_get_value_as_int(widget);
	//gtk_table_resize(GTK_TABLE(Port_win.pos_table), Port_win.port_rows+1, 3);
	//gtk_widget_destroy(
	//gtk_spin_button_set_value(GTK_SPIN_BUTTON(Port_bt.button2), (gdouble)cols);
	g_signal_connect(G_OBJECT(ng.Num_Players_b), "value-changed", G_CALLBACK(on_num_players_chng), NULL);

	gtk_widget_show_all(ng.win);
	for(num1=0; num1<gs.Num_Players; num1++){
		if(gtk_combo_box_get_active((GtkComboBox *)(pco[num1].type)) == LOCAL_PLAYER){
			gtk_widget_hide(pco[num1].dice_b);
			gtk_widget_hide(pco[num1].score_b);
		}
	}
	//gtk_widget_destroy(ng.win);
	//gtk_main();
	return TRUE;
}

static gboolean on_dice_roll(GtkWidget *widget, gpointer data){
	//FIXME: insert roll function call and condition/error checks here
	uint32_t num1 = gs.Cur_Player;
	//if(pd[num1].type == COMPUTER_PLAYER)
	//	return TRUE;
	//uint8_t ret_val = Player_Can_Roll();

	uint8_t ret_val = Player_Can_Roll();

/*
	if(pd[num1].type == COMPUTER_PLAYER){
	//	return FALSE;
		if(ret_val == TRUE){
			Roll_Dice();
		}
		pd[gs.Cur_Player].turn_score += AI_Select_Dice();
		ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
		if(ret_val == FALSE){
			printf("Error!\n");
			return FALSE;
		}
		gtk_widget_show_all(gtk.main_win);
		sleep(1);
		Reset_Dice_Selection();
		Roll_Dice();
		printf("Dice Rolled!\n");
        ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
        if(ret_val == FALSE){
            printf("Error!\n");
            return FALSE;
        }
        gtk_widget_show_all(gtk.main_win);
        //sleep(1);
        //should be automatically doing zilch check
        ret_val = Player_Can_Roll();
        if(ret_val == FALSE){
            printf("Zilch: Turn Over!\n");
            sleep(1);
            Player_End_Turn();
            Next_Player();
            ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
            if(ret_val == FALSE){
                printf("Error!\n");
                return FALSE;
            }
            gtk_widget_show_all(gtk.main_win);
            //return TRUE;
            //printf("Zilch: Turn Ended!\n");
            //should show blank dice here
        }

	}


	ret_val = Player_Can_Roll();
*/
	gchar buff[18];

	if(ret_val == TRUE){
		//add score
		if(pd[num1].type == COMPUTER_PLAYER){
			Roll_Dice();
			printf("Dice Rolled!\n");
			pd[gs.Cur_Player].turn_score += AI_Select_Dice();

		}else{
			pd[gs.Cur_Player].turn_score += Score_Of_Selected();
			Adjust_RDC();
		}
		(void)memset(buff, '\0', 18);
		(void)sprintf(buff, "Turn Score %u\n", pd[gs.Cur_Player].turn_score);
		Print_Score(buff);
		if(pd[num1].type == COMPUTER_PLAYER){
			ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
			if(ret_val == FALSE){
				printf("Error!\n");
				return FALSE;
			}
			gtk_widget_show_all(gtk.main_win);
			sleep(1);
			Reset_Dice_Selection();
		}else{
			//Adjust_RDC();
			Reset_Dice_Selection();

			//Adjust_RDC();
			//gs.rdc--;
			Roll_Dice();
			printf("Dice Rolled!\n");
			//ret_val = FALSE;
			ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
			if(ret_val == FALSE){
				printf("Error!\n");
				return FALSE;
			}
			gtk_widget_show_all(gtk.main_win);
			//sleep(1);
			//should be automatically doing zilch check
		}
		ret_val = Player_Can_Roll();
		if(ret_val == FALSE){
			printf("Zilch: Turn Over!\n");
			sleep(1);
			Player_End_Turn();
			Next_Player();
			ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
			if(ret_val == FALSE){
				printf("Error!\n");
				return FALSE;
			}
			gtk_widget_show_all(gtk.main_win);
			//return TRUE;
			//printf("Zilch: Turn Ended!\n");
			//should show blank dice here
		}
		sleep(1);
		//return TRUE;

	}else if(ret_val == FALSE){
		printf("Zilch: Turn Ended!\n");
		sleep(1);
		Player_End_Turn();
		Next_Player();
		ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
		if(ret_val == FALSE){
			printf("Error!\n");
			return FALSE;
		}
		gtk_widget_show_all(gtk.main_win);
	}else if(ret_val == INVALID_DICE_SELECTION){
		printf("Invalid Selection!\n");
		sleep(1);
		Reset_Dice_Selection();
		ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
		if(ret_val == FALSE){
			printf("Error!\n");
			return FALSE;
		}
		gtk_widget_show_all(gtk.main_win);
		//printf("Invalid Selection!\n");
	}else{
		printf("Error: on_dice_roll!\n");
		return FALSE;
	}
	//sleep(1);
	//	return TRUE;
	//Roll_Dice();
	//printf("Dice Rolled!\n");
	//uint32_t num1 = 0;
	//gboolean ret_val = FALSE;
	//ret_val = FALSE;
	//g_signal_connect(G_OBJECT(gtk.da_cairo), "expose-event", G_CALLBACK(on_expose_cairo), NULL);

	//ret_val = on_expose_cairo(gtk.da_cairo[0], NULL);
	//if(ret_val == FALSE){
	//	printf("Error!\n");
	//	return FALSE;
	//}
	/*
	for(num1=0; num1<Dice; num1++){
		ret_val = on_expose_cairo(gtk.da_cairo[num1], (gpointer)&(numbers[num1]));
		//g_signal_emit_by_name(G_OBJECT(gtk.da_cairo[num1]), "expose-event", G_CALLBACK(on_expose_cairo), &numbers[num1], &ret_val);
		if(ret_val == FALSE){
			printf("Error!\n");
			return FALSE;
		}
	}
	*/
	//gtk_widget_show_all(gtk.main_win);
	//sleep(1);
	//gtk_widget_show_all( GTK_WIDGET( ((struct GTK_Main_Window *)data)->main_window) );
	//gtk_widget_show_all(widget);
	return TRUE;
}

static gboolean on_expose_cairo(GtkWidget *widget, gpointer data){
	const uint32_t img_w = 120;
	const uint32_t img_h = 120;
	const uint32_t circle_r = 5;
	const double Rad360 = 6.28318530718;
	const double dot_xy[7][2] = {
		{img_w/2, img_h/2}, //center
		{img_w/2, img_h/4}, //top middle
		{img_w/2, img_h*3/4}, //bottom middle
		{img_w/4, img_h/4}, //top left corner
		{img_w*3/4, img_h/4}, //top right
		{img_w/4, img_h*3/4}, //bottom right
		{img_w*3/4, img_h*3/4} //bottom left
	};
	const uint8_t dot_indx[6][7] = {
		{1, 0, 0, 0, 0, 0, 0},
		{0, 0, 0, 1, 0, 0, 1},
		{1, 0, 0, 1, 0, 0, 1},
		{0, 0, 0, 1, 1, 1, 1},
		{1, 0, 0, 1, 1, 1, 1},
		{0, 1, 1, 1, 1, 1, 1}
	};
	//uint32_t num1 = (uint32_t)(*(unsigned char *)data);
	//num1--;
//printf("%u !!!\n", *(unsigned char *)data);
//printf("%u !\n", num1);
	uint32_t num1 = 0;
	uint32_t num2 = 0;

	cairo_t *context;
	cairo_status_t status;

//printf("Should show %u dice\n", gs.rdc);
	//for(num1=0; num1<Dice; num1++){
		//GtkWidget *da_cairo[6];
		// it is global ...

	//context = gdk_cairo_create(GDK_DRAWABLE( widget->window ));
	for(num1=0; num1<gs.Dice; num1++){

		context = gdk_cairo_create(GDK_DRAWABLE( (gtk.da_cairo[num1])->window ));

		//context = gdk_cairo_create(GDK_DRAWABLE( widget[num1]->window ));
		status = cairo_status(context);
		if(status != 0){
			printf("Error: %s\n", cairo_status_to_string(status) );
			cairo_destroy(context);
			return FALSE;
		}

		if(gs.Dice_Selected[num1] == 1){
			cairo_set_source_rgba(context, 0.80, 0.80, 0.80, 1.0);
		}else{
			cairo_set_source_rgba(context, 1.0, 1.0, 1.0, 1.0);
		}

		cairo_rectangle(context, 0, 0, img_w, img_h);
		cairo_fill(context);
		cairo_stroke(context);
		//if(num1 < gs.rdc){
		if(gs.Dice_Blank[num1] != 1){
			cairo_set_source_rgba(context, 0.0, 0.0, 0.0, 1.0);
			for(num2=0; num2<7; num2++){
				//Dice_Values
				if(dot_indx[ (size_t)(gs.Dice_Values[num1])-1 ][num2] == 1){
					cairo_arc(context, dot_xy[num2][0], dot_xy[num2][1], circle_r, 0.0, Rad360);
					cairo_fill(context);
					cairo_stroke(context);
				}
			}
		}

		cairo_destroy(context);
	}
	//cairo_destroy(context);
	return TRUE;
}

/*
static uint8_t Create_Cairo_Dice(void){
	const uint32_t img_w = 120;
	const uint32_t img_h = 120;
	const uint32_t circle_r = 10;
	cairo_format_t format = CAIRO_FORMAT_ARGB32;
	cairo_surface_t *target = cairo_image_surface_create(format, img_w, img_h);
	cairo_t *context;
	cairo_status_t status;

	//double red, green, blue, alpha;
	//double x1, y1, x2, y2;
	//int width
	//int height = 
	//int stride;
	//unsigned char *img_data;
	//stride = cairo_format_stride_for_width(format, width);
	//img_data = malloc (stride * height);
	//target = cairo_image_surface_create_for_data(img_data, format, width, height, stride);
	context = gdk_cairo_create(w_graph->window);
	status = cairo_status(context);
	if(status != 0){
		printf("Error: %s\n", cairo_status_to_string(status) );
		free(img_data);
		return FALSE;
	}
	cairo_set_source_rgba(context, 1.0, 1.0, 1.0, 1.0);
	cairo_rectangle(context, 0, 0, width, height);
	cairo_fill(context);
    //cairo_set_dash(context, 0, 0, 0);
    //cairo_set_source_rgba(context, red, green, blue, alpha);
    //cairo_set_line_width (context, 1);
    //cairo_move_to(context, x1, y1);
    //cairo_line_to(context, x2, y2);
	//arc(xc, yc, lesser / 4.0, 0.0, 2.0 * M_PI);
	cairo_set_source_rgba(context, 0.0, 0.0, 0.0, 1.0);
	cairo_arc(context, img_w/2, img_h/2, circle_r, 0.0, 2.0 * LS_PI);
    //cairo_stroke(context);
	free(img_data);
	return TRUE;
}
*/

//void *GTK_Func(void *data){
void GTK_Func(void){
	//gtk_init(&argc, &argv);
	uint32_t num1 = 0;
	//pco = (struct Player_Conf_Objs *)malloc(sizeof(struct Player_Conf_Objs) * Num_Players);
	//assign pco defaults here
    pco = (struct Player_Conf_Objs *)malloc(sizeof(struct Player_Conf_Objs) * gs.Num_Players);
	//pd = (struct Player_Data *)malloc(sizeof(struct Player_Data) * Num_Players);
	//for(num1=0; num1<Num_Players; num1++){
	//	pd[num1].rseed = 
	//}
    ng_tmps.pd = (struct Player_Data *)malloc(sizeof(struct Player_Data) * gs.Num_Players);
    (void)memcpy((void *)ng_tmps.pd, (const void *)pd, sizeof(struct Player_Data) * gs.Num_Players);

	//extern uint32_t Current_Player;
	//extern uint8_t *Dice_Selections;
	//extern uint8_t *Dice_Values;
	//gs.Cur_Player = 0;
	gs.Dice_Selected = (uint8_t *)malloc(sizeof(uint8_t) * gs.Dice);
	gs.Dice_Values = (uint8_t *)malloc(sizeof(uint8_t) * gs.Dice);
	gs.Dice_Blank = (uint8_t *)malloc(sizeof(uint8_t) * gs.Dice);
	//(void)memset(gs.Dice_Selected, '\0', gs.Dice);
	(void)memset(gs.Dice_Selected, '\0', gs.Dice);
	//(void)memset(gs.Dice_Values, '\0', gs.Dice);
	Blank_Dice();

    //for(num1=0; num1<gs.Dice; num1++){
    //  gs.Dice_Values[num1] = 1;
	//	gs.Dice_Blank[num1] = 1;
    //}
	Reset_Dice_Selection();

	//gtk_init(&argc, &argv);
	gtk.main_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_container_set_border_width(GTK_CONTAINER(gtk.main_win), 2);
	gtk_window_set_default_size(GTK_WINDOW(gtk.main_win), 800, 600);
	gtk_window_set_title(GTK_WINDOW(gtk.main_win), "linuxsociety 10K v0.0.1");
	//= gtk_vpaned_new();
	//gtk.main_table = gtk_table_new(2, 1, TRUE);
	gtk.main_vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(gtk.main_win), gtk.main_vbox);
//GTK_IS_MENU_ITEM (menu_item)
	gtk.main_menubar = gtk_menu_bar_new();
	gtk.main_filemenu = gtk_menu_new();

//file = gtk_menu_item_new_with_mnemonic("_File");
//new = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
//quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group);

	gtk.main_file = gtk_menu_item_new_with_label("File");
	gtk.main_new_game = gtk_menu_item_new_with_label("Start New Game");
	gtk.main_quit = gtk_menu_item_new_with_label("Quit");

	gtk_menu_item_set_submenu(GTK_MENU_ITEM(gtk.main_file), gtk.main_filemenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(gtk.main_filemenu), gtk.main_new_game);
	gtk_menu_shell_append(GTK_MENU_SHELL(gtk.main_filemenu), gtk.main_quit);
	//gtk_menu_shell_append(GTK_MENU_SHELL(gtk.main_menubar), gtk.main_file);
	gtk_menu_shell_append(GTK_MENU_SHELL(gtk.main_menubar), gtk.main_file);
	gtk_box_pack_start(GTK_BOX(gtk.main_vbox), gtk.main_menubar, FALSE, FALSE, 3);


	for(num1=0; num1<gs.Dice; num1++){
		gtk.da_cairo[num1] = gtk_drawing_area_new();
		gtk_widget_set_size_request(gtk.da_cairo[num1], 120, 120);
	}
/*
    cairo_t *context;
    cairo_status_t status;
	for(num1=0; num1<Dice; num1++){
		//GTK_DRAWING_AREA( GDK_DRAWABLE(  GtkDrawingArea*
		context = gdk_cairo_create( GDK_DRAWABLE((gtk.da_cairo[num1])->window) );
		status = cairo_status(context);
		if(status != 0){
			printf("Error: %s\n", cairo_status_to_string(status) );
		}
		cairo_set_source_rgba(context, 1.0, 1.0, 1.0, 1.0);
		cairo_rectangle(context, 0, 0, 120, 120);
		cairo_fill(context);
		cairo_stroke(context);
	}
*/

	//dice area
	gtk.da_vbox = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_end(GTK_BOX(gtk.main_vbox), gtk.da_vbox, TRUE, TRUE, 3);
	gtk.da_top_table = gtk_table_new(1, gs.Dice, TRUE);
	for(num1=0; num1<gs.Dice; num1++){
		gtk.da_event_boxs[num1] = gtk_event_box_new();
		gtk_container_add(GTK_CONTAINER(gtk.da_event_boxs[num1]), gtk.da_cairo[num1]);
		gtk_table_attach(GTK_TABLE(gtk.da_top_table), gtk.da_event_boxs[num1], num1, num1+1, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	}

  //text_view = gtk_text_view_new ();
  //gtk_box_pack_start (GTK_BOX (vbox), text_view, 1, 1, 0);
  //buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
  //gtk_text_buffer_set_text (buffer, "Hello Text View!", -1);

	//text view area for scores/status
	//GTK_TEXT_VIEW (
	gtk.ta_text_tag_lock = gtk_text_tag_new(NULL);
	// "wrap-mode" GTK_WRAP_WORD
	//gtk_text_view_set_editable( GTK_TEXT_VIEW(), FALSE);
	g_object_set(G_OBJECT(gtk.ta_text_tag_lock), "editable", FALSE, NULL);
	//gtk_text_buffer_create_tag(GTK_TEXT_BUFFER(gtk.ta_text_tag_lock), "lock", "editable", FALSE, NULL);

	gtk.ta_text_tag_table = gtk_text_tag_table_new();
	gtk_text_tag_table_add(gtk.ta_text_tag_table, gtk.ta_text_tag_lock);

	//left of tv_hbox
	gtk.ta_status_text_b = gtk_text_buffer_new(gtk.ta_text_tag_table);
	gtk_text_buffer_set_text(gtk.ta_status_text_b, "STATUS: None", -1);
	gtk.ta_status_text_v = gtk_text_view_new_with_buffer(gtk.ta_status_text_b);
	//ta_status_text_b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ta_status_text_v));
	//right of tv_hbox
	gtk.ta_score_text_b = gtk_text_buffer_new(gtk.ta_text_tag_table);
	gtk_text_buffer_set_text(gtk.ta_score_text_b, "SCORES: None", -1);
	gtk.ta_score_text_v = gtk_text_view_new_with_buffer(gtk.ta_score_text_b);
	//ta_score_text_b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ta_score_text_v));

//	gtk_widget_set_size_request(gtk.ta_status_text_v, 240, 320);
//	gtk_widget_set_size_request(gtk.ta_score_text_v, 240, 320);
//gtk_text_buffer_apply_tag(gtk.ta_status_text_b, gtk.ta_text_tag_lock, 0, 600);
//gtk_text_buffer_apply_tag(gtk.ta_score_text_b, gtk.ta_text_tag_lock, 0, 600);
	//tv_hbox
	gtk.tv_hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(gtk.tv_hbox), gtk.ta_status_text_v, FALSE, FALSE, 3);
	gtk_box_pack_end(GTK_BOX(gtk.tv_hbox), gtk.ta_score_text_v, FALSE, FALSE, 3);
	//sw_vbox
	gtk.sw_vbox = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(gtk.sw_vbox), gtk.da_top_table, TRUE, TRUE, 3);
	gtk_box_pack_end(GTK_BOX(gtk.sw_vbox), gtk.tv_hbox, FALSE, FALSE, 3);


	//da_vbox bottom members
	gtk.da_bottom_table = gtk_table_new(1, 2, TRUE);
	gtk.da_roll_button = gtk_button_new_with_label("Roll Dice");
	gtk.da_turn_button = gtk_button_new_with_label("End Turn");
	gtk_table_attach(GTK_TABLE(gtk.da_bottom_table), gtk.da_roll_button, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	gtk_table_attach(GTK_TABLE(gtk.da_bottom_table), gtk.da_turn_button, 1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	//da_vbox top da_scrolled_win
	gtk.da_scrolled_win = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gtk.da_scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(gtk.da_scrolled_win), gtk.sw_vbox);

	gtk_box_pack_start(GTK_BOX(gtk.da_vbox), gtk.da_scrolled_win, TRUE, TRUE, 3);
	gtk_box_pack_end(GTK_BOX(gtk.da_vbox), gtk.da_bottom_table, FALSE, FALSE, 3);












	//gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(gtk.da_scrolled_win), );

	//gtk_container_add(GTK_CONTAINER(gtk.main_win), gtk.da_vbox);

	//gtk_box_pack_end(GTK_BOX(gtk.main_vbox), gtk.main_menubar, TRUE, TRUE, 3);
	//gtk.= gtk_button_new_with_label("Roll Dice");

	//gtk_table_attach(GTK_TABLE(mw.button_containe), mw.button1, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);
	//gtk_table_attach(GTK_TABLE(mw.button_container), mw.button2, 1, 2, 0, 1, GTK_EXPAND|GTK_FILL, 0, GTK_EXPAND|GTK_FILL, 0);

	g_signal_connect(G_OBJECT(gtk.main_new_game), "activate", G_CALLBACK(Create_NewGameWindow), NULL );

	g_signal_connect(gtk.main_win, "destroy", G_CALLBACK(on_destroy), NULL);
	g_signal_connect(G_OBJECT(gtk.main_quit), "activate", G_CALLBACK(on_destroy), NULL);

	for(num1=0; num1<gs.Dice; num1++){
		g_signal_connect(G_OBJECT(gtk.da_event_boxs[num1]), "button-release-event", G_CALLBACK(on_dice_select), (gpointer)(&numbers[num1]) );
		//g_signal_connect(G_OBJECT(gtk.da_cairo[num1]), "expose-event", G_CALLBACK(on_expose_cairo), (gpointer)&(numbers[num1]));
	}

	g_signal_connect(G_OBJECT(gtk.da_roll_button), "clicked", G_CALLBACK(on_dice_roll), NULL);
	g_signal_connect(G_OBJECT(gtk.da_turn_button), "clicked", G_CALLBACK(on_end_turn), NULL);

	g_signal_connect(G_OBJECT(gtk.da_top_table), "expose-event", G_CALLBACK(on_expose_cairo), NULL);
	g_signal_connect(G_OBJECT(gtk.ta_score_text_b), "changed", G_CALLBACK(on_text_refresh), NULL);
	g_signal_connect(G_OBJECT(gtk.ta_status_text_b), "changed", G_CALLBACK(on_text_refresh), NULL);

	gtk_widget_show_all(gtk.main_win);

	//for(num1=0; num1<Dice; num1++){
	//	(void)on_expose_cairo(gtk.da_cairo[num1], (gpointer)&numbers[num1]);
	//}
	gtk_main();
	//free(pd);
	free(ng_tmps.pd);
	free(pco);
	free(gs.Dice_Selected);
	free(gs.Dice_Values);
	free(gs.Dice_Blank);
	//pthread_exit(NULL);
}