Colony

/**

 * @file gtk_gui.c

 * @author Brian Coltin

 *

 * A header file for functions to create and utilize

 * a GUI based on GTK.

 **/

/**

 * Run the GTK GUI. This function is blocking and

 * does not return until the GUI closes.

 *

 * @param argc argc as passed to main

 * @param argv argv as passed to main

 *

 * @return nonzero on failure, or 0 on window closure

 **/

int run_gtk_gui(int argc, char* argv);

#include <math.h>

#include <stdlib.h>

#include <stdio.h>

#include <sys/time.h>

#include <string.h>

#include <gtk/gtkmain.h>

#include <gtk/gtksignal.h>

#include "gtk_environment_view.h"

#define ENVIRONMENT_VIEW_MIN_WIDTH		100

#define ENVIRONMENT_VIEW_MIN_HEIGHT		50

static GtkWidgetClass* parent_class = NULL;

static void gtk_environment_view_class_init(GtkEnvironmentViewClass* environmentClass);

static void gtk_environment_view_init(GtkEnvironmentView* view);

static void gtk_environment_view_destroy(GtkObject* object);

static void gtk_environment_view_size_request(GtkWidget* widget,

		GtkRequisition* req);

static void gtk_environment_view_realize(GtkWidget* widget);

static void gtk_environment_view_size_allocate(GtkWidget* widget, GtkAllocation* a);

static gboolean gtk_environment_view_expose(GtkWidget* widget,

		GdkEventExpose* event);

static gboolean gtk_environment_view_mouse_down(GtkWidget* widget,

				GdkEventButton* event);

static gboolean gtk_environment_view_mouse_release(GtkWidget* widget,

				GdkEventButton* event);

static gboolean gtk_environment_view_mouse_move(GtkWidget* widget,

				GdkEventMotion* event);

static void gtk_environment_view_render_begin(GtkEnvironmentView* view);

static void gtk_environment_view_render_abort(GtkEnvironmentView* view);

static void gtk_environment_view_get_pixel(GtkEnvironmentView* view,

		double x,double y, unsigned char* pixel);

GtkType gtk_environment_view_get_type(void)

{

	static GtkType environment_view_type = 0;

	if (!environment_view_type)

	{

		static const GtkTypeInfo environment_view_info =

		{

			"GtkEnvironmentView",

			sizeof(GtkEnvironmentView),

			sizeof(GtkEnvironmentViewClass),

			(GtkClassInitFunc)gtk_environment_view_class_init,

			(GtkObjectInitFunc)gtk_environment_view_init,

			NULL, NULL, (GtkClassInitFunc)NULL

		};

		environment_view_type = gtk_type_unique(GTK_TYPE_WIDGET,

			&environment_view_info);

	}

	return environment_view_type;

}

static void gtk_environment_view_class_init(GtkEnvironmentViewClass* environmentClass)

{

	GtkObjectClass* object_class;

	GtkWidgetClass* widget_class;

	object_class = (GtkObjectClass*)environmentClass;

	widget_class = (GtkWidgetClass*)environmentClass;

	parent_class = gtk_type_class(gtk_widget_get_type());

	object_class->destroy = gtk_environment_view_destroy;

	widget_class->realize = gtk_environment_view_realize;

	widget_class->expose_event = gtk_environment_view_expose;

	widget_class->size_request = gtk_environment_view_size_request;

	widget_class->size_allocate = gtk_environment_view_size_allocate;

	widget_class->button_press_event = gtk_environment_view_mouse_down;

	widget_class->button_release_event = gtk_environment_view_mouse_release;

	widget_class->motion_notify_event = gtk_environment_view_mouse_move;

}

GtkWidget* gtk_environment_view_new(void)

{

	GtkEnvironmentView* view;

	view = gtk_type_new(gtk_environment_view_get_type());

	return GTK_WIDGET(view);

}

static void gtk_environment_view_init(GtkEnvironmentView* view)

{

	view->buf = NULL;

	view->topLeftX = -2.0;

	view->topLeftY = -1.3;

	view->scale = 2.0 / 800.0;

	view->width = -1;

	view->height = -1;

	view->mouseDown = 0;

}

static void gtk_environment_view_destroy(GtkObject* object)

