/ - Diff - Colony - Robotics Club

     void dragonfly_init(int config)
+    {
       struct itimerval iv;
       int ret;
       shared_state = shmat(atoi(getenv("memory_id")), NULL, 0);
       if(shared_state < 0)
-...
+    {
          if(raise(SIGTSTP)<0)
               fprintf(stderr, "ERROR: could not kill self\n");
+    }
+    }

     #include "gtk_gui.h"
     #include "gtk_environment_view.h"
     #include "robot.h"
     #define NEW_ROBOT 1
     #define PAUSE 2
     #define RESUME 3
     GtkWidget* window;
     GtkWidget* view = NULL;
     void destroy_callback(int arg)
+    {
     	robots_cleanup();
     	gtk_main_quit();
+    }
     void make_new_robot(void)
+    {
     	GtkWidget *dialog;
     	gdk_threads_leave();
     	robots_pause();
     	gdk_threads_enter();
     	dialog = gtk_file_chooser_dialog_new ("Open File",
     		GTK_WINDOW(window),
     		GTK_FILE_CHOOSER_ACTION_OPEN,
     		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
     		GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
     		NULL);
     	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
+    	{
     		char *filename;
     		filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
     		robot_create(filename);
     		g_free (filename);
+    	}
     	gtk_widget_destroy (dialog);
     	gdk_threads_leave();
     	robots_resume();
     	gdk_threads_enter();
+    }
     static gboolean menuhandler(int type)
+    {
     	switch (type)
+    	{
     		case NEW_ROBOT:
     			make_new_robot();
     			break;
     		case PAUSE:
     			gdk_threads_leave();
     			robots_pause();
     			gdk_threads_enter();
     			break;
     		case RESUME:
     			gdk_threads_leave();
     			robots_resume();
     			gdk_threads_enter();
     			break;
+    	}
     	return TRUE;
+    }
     GtkWidget* make_menu_bar(GtkWidget* window, GtkWidget* other)
+    {
     	GtkWidget* menu_bar;
     	GtkWidget* file_item;
     	GtkWidget* file_menu;
     	GtkWidget* menu_item;
     	GtkWidget* vbox;
     	file_menu = gtk_menu_new();
     	gtk_widget_show(file_menu);
     	menu_item = gtk_menu_item_new_with_label("New Robot");
     	gtk_widget_show(menu_item);
     	gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_item);
     	g_signal_connect_swapped(G_OBJECT(menu_item), "activate",
     		G_CALLBACK(menuhandler), (gint*)NEW_ROBOT);
     	menu_item = gtk_menu_item_new_with_label("Pause");
     	gtk_widget_show(menu_item);
     	gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_item);
     	g_signal_connect_swapped(G_OBJECT(menu_item), "activate",
     		G_CALLBACK(menuhandler), (gint*)PAUSE);
     	menu_item = gtk_menu_item_new_with_label("Resume");
     	gtk_widget_show(menu_item);
     	gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_item);
     	g_signal_connect_swapped(G_OBJECT(menu_item), "activate",
     		G_CALLBACK(menuhandler), (gint*)RESUME);
     	file_item = gtk_menu_item_new_with_label("File");
     	gtk_widget_show(file_item);
     	gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu);
     	menu_bar = gtk_menu_bar_new();
     	vbox = gtk_vbox_new (FALSE, 0);
     	gtk_container_add (GTK_CONTAINER (window), vbox);
     	gtk_widget_show (vbox);
     	gtk_box_pack_start (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 2);
     	gtk_widget_show(menu_bar);
     	gtk_box_pack_end (GTK_BOX (vbox), other, TRUE, TRUE, 2);
     	gtk_widget_show(other);
     	gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file_item);
     	return menu_bar;
+    }
     int gtk_gui_run(int argc, char** argv)
+    {
     	//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);
     	gtk_container_set_border_width(GTK_CONTAINER(window), 0);
     	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);
     	make_menu_bar(window, view);
     	gtk_widget_show(window);
     	gtk_main();

     	robot_create(argv[optind]);
     	/*robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
-...
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);
     	robot_create(argv[optind]);*/
     	sigset_t set;

     pthread_cond_t all_finished_cond;
     int finished = 0;
     int pausing = 0;
     int paused = 0;
     int robots_initialize(void)
+    {
     	int i;
-...
     	return 0;
+    }
     int robots_cleanup(void)
+    {
     	robots_pause();
     	//TODO: clean things up
     	return 0;
+    }
     void robots_pause(void)
+    {
     	pausing = 1;
     	while (!paused) usleep(10000);
+    }
     void robots_resume(void)
+    {
     	pausing = 0;
+    }
     /**
      * Creates a new robot. Returns its id on
      * success, or a negative integer on failure.
-...
     			  err(errno, "error waiting on condition variable");
+    		}
     		finished = 0;
     		ret = pthread_mutex_unlock(&all_finished_mutex);
         //sleep to avoid 100% CPU usage
         usleep(10000);
     		//sleep to avoid 100% CPU usage
     		usleep(10000);
     		while (pausing)
+    		{
     			paused = 1;
     			usleep(50000);
+    		}
     		paused = 0;
     		ret = pthread_mutex_unlock(&all_finished_mutex);
     		if(ret)
     		  fprintf(stderr, "hmmm, error unlocking. errno: %d", errno);
-...
+    			{
     				robot_update(i);
     				printf("commit %d\n", i);
     				commit(&robots[i],i,timeStep);
+    			}
     		for (i = 0; i < robots_size; i++)
-...
     			  warn("error: could not kill resume robot proc.");
+    		}
     		gui_refresh();
     		if (timeStep % 5 == 0)
     			gui_refresh();
+    	}
+    }

     } Robot;
     int robots_initialize(void);
     int robots_cleanup(void);
     int robot_create(char *execname);
     int robot_destroy(int id);
-...
     void* robot_event_loop(void* arg);
     void* logger_step_loop(void* arg);
     void robots_pause(void);
     void robots_resume(void);
     #endif

Project

General

Profile

Colony

Revision 1074