{

	GtkEnvironmentView* view;

	g_return_if_fail(object != NULL);

	g_return_if_fail(GTK_IS_ENVIRONMENT_VIEW(object));

	view = GTK_ENVIRONMENT_VIEW(object);

	gtk_environment_view_render_abort(view);

	if (view->buf != NULL)

	{

		free(view->buf);

		view->buf = NULL;

		view->width = -1;

		view->height = -1;

	}

	if (GTK_OBJECT_CLASS(parent_class)->destroy)

		(* GTK_OBJECT_CLASS(parent_class)->destroy) (object);

}

static void gtk_environment_view_realize(GtkWidget* widget)

{

	GtkEnvironmentView* view;

	GdkWindowAttr attributes;

	gint attributes_mask;

	g_return_if_fail( widget != NULL);

	g_return_if_fail( GTK_IS_ENVIRONMENT_VIEW(widget));

	GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);

	view = GTK_ENVIRONMENT_VIEW(widget);

	attributes.x = widget->allocation.x;

	attributes.y = widget->allocation.y;

	attributes.width = widget->allocation.width;

	attributes.height = widget->allocation.height;

	attributes.wclass = GDK_INPUT_OUTPUT;

	attributes.window_type = GDK_WINDOW_CHILD;

	attributes.event_mask = gtk_widget_get_events(widget) |

		GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |

		GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |

		GDK_POINTER_MOTION_HINT_MASK;

	attributes.visual = gtk_widget_get_visual(widget);

	attributes.colormap = gtk_widget_get_colormap(widget);

	attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

	widget->window = gdk_window_new(widget->parent->window, &attributes,

			attributes_mask);

	gdk_window_set_user_data(widget->window, widget);

	widget->style = gtk_style_attach(widget->style, widget->window);

	gtk_style_set_background(widget->style, widget->window,

			GTK_STATE_NORMAL);

}

static void gtk_environment_view_size_request(GtkWidget* widget, 

		GtkRequisition* req)

{

	if (req->width < ENVIRONMENT_VIEW_MIN_WIDTH)

		req->width = ENVIRONMENT_VIEW_MIN_WIDTH;

	if (req->height < ENVIRONMENT_VIEW_MIN_HEIGHT)

		req->height = ENVIRONMENT_VIEW_MIN_HEIGHT;

}

static void gtk_environment_view_size_allocate(GtkWidget* widget, GtkAllocation* a)

{

	GtkEnvironmentView* view;

	g_return_if_fail(widget != NULL);

	g_return_if_fail(GTK_IS_ENVIRONMENT_VIEW(widget));

	g_return_if_fail(a != NULL);

	view = GTK_ENVIRONMENT_VIEW(widget);

	gtk_environment_view_render_abort(view);

	widget->allocation = *a;

	// resize buffer

	if (view->buf != NULL)

	{

		free(view->buf);

		view->buf = NULL;

		view->width = -1;

		view->height = -1;

	}

	view->buf = (guchar*)malloc(a->width * a->height * 3 * sizeof(guchar));

	memset(view->buf, 0, a->width * a->height * 3 * sizeof(guchar));

	view->width = a->width;

	view->height = a->height;

	if (GTK_WIDGET_REALIZED(widget))

	{

		gdk_window_move_resize(widget->window, a->x, a->y, a->width, a->height);

		gtk_environment_view_render_begin(view);

	}

}

static gboolean gtk_environment_view_expose(GtkWidget* widget,

		GdkEventExpose* event)

{

	GtkEnvironmentView* view;

	if (widget == NULL || !GTK_IS_ENVIRONMENT_VIEW(widget) || event == NULL)

		return FALSE;

	if (event->count > 0)

		return FALSE;

	view = GTK_ENVIRONMENT_VIEW(widget);

	gdk_draw_rgb_image(widget->window, widget->style->fg_gc[

			GTK_WIDGET_STATE(widget)], event->area.x, 

			event->area.y, event->area.width, 

			event->area.height, GDK_RGB_DITHER_NONE, 

			view->buf + 3 * (event->area.y * view->width + event->area.x),

			3 * view->width);

	return FALSE;

}

static gboolean gtk_environment_view_mouse_down(GtkWidget* widget,

				GdkEventButton* event)

{

	GtkEnvironmentView* view;

	if (widget == NULL || !GTK_IS_ENVIRONMENT_VIEW(widget) || event == NULL)

		return FALSE;

	view = GTK_ENVIRONMENT_VIEW(widget);

	if (event->button != 1)

		return FALSE;

	view->mouseDownX = event->x;

	view->mouseDownY = event->y;

	view->mouseX = event->x;

	view->mouseY = event->y;

	view->mouseDown = 1;

	return FALSE;

}

static gboolean gtk_environment_view_mouse_release(GtkWidget* widget,

				GdkEventButton* event)

{

	GtkEnvironmentView* view;

	double x1, x2, y1, y2;

	int w, h;

	if (widget == NULL || !GTK_IS_ENVIRONMENT_VIEW(widget) || event == NULL)

		return FALSE;

	view = GTK_ENVIRONMENT_VIEW(widget);

	if (event->button != 1 && event->button != 3)

		return FALSE;

	if (event->button == 1)

		view->mouseDown = 0;

	view->mouseX = event->x;

	view->mouseY = event->y;

	w = abs(view->mouseX - view->mouseDownX);

	h = abs(view->mouseY - view->mouseDownY);

	gtk_environment_view_render_abort(view);

	// if the box is big, zoom to the box

	if (event->button == 1 && (w >= 10 || h >= 10))

	{

		// we need to make sure the box is to scale

		// scale to height

		if (fabs((double)w / h) <= fabs((double)view->width / view->height))

		{

			w = (int)((double)view->width / view->height * h);

			if (view->mouseX < view->mouseDownX)

				view->mouseX = view->mouseDownX - w;

			else

				view->mouseX = view->mouseDownX + w;

		}

		// scale to width

		else

		{

			h = (int)((double)view->height / view->width * w);

			if (view->mouseY < view->mouseDownY)

				view->mouseY = view->mouseDownY - h;

			else

				view->mouseY = view->mouseDownY + h;

		}

		x1 = view->mouseX * view->scale + view->topLeftX;

		y1 = view->mouseY * view->scale + view->topLeftY;

		x2 = view->mouseDownX * view->scale + view->topLeftX;

		y2 = view->mouseDownY * view->scale + view->topLeftY;

		if (x2 < x1)

			x1 = x2;

		if (y2 < y1)

			y1 = y2;

		view->scale = (w * view->scale) / view->width;

		view->topLeftX = x1;

		view->topLeftY = y1;

	}

	else

	{

		x1 = view->mouseX * view->scale + view->topLeftX;

		y1 = view->mouseY * view->scale + view->topLeftY;

		// zoom in on left click, out on right click

		if (event->button == 1)

			view->scale /= 2.0;

		else

			view->scale *= 2.0;

		view->topLeftX = x1 - view->width / 2 * view->scale;

		view->topLeftY = y1 - view->height / 2 * view->scale;

	}

	gtk_environment_view_render_begin(view);

	return FALSE;

}

static gboolean gtk_environment_view_mouse_move(GtkWidget* widget,

				GdkEventMotion* event)

{

	GtkEnvironmentView* view;

	if (widget == NULL || !GTK_IS_ENVIRONMENT_VIEW(widget) || event == NULL)

		return FALSE;

	view = GTK_ENVIRONMENT_VIEW(widget);

	view->mouseX = event->x;

	view->mouseY = event->y;

	if (!view->mouseDown)

		return FALSE;

	// we need to make sure the new view is to scale

	int w = abs(view->mouseX - view->mouseDownX);

	int h = abs(view->mouseY - view->mouseDownY);

	// scale to height

	if (fabs((double)w / h) <= fabs((double)view->width / view->height))

	{

		w = (int)((double)view->width / view->height * h);

		if (view->mouseX < view->mouseDownX)

			view->mouseX = view->mouseDownX - w;

		else

			view->mouseX = view->mouseDownX + w;

	}

	// scale to width

	else

	{

		h = (int)((double)view->height / view->width * w);

		if (view->mouseY < view->mouseDownY)

			view->mouseY = view->mouseDownY - h;

		else

			view->mouseY = view->mouseDownY + h;

	}

	gtk_widget_queue_draw_area(widget, 0, 0, view->width, view->height);

	return FALSE;

}

static void* gtk_environment_view_do_work(void* arg)

{

	GtkEnvironmentView* view = (GtkEnvironmentView*)arg;

	GtkWidget* widget = GTK_WIDGET(view);

	int row, col;

	while ((row = gtk_environment_view_acquire_row(view)) >= 0 && view->working)

	{

		int pos = 3 * row * view->width;

		double y = row * view->scale + view->topLeftY;

		double x = view->topLeftX;

		for (col = 0; col < view->width && view->working; col++)

		{

			gtk_environment_view_get_pixel(view, x, y, &view->buf[pos]);

			pos += 3;

			x += view->scale;

		}

		gdk_threads_enter();

		gtk_widget_queue_draw_area(widget, 0, row, view->width, 1);

		gdk_threads_leave();

	}

	view->num_active_threads--;

	// print out time in milliseconds

	if (view->num_active_threads == 0)

	{

		struct timeval t;

		gettimeofday(&t, NULL);

		unsigned int diff = (t.tv_sec - view->starttime.tv_sec) * 1000 +

							(t.tv_usec - view->starttime.tv_usec) / 1000;

		printf("Generated in %d milliseconds.\n", diff);

	}

	return NULL;

}

// spawn worker threads

static void gtk_environment_view_render_begin(GtkEnvironmentView* view)

{

	int i;

	view->working = 1;

	view->cur_row = 0;

	view->num_active_threads = NUM_THREADS;

	gettimeofday(&view->starttime, NULL);

	for (i = 0; i < NUM_THREADS; i++)

		view->worker_threads[i] = g_thread_create(

				gtk_environment_view_do_work, view, TRUE, NULL);

}

static void gtk_environment_view_render_abort(GtkEnvironmentView* view)

{

	int i;

	if (view->working)

	{

		view->working = 0;

		gdk_threads_leave();

		for (i = 0; i < NUM_THREADS; i++)

			g_thread_join(view->worker_threads[i]);

		gdk_threads_enter();

	}

}

#ifndef __ENVIRONMENT_VIEW_H__

#define __ENVIRONMENT_VIEW_H__

#include <gdk/gdk.h>

#include <gtk/gtkwidget.h>

#include <pthread.h>

#include <time.h>

#define GTK_ENVIRONMENT_VIEW(obj)		GTK_CHECK_CAST(obj, \

									gtk_environment_view_get_type(), GtkEnvironmentView)

#define GTK_ENVIRONMENT_VIEW_CLASS(kclass)	GTK_CHECK_CLASS_CAST ( \

										kclass, gtk_environment_view_get_type(), \

										GtkEnvironmentViewClass)

#define GTK_IS_ENVIRONMENT_VIEW(obj)		GTK_CHECK_TYPE(obj, \

										gtk_environment_view_get_type())

#define NUM_THREADS		4

struct _GtkEnvironmentView

{

	GtkWidget widget;

	int width;

	int height;

	guchar* buf;

	double topLeftX;

	double topLeftY;

	double scale;

	int mouseDownX;

	int mouseDownY;

	int mouseX;

	int mouseY;

	int mouseDown;

};

struct _GtkEnvironmentViewClass

{

	GtkWidgetClass parent_class;

};

typedef struct _GtkEnvironmentView GtkEnvironmentView;

typedef struct _GtkEnvironmentViewClass GtkEnvironmentViewClass;

GtkWidget* gtk_environment_view_new(void);

GtkType gtk_environment_view_get_type(void);

#endif

#include <stdlib.h>

#include <gtk/gtk.h>

#include <glib.h>

#include "gtk_gui.h"

void destroy_callback(int arg)

{

	gtk_main_quit();

}

int gtk_gui_run(int argc, char* argv[])

{

	GtkWidget* window;

	GtkWidget* view;

	g_thread_init(NULL);

	gdk_threads_init();

	gdk_threads_enter();

	gtk_init(&argc, &argv);

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	gtk_window_set_title(GTK_WINDOW(window), "Colony Simulator");

	gtk_window_maximize(GTK_WINDOW(window));

	//g_signal_connect(G_OBJECT(window), "delete_event",

	//		G_CALLBACK(delete_event), NULL);

	g_signal_connect(G_OBJECT(window), "destroy",

			G_CALLBACK(destroy_callback), NULL);

	gtk_container_set_border_width(GTK_CONTAINER(window), 0);

	view = gtk_environment_view_new();

	gtk_container_add(GTK_CONTAINER(window), view);

	gtk_widget_show(view);

	gtk_widget_show(window);

	gtk_main();

	gdk_threads_leave();

	return 0;

}

SRCS := main.c gtk_fractal_view.c

OBJS := $(patsubst %.c, %.o, $(SRCS))

PROG := simulator

CFLAGS := -Wall

CFLAGS += `pkg-config --cflags gtk+-2.0 gthread-2.0`

LDFLAGS :=

LDFLAGS += `pkg-config --libs gtk+-2.0 gthread-2.0`

CC := gcc

all: $(OBJS)

	$(CC) $(CFLAGS) $(LDFLAGS) -o $(PROG) $(OBJS)

%.o: %.c %.h

	$(CC) $(CFLAGS) -c -o $@ $<

clean:

	rm *~ *.o $(PROG)