mappix/mappix-ui.c

/*
 *  mappix-ui
 *
 *  Copyright (C) 2006,2007 Nils Faerber <nils.faerber@kernelconcepts.de>
 *
 *
 *  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 St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


#include "mappix.h"

#include "geo-tools.h"

#define DEFAULT_WINDOW_WIDTH 640
#define DEFAULT_WINDOW_HEIGHT 480



gint
do_preference_dialog (GtkWidget *pw, gpointer userdata)
{
mapwin *Mapper = (mapwin *)userdata;
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *stock;
GtkWidget *table;
GtkWidget *mtype[4];
GtkWidget *spinb_marker_size;
GtkWidget *spinb_line_width;
GtkWidget *idledraw_toggle;
GtkWidget *label;
GtkWidget *w;
gint result;

	dialog = gtk_dialog_new_with_buttons("Preferences", GTK_WINDOW(gtk_widget_get_toplevel(Mapper->mainwin)),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_STOCK_OK,
			GTK_RESPONSE_ACCEPT,
			GTK_STOCK_CANCEL,
			GTK_RESPONSE_REJECT,
			NULL);

	hbox = gtk_hbox_new (FALSE, 8);
	gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
	gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0);

	stock = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
	gtk_box_pack_start (GTK_BOX (hbox), stock, FALSE, FALSE, 0);

	table = gtk_table_new (2, 4, FALSE);
	gtk_table_set_row_spacings (GTK_TABLE (table), 4);
	gtk_table_set_col_spacings (GTK_TABLE (table), 4);
	gtk_table_set_homogeneous(GTK_TABLE (table), FALSE);
	gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0);

	label = gtk_label_new ("Marker mode");
	gtk_table_attach_defaults (GTK_TABLE (table),
			label,
			0, 1, 0, 1);
	w = gtk_vbox_new(FALSE, 2);
	gtk_table_attach_defaults (GTK_TABLE (table), w, 1, 2, 0, 1);
	mtype[0] = gtk_radio_button_new_with_label(NULL, "None");
	mtype[1] = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(mtype[0])), "Filled Square");
	mtype[2] = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(mtype[0])), "Square");
	mtype[3] = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(mtype[0])), "Cross");
	gtk_container_add(GTK_CONTAINER(w), mtype[0]);
	gtk_container_add(GTK_CONTAINER(w), mtype[1]);
	gtk_container_add(GTK_CONTAINER(w), mtype[2]);
	gtk_container_add(GTK_CONTAINER(w), mtype[3]);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mtype[Mapper->marker_type]), TRUE);

	label = gtk_label_new ("Marker size");
	gtk_table_attach_defaults (GTK_TABLE (table),
			label,
			0, 1, 1, 2);

	spinb_marker_size = gtk_spin_button_new_with_range(0, 100, 1);
	gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinb_marker_size), Mapper->marker_size);
	gtk_table_attach_defaults (GTK_TABLE (table), spinb_marker_size, 1, 2, 1, 2);
  
	label = gtk_label_new ("Line width");
	gtk_table_attach_defaults (GTK_TABLE (table),
			label,
			0, 1, 2, 3);

	spinb_line_width = gtk_spin_button_new_with_range(0, 100, 1);
	gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinb_line_width), Mapper->linewidth);
	gtk_table_attach_defaults (GTK_TABLE (table), spinb_line_width, 1, 2, 2, 3);

	label = gtk_label_new ("Draw in background");
	gtk_table_attach_defaults (GTK_TABLE (table),
			label,
			0, 1, 3, 4);

	idledraw_toggle = gtk_check_button_new();
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(idledraw_toggle), Mapper->use_idledraw);
	gtk_table_attach_defaults (GTK_TABLE (table), idledraw_toggle, 1, 2, 3, 4);

	gtk_widget_show_all (hbox);

	result = gtk_dialog_run (GTK_DIALOG (dialog));
	gtk_widget_hide (dialog);

	switch (result) {
		gint i;
		case GTK_RESPONSE_ACCEPT:
			/* one of three MUST be selected */
			for (i=0; i<=3; i++)
				if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mtype[i])))
					Mapper->marker_type = i;
			Mapper->marker_size = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinb_marker_size));
			Mapper->linewidth = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spinb_line_width));
			Mapper->use_idledraw = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(idledraw_toggle));
			draw_tracks(Mapper);
			break;
		default:
			break;
	}
	gtk_widget_destroy (dialog);


return result;
}


gint close_application(GtkWidget *widget, GdkEvent *event, gpointer userdata)
{
mapwin *Mapper = (mapwin *)userdata;

	if (Mapper->modified) {
		/* ask for exit confirmation */
	}
	gtk_main_quit ();

return FALSE;
}


gboolean
mappix_configure(GtkWidget *w, GdkEventConfigure *event, gpointer userdata)
{
mapwin *Mapper = (mapwin *)userdata;
GdkRectangle grect;

	// fprintf(stderr,"conf w:%d h:%d\n", event->width, event->height);

	if (Mapper->mappix != NULL) {
		g_object_unref(Mapper->mappix);
		g_object_unref(Mapper->mappix_blank);
	}
	Mapper->canvas_x = event->width;
	Mapper->canvas_y = event->height;
	Mapper->mappix = gdk_pixmap_new(GDK_DRAWABLE(w->window), Mapper->canvas_x, Mapper->canvas_y, -1);
	Mapper->mappix_blank = gdk_pixmap_new(GDK_DRAWABLE(w->window), Mapper->canvas_x, Mapper->canvas_y, -1);

	gdk_draw_rectangle(Mapper->mappix, w->style->white_gc, 1, 0, 0, Mapper->canvas_x, Mapper->canvas_y);
	gdk_draw_rectangle(Mapper->mappix_blank, w->style->white_gc, 1, 0, 0, Mapper->canvas_x, Mapper->canvas_y);

	grect.x = 0;
	grect.y = 0;
	grect.width = Mapper->canvas_x-1;
	grect.height = Mapper->canvas_y-1;
	gdk_gc_set_clip_rectangle(Mapper->red_gc, &grect);
	gdk_gc_set_clip_origin(Mapper->red_gc, 0, 0);
	gdk_gc_set_clip_rectangle(Mapper->blue_gc, &grect);
	gdk_gc_set_clip_origin(Mapper->blue_gc, 0, 0);
	gdk_gc_set_clip_rectangle(Mapper->select_gc, &grect);
	gdk_gc_set_clip_origin(Mapper->select_gc, 0, 0);
	gdk_gc_set_clip_rectangle(Mapper->drawarea->style->black_gc, &grect);
	gdk_gc_set_clip_origin(Mapper->drawarea->style->black_gc, 0, 0);

	do_redraw(Mapper);

return TRUE;
}


gboolean
mappix_expose(GtkWidget *w, GdkEventExpose *event, gpointer userdata)
{
mapwin *Mapper = (mapwin *)userdata;
gint areax, areay, width, height;

	// fprintf(stderr,"exp\n");

	if (Mapper->move_selection) {
			return TRUE;
	}
	areax = event->area.x;
	areay = event->area.y;
	width = event->area.width;
	height = event->area.height;
	// fprintf(stderr,"exp x,y,w,h: %d, %d, %d, %d\n", areax, areay, width, height);
	gdk_draw_drawable(w->window, w->style->fg_gc[GTK_WIDGET_STATE(w)], Mapper->mappix,
			areax, areay,
			areax, areay,
			-1 /*width*/, -1 /*height*/);

return TRUE;
}


gboolean
mappix_drfocus_in(GtkWidget *w, GdkEventCrossing *event, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;

	// fprintf(stderr,"drawing-area enter\n");
	switch (Mapper->toolmode) {
		case MAPPIX_TOOL_NONE:
			gdk_window_set_cursor(Mapper->mainwin->window, Mapper->cursor_normal);
			break;
		case MAPPIX_TOOL_ZOOM_REGION:
		case MAPPIX_TOOL_SELECT_REGION:
			gdk_window_set_cursor(Mapper->mainwin->window, Mapper->cursor_crosshair);
			break;
		case MAPPIX_TOOL_MOVE:
			gdk_window_set_cursor(Mapper->mainwin->window, Mapper->cursor_mover);
			break;
		case MAPPIX_TOOL_SELECT_TRACKPOINT:
			gdk_window_set_cursor(Mapper->mainwin->window, Mapper->cursor_select);
		case MAPPIX_TOOL_MOVE_TRACKPOINT:
			gdk_window_set_cursor(Mapper->mainwin->window, Mapper->cursor_select);
		default:
			break;
	}

return TRUE;
}


gboolean
mappix_drfocus_out(GtkWidget *w, GdkEventCrossing *event, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;

	// fprintf(stderr,"drawing-area leave\n");
	gdk_window_set_cursor(Mapper->mainwin->window, Mapper->cursor_normal);

return TRUE;
}


void
create_file_selection (GtkButton *widget, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;
GtkWidget *fchooser;
GtkFileFilter *filter;

	fchooser = gtk_file_chooser_dialog_new("Open GPX file",
		GTK_WINDOW(Mapper->mainwin), GTK_FILE_CHOOSER_ACTION_OPEN,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
		NULL);
	filter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(filter, "*.gpx");
	gtk_file_filter_set_name(filter, "GPX file");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fchooser), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(filter, "*");
	gtk_file_filter_set_name(filter, "All files");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fchooser), filter);

	/* Display that dialog */
	gtk_widget_show (fchooser);
	if (gtk_dialog_run (GTK_DIALOG(fchooser)) == GTK_RESPONSE_ACCEPT) {
		draw_filename(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (fchooser)), Mapper);
	}
	gtk_widget_destroy(fchooser);
}


void
on_save_gpxfile (GtkButton *widget, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;
GtkWidget *fchooser;
GtkFileFilter *filter;

	fchooser = gtk_file_chooser_dialog_new("Save project to GPX file",
		GTK_WINDOW(Mapper->mainwin), GTK_FILE_CHOOSER_ACTION_SAVE,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
		NULL);
	filter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(filter, "*.gpx");
	gtk_file_filter_set_name(filter, "GPX file");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fchooser), filter);
	filter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(filter, "*");
	gtk_file_filter_set_name(filter, "All files");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fchooser), filter);

	/* Display that dialog */
	gtk_widget_show (fchooser);
	if (gtk_dialog_run (GTK_DIALOG(fchooser)) == GTK_RESPONSE_ACCEPT) {
		save_project_to_file(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (fchooser)), Mapper);
	}
	gtk_widget_destroy(fchooser);
}


void
draw_selectbox(mapwin *Mapper, gint x, gint y, gboolean update, gboolean start_new)
{
static gint origin_x, origin_y;
static gint old_x, old_y;

	if (start_new) {
		origin_x = -1;
		origin_y = -1;
		old_x = -1;
		old_y = -1;
		return;
	}
	if (update) {
		if (origin_x == -1 && origin_y == -1) {
			origin_x = x;
			origin_y = y;
			return;
		}
		if (old_x != -1 && old_y != -1)
			gdk_draw_rectangle(Mapper->mappix, Mapper->select_gc, FALSE, MIN(origin_x, old_x), MIN(origin_y, old_y), ABS(old_x - origin_x), ABS(old_y - origin_y));
		gdk_draw_rectangle(Mapper->mappix, Mapper->select_gc, FALSE, MIN(origin_x, x), MIN(origin_y, y), ABS(x - origin_x), ABS(y - origin_y));
		gtk_widget_queue_draw(Mapper->drawarea);
		old_x = x;
		old_y = y;
		return;
	}
	if (old_x != -1 && old_y != -1)
		gdk_draw_rectangle(Mapper->mappix, Mapper->select_gc, FALSE, MIN(origin_x, old_x), MIN(origin_y, old_y), ABS(old_x - origin_x), ABS(old_y - origin_y));
}


static gboolean
button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;
static guint press_x, press_y;
static guint release_x, release_y;

	// we only want button 1
	if (event->button != 1)
		return TRUE;
	switch (Mapper->toolmode) {
		case MAPPIX_TOOL_SELECT_REGION:
			if (event->type == GDK_BUTTON_PRESS) {
				// fprintf(stderr,"press: ");
				press_x = Mapper->pointer_x;
				press_y = Mapper->pointer_y;
				draw_selectbox(Mapper, 0, 0, FALSE, TRUE);
				Mapper->draw_selection = TRUE;
			}
			if (event->type == GDK_BUTTON_RELEASE) {
				// fprintf(stderr,"release: ");
				release_x = Mapper->pointer_x;
				release_y = Mapper->pointer_y;
				draw_selectbox(Mapper, 0, 0, FALSE, FALSE);
				Mapper->draw_selection = FALSE;
				gtk_widget_queue_draw(Mapper->drawarea);
				do_trackpoint_region_select(press_x, press_y, release_x, release_y, Mapper);
			}
			// fprintf(stderr, "%d %d %lf %lf\n", event->button, event->state, Mapper->pointer_long, Mapper->pointer_lat);
			break;
		case MAPPIX_TOOL_ZOOM_REGION:
			if (event->type == GDK_BUTTON_PRESS) {
				// fprintf(stderr,"press: ");
				press_x = Mapper->pointer_x;
				press_y = Mapper->pointer_y;
				draw_selectbox(Mapper, 0, 0, FALSE, TRUE);
				Mapper->draw_selection = TRUE;
			}
			if (event->type == GDK_BUTTON_RELEASE) {
				// fprintf(stderr,"release: ");
				release_x = Mapper->pointer_x;
				release_y = Mapper->pointer_y;
				if (release_x > press_x) {
					Mapper->xmin = press_x;
					Mapper->xmax = release_x;
				} else {
					Mapper->xmin = release_x;
					Mapper->xmax = press_x;
				}
				if (release_y > press_y) {
					Mapper->ymin = press_y;
					Mapper->ymax = release_y;
				} else {
					Mapper->ymin = release_y;
					Mapper->ymax = press_y;
				}
				// calculate new scale factor for zoomed square
				draw_selectbox(Mapper, 0, 0, FALSE, FALSE);
				change_scale(Mapper, do_calc_scale(Mapper));
				// draw_tracks(Mapper);
				// gtk_widget_queue_draw(Mapper->drawarea);
				Mapper->draw_selection = FALSE;
			}
			// fprintf(stderr, "%d %d %lf %lf\n", event->button, event->state, Mapper->pointer_long, Mapper->pointer_lat);
			break;
		case MAPPIX_TOOL_MOVE:
			if (event->type == GDK_BUTTON_PRESS) {
				press_x = Mapper->pointer_x;
				press_y = Mapper->pointer_y;
				Mapper->mouse_px = Mapper->mouse_x;
				Mapper->mouse_py = Mapper->mouse_y;
				Mapper->move_selection = TRUE;
			}
			if (event->type == GDK_BUTTON_RELEASE) {
				Mapper->move_selection = FALSE;
				release_x = Mapper->pointer_x;
				release_y = Mapper->pointer_y;
				Mapper->xoffset = Mapper->xoffset + (press_x - release_x);
				Mapper->yoffset = Mapper->yoffset + (press_y - release_y);
				Mapper->xmin = Mapper->xoffset;
				Mapper->ymin = Mapper->yoffset;
				Mapper->xmax = Mapper->xmin + (Mapper->canvas_x / Mapper->scale);
				Mapper->ymax = Mapper->ymin + (Mapper->canvas_y / Mapper->scale);
				change_scale(Mapper, Mapper->scale);
			}
			break;
		case MAPPIX_TOOL_SELECT_TRACKPOINT:
			if (event->type == GDK_BUTTON_RELEASE) {
				release_x = Mapper->pointer_x;
				release_y = Mapper->pointer_y;
				do_select_trackpoint(release_x, release_y, Mapper);
			}
			break;
		case MAPPIX_TOOL_MOVE_TRACKPOINT:
			if (event->type == GDK_BUTTON_PRESS) {
				press_x = Mapper->pointer_x;
				press_y = Mapper->pointer_y;
			}
			if (event->type == GDK_BUTTON_RELEASE) {
				release_x = Mapper->pointer_x;
				release_y = Mapper->pointer_y;
				do_move_trackpoint(press_x, press_y, release_x, release_y, Mapper);
			}
			break;
		default:
			break;
	}

return TRUE;
}


static gboolean
motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;
gint x, y;
GdkModifierType state;
static gchar statlabel[256];
static guint ox, oy;

	if (event->is_hint)
		gdk_window_get_pointer (event->window, &x, &y, &state);
	else {
		x = event->x;
		y = event->y;
		state = event->state;
	}

	/* if scale is not yet set we cannot scale */
	if (Mapper->scale) {
		Mapper->pointer_x = (x / Mapper->scale) + Mapper->xoffset;
		Mapper->pointer_y = (y / Mapper->scale) + Mapper->yoffset;
	}
	Mapper->mouse_x = x;
	Mapper->mouse_y = y;

	if (Mapper->draw_selection)
		draw_selectbox(Mapper, x, y, TRUE, FALSE);

	if (Mapper->move_selection) {
		if (ox != x || oy != y) {
			guint delta_x, delta_y;
			delta_x = x - Mapper->mouse_px;
			delta_y = y - Mapper->mouse_py;
			gdk_draw_drawable(Mapper->drawarea->window, Mapper->drawarea->style->fg_gc[GTK_WIDGET_STATE(Mapper->drawarea)], Mapper->mappix_blank,
				0, 0,
				0, 0,
				-1 /*width*/, -1 /*height*/);
			gdk_draw_drawable(Mapper->drawarea->window, Mapper->drawarea->style->fg_gc[GTK_WIDGET_STATE(Mapper->drawarea)], Mapper->mappix,
				0, 0,
				delta_x, delta_y,
				-1 /*width*/, -1 /*height*/);
			//gtk_widget_queue_draw(Mapper->drawarea);
		}
	}

	ox=x; oy=y;

	sprintf(statlabel, "lat: %d  long: %d scale: %lf", Mapper->pointer_x, Mapper->pointer_y, Mapper->scale);
	gtk_statusbar_pop(GTK_STATUSBAR(Mapper->statbar), Mapper->lstatid);
	Mapper->lstatid = gtk_statusbar_get_context_id(GTK_STATUSBAR(Mapper->statbar), "pcoord");
	gtk_statusbar_push(GTK_STATUSBAR(Mapper->statbar), Mapper->lstatid, statlabel);

return TRUE;
}


static void
track_show_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;
GtkTreeModel *model; // = (GtkTreeModel *)data;
GtkTreeIter  iter;
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
// gboolean show;
track_head *trackh;

	model = gtk_tree_view_get_model(GTK_TREE_VIEW(Mapper->track_treeview));
	gtk_tree_model_get_iter (model, &iter, path);
	gtk_tree_model_get (model, &iter, 2, &trackh, -1);
	trackh->show ^= 1;
	gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, trackh->show, -1);
	gtk_tree_path_free (path);
	do_redraw(Mapper);
}


static void
do_show_waypoints_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;

	Mapper->show_waypoints = gtk_check_menu_item_get_active(checkmenuitem);
	if (Mapper->show_waypoints)
		draw_waypoints(Mapper);
	else
		do_redraw(Mapper);
}


static void
do_show_cities_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;

	Mapper->show_cities = gtk_check_menu_item_get_active(checkmenuitem);
	if (Mapper->show_cities)
		draw_city_names(Mapper);
	else
		do_redraw(Mapper);
}


static void
do_show_markers_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;

	Mapper->show_marker = gtk_check_menu_item_get_active(checkmenuitem);
	do_redraw(Mapper);
}


static void
do_show_scale_toggled(GtkCheckMenuItem *checkmenuitem, gpointer user_data)
{
mapwin *Mapper = (mapwin *)user_data;

	Mapper->show_scale = gtk_check_menu_item_get_active(checkmenuitem);
	if (Mapper->show_scale)
		draw_scale(Mapper);
	else
		do_redraw(Mapper);
}


static void
add_columns (GtkTreeView *treeview, mapwin *Mapper)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
// GtkTreeModel *model;

	// model = gtk_tree_view_get_model(Mapper->track_treeview);
	renderer = gtk_cell_renderer_toggle_new ();
	g_signal_connect (renderer, "toggled", G_CALLBACK (track_show_toggled), Mapper);
	column = gtk_tree_view_column_new_with_attributes ("Show", renderer, "active", 0, NULL);
	gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
	gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50);
	gtk_tree_view_append_column (treeview, column);

	renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", 1, NULL);
	// gtk_tree_view_column_set_sort_column_id (column, 1);
	gtk_tree_view_set_search_column (treeview, 1);
	gtk_tree_view_append_column (treeview, column);
}


static GtkWidget
*load_icon(gchar *filename)
{
GdkPixbuf *gpbuf;
gchar *sfname1, *sfname2;

	sfname1 = g_strdup(PREFIX);
	sfname2 = g_strconcat(sfname1, filename, NULL);
	gpbuf = gdk_pixbuf_new_from_file(sfname2, NULL);
	g_free(sfname1);
	g_free(sfname2);
	if (gpbuf == NULL) {
		gpbuf = gdk_pixbuf_new_from_file(filename, NULL);
	}
	if (gpbuf == NULL)
		return NULL;

return gtk_image_new_from_pixbuf(gpbuf);
}


/* OK, this will do the nasty work of creating the UI of the main window
 * Be careful when changing since order does matter!
 */
int
create_main_window(mapwin *Mapper)
{
GtkWidget *mainmenu;
GtkWidget *mvb, *mhb, *w;
GtkWidget *filemenu, *editmenu, *algomenu, *viewmenu, *toolsmenu, *mitem;
GtkWidget *tb;		// toolbar
GtkToolItem *ti;	// tool-item
GtkTooltips *tt;	// tooltip
GtkWidget *mim;		// menu item
GtkStyle *style;
GtkTreeModel *tree_model;
GdkColor color;


	/* initialize some private data to sane defaults */
#ifdef HILDON
	Mapper->hildon_app = NULL;
	Mapper->hildon_mainview = NULL;
#endif
	/* pixmap for drawing */
	Mapper->mappix = NULL;
	/* default canvas size */
	Mapper->canvas_x = 640;
	Mapper->canvas_y = 480;
	/* default line drawing parameters */
	Mapper->linewidth = 1;
	Mapper->marker_type = 1; // square (faster)
	Mapper->marker_size = 3;
	/* default scale factors */
	Mapper->xscale = 0;
	Mapper->yscale = 0;
	Mapper->scale = 0;
	Mapper->xoffset = 0;
	Mapper->yoffset = 0;
	Mapper->xmin=WORLD_SIZE_UNITS;
	Mapper->xmax=0;
	Mapper->ymin=WORLD_SIZE_UNITS;
	Mapper->ymax=0;
	Mapper->toolmode = MAPPIX_TOOL_ZOOM_REGION;
	Mapper->modified = FALSE;
	Mapper->use_idledraw = FALSE;
	Mapper->draw_selection = FALSE;
	Mapper->move_selection = FALSE;
	Mapper->show_marker = FALSE;
	Mapper->show_waypoints = TRUE;
	Mapper->show_cities = TRUE;
	Mapper->show_scale = TRUE;

#ifdef HILDON
	Mapper->hildon_app = HILDON_APP(hildon_app_new());
	Mapper->hildon_mainview = HILDON_APPVIEW(hildon_appview_new("main_view"));
	hildon_app_set_appview(Mapper->hildon_app, Mapper->hildon_mainview);
	hildon_app_set_title(Mapper->hildon_app, "Mappix");
	Mapper->mainwin = GTK_WIDGET(Mapper->hildon_mainview);
#else
	Mapper->mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	g_signal_connect (G_OBJECT (Mapper->mainwin), "delete_event",
			G_CALLBACK (close_application), NULL);
	gtk_container_set_border_width (GTK_CONTAINER (Mapper->mainwin), 1);
	gtk_window_set_default_size(GTK_WINDOW(gtk_widget_get_toplevel(Mapper->mainwin)), DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT);
#endif
	Mapper->cursor_normal = gdk_cursor_new_for_display(gtk_widget_get_display(Mapper->mainwin), GDK_LEFT_PTR);
	Mapper->cursor_mover = gdk_cursor_new_for_display(gtk_widget_get_display(Mapper->mainwin), GDK_FLEUR);
	Mapper->cursor_crosshair = gdk_cursor_new_for_display(gtk_widget_get_display(Mapper->mainwin), GDK_CROSSHAIR);
	Mapper->cursor_hand = gdk_cursor_new_for_display(gtk_widget_get_display(Mapper->mainwin), GDK_HAND2);
	Mapper->cursor_select = gdk_cursor_new_for_display(gtk_widget_get_display(Mapper->mainwin), GDK_RIGHT_PTR);

	style = gtk_widget_get_style (Mapper->mainwin);

	mvb = gtk_vbox_new(FALSE, 0);
	gtk_container_add (GTK_CONTAINER (Mapper->mainwin), mvb);
	gtk_widget_show(mvb);

#ifdef HILDON
	mainmenu = GTK_WIDGET(hildon_appview_get_menu( HILDON_APPVIEW(Mapper->hildon_mainview)));
#else
	mainmenu = gtk_menu_bar_new();
	gtk_container_add (GTK_CONTAINER (mvb), mainmenu);
	gtk_box_set_child_packing(GTK_BOX(mvb), mainmenu, FALSE, FALSE, 2, GTK_PACK_START);
	gtk_widget_show(mainmenu);
#endif

	// menu "File"
	w=gtk_menu_item_new_with_label ("File");
	gtk_menu_shell_append (GTK_MENU_SHELL (mainmenu), w);
	gtk_widget_show (w);
	filemenu = gtk_menu_new();
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), filemenu);
	// item "Import track"
	mitem = gtk_image_menu_item_new_with_label("Open GPX file");
	mim = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(create_file_selection), Mapper);
	// item "Import track"
	mitem = gtk_image_menu_item_new_with_label("Save GPX file");
	mim = gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_save_gpxfile), Mapper);
	// item seperator
	mitem = gtk_separator_menu_item_new();
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), mitem);
	gtk_widget_show (mitem);
	// item "Exit"
	mitem = gtk_image_menu_item_new_with_label("Exit");
	mim = gtk_image_new_from_stock(GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(close_application), Mapper);
	// menu "Edit"
	w=gtk_menu_item_new_with_label ("Edit");
	gtk_menu_shell_append (GTK_MENU_SHELL (mainmenu), w);
	gtk_widget_show (w);
	editmenu = gtk_menu_new();
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), editmenu);

	// submenu "Algorithms"
	algomenu = gtk_menu_new();
	w = gtk_menu_item_new_with_label ("Algorithms");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(w), algomenu);
	gtk_menu_shell_append (GTK_MENU_SHELL (editmenu), w);
	gtk_widget_show (algomenu);
	gtk_widget_show (w);

	// item "Autoscale"
	mitem = gtk_image_menu_item_new_with_label("Auto-Scale");
	mim = gtk_image_new_from_stock(GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(algomenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(auto_scale), Mapper);
	// item "Autosplit"
	mitem = gtk_image_menu_item_new_with_label("Auto-Split");
	mim = gtk_image_new_from_stock(GTK_STOCK_CUT, GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(algomenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_auto_split), Mapper);
	// item "Autothin"
	mitem = gtk_image_menu_item_new_with_label("Auto-Thin");
	//mim = gtk_image_new_from_stock(GTK_STOCK_CUT, GTK_ICON_SIZE_MENU);
	//gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(algomenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_auto_thin), Mapper);
	// item "Angle simplify"
	mitem = gtk_image_menu_item_new_with_label("Auto-angle-simple");
	//mim = gtk_image_new_from_stock(GTK_STOCK_CUT, GTK_ICON_SIZE_MENU);
	//gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(algomenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_track_angle_simplify), Mapper);

	// item "Properties"
	mitem = gtk_image_menu_item_new_with_label("Track Properties");
	//mim = gtk_image_new_from_stock(GTK_STOCK_CUT, GTK_ICON_SIZE_MENU);
	//gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_properties_track), Mapper);
	// item "Edit/View waypoints"
	mitem = gtk_image_menu_item_new_with_label("Edit/View waypoints");
	//mim = gtk_image_new_from_stock(GTK_STOCK_CUT, GTK_ICON_SIZE_MENU);
	//gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_editview_waypoints), Mapper);
	// item seperator
	mitem = gtk_separator_menu_item_new();
	gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), mitem);
	gtk_widget_show (mitem);
	// item "Record"
	mitem = gtk_image_menu_item_new_with_label("Record");
	//mim = gtk_image_new_from_stock(GTK_STOCK_CUT, GTK_ICON_SIZE_MENU);
	//gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_record_track), Mapper);
	// item seperator
	mitem = gtk_separator_menu_item_new();
	gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), mitem);
	gtk_widget_show (mitem);
	// item "Preferences"
	mitem = gtk_image_menu_item_new_with_label("Preferences");
	mim = gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mitem), mim);
	gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(do_preference_dialog), Mapper);
	
	// menu "View"
	w=gtk_menu_item_new_with_label ("View");
	gtk_menu_shell_append (GTK_MENU_SHELL (mainmenu), w);
	gtk_widget_show (w);
	viewmenu = gtk_menu_new();
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), viewmenu);
	// item "Show cities"
	mitem = gtk_check_menu_item_new_with_label("Show cities");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mitem), TRUE);
	gtk_menu_shell_append (GTK_MENU_SHELL (viewmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "toggled", G_CALLBACK(do_show_cities_toggled), Mapper);
	// item "Show waypoints"
	mitem = gtk_check_menu_item_new_with_label("Show waypoints");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mitem), TRUE);
	gtk_menu_shell_append (GTK_MENU_SHELL (viewmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "toggled", G_CALLBACK(do_show_waypoints_toggled), Mapper);
	// item "Show markers"
	mitem = gtk_check_menu_item_new_with_label("Show markers");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mitem), FALSE);
	gtk_menu_shell_append (GTK_MENU_SHELL (viewmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "toggled", G_CALLBACK(do_show_markers_toggled), Mapper);
	// item "Show scale"
	mitem = gtk_check_menu_item_new_with_label("Show scale");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mitem), TRUE);
	gtk_menu_shell_append (GTK_MENU_SHELL (viewmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "toggled", G_CALLBACK(do_show_scale_toggled), Mapper);

	// menu "Tools"
	w=gtk_menu_item_new_with_label ("Tools");
	gtk_menu_shell_append (GTK_MENU_SHELL (mainmenu), w);
	gtk_widget_show (w);
	toolsmenu = gtk_menu_new();
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), toolsmenu);
	// item "Measure Distance"
	mitem = gtk_image_menu_item_new_with_label("Measure distance");
	gtk_menu_shell_append (GTK_MENU_SHELL (toolsmenu), mitem);
	gtk_widget_show (mitem);
	//g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(do_preference_dialog), Mapper);
	// item "Track length (total)"
	mitem = gtk_image_menu_item_new_with_label("Track length");
	gtk_menu_shell_append (GTK_MENU_SHELL (toolsmenu), mitem);
	gtk_widget_show (mitem);
	g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(on_track_length), Mapper);
	// item "Trackpoint distance"
	mitem = gtk_image_menu_item_new_with_label("Trackpoint distance");
	gtk_menu_shell_append (GTK_MENU_SHELL (toolsmenu), mitem);
	gtk_widget_show (mitem);
	//g_signal_connect(G_OBJECT(mitem), "activate", G_CALLBACK(do_preference_dialog), Mapper);

	/* toolbar and buttons */
	tb = gtk_toolbar_new();
	tt = gtk_tooltips_new();
	gtk_container_add (GTK_CONTAINER (mvb), tb);
	gtk_box_set_child_packing(GTK_BOX(mvb), tb, FALSE, FALSE, 2, GTK_PACK_START);
	gtk_widget_show(tb);
	/* auto zoom */
	w = load_icon("pixmaps/stock_zoom-page-width.png");
	gtk_widget_show(w);
	ti = gtk_tool_button_new(w, "Auto Zoom");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(auto_scale), Mapper);
	gtk_tool_item_set_tooltip (ti, tt, "Auto Zoom", "Auto Zoom complete data to view area");
	/* zoom in */
	w = load_icon("pixmaps/stock_zoom-in.png");
	gtk_widget_show(w);
	ti = gtk_tool_button_new(w, "Zoom In");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(zoom_in_cb), Mapper);
	gtk_tool_item_set_tooltip (ti, tt, "Zoom in", "Zoom in, make it larger");
	/* zoom out */
	w = load_icon("pixmaps/stock_zoom-out.png");
	gtk_widget_show(w);
	ti = gtk_tool_button_new(w, "Zoom Out");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(zoom_out_cb), Mapper);
	gtk_tool_item_set_tooltip (ti, tt, "Zoom out", "Zoom in, make it smaller");
	/* zoom selection */
	w = load_icon("pixmaps/stock_zoom-object.png");
	gtk_widget_show(w);
	ti = gtk_radio_tool_button_new(NULL);
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(ti), w);
	gtk_tool_button_set_label(GTK_TOOL_BUTTON(ti), "Zoom Selection");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(zoom_area_cb), Mapper);
	Mapper->zoom_area_toggle_button = GTK_RADIO_TOOL_BUTTON(ti);
	gtk_tool_item_set_tooltip (ti, tt, "Zoom selection", "Zoom selected area to maxmum view size");
	/* move */
	w = load_icon("pixmaps/stock-tool-move-22.png");
	gtk_widget_show(w);
	ti = gtk_radio_tool_button_new(gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(ti)));
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(ti), w);
	gtk_tool_button_set_label(GTK_TOOL_BUTTON(ti), "Move");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(move_cb), Mapper);
	Mapper->move_toggle_button = GTK_RADIO_TOOL_BUTTON(ti);
	gtk_tool_item_set_tooltip (ti, tt, "Move", "Move the viewing area");
	/* seperator */
	ti = gtk_separator_tool_item_new();
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	/* select trackpoint */
	w = load_icon("pixmaps/stock_draw-selection.png");
	gtk_widget_show(w);
	ti = gtk_radio_tool_button_new(gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(Mapper->move_toggle_button)));
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(ti), w);
	gtk_tool_button_set_label(GTK_TOOL_BUTTON(ti), "Select Trackpoint");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(on_select_trackpoint_cb), Mapper);
	Mapper->move_toggle_button = GTK_RADIO_TOOL_BUTTON(ti);
	gtk_tool_item_set_tooltip (ti, tt, "Select point(s)", "Select track point(s)");
	/* select region */
	w = load_icon("pixmaps/stock_frame.png");
	gtk_widget_show(w);
	ti = gtk_radio_tool_button_new(gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(Mapper->move_toggle_button)));
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(ti), w);
	gtk_tool_button_set_label(GTK_TOOL_BUTTON(ti), "Select Region");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(on_select_region_cb), Mapper);
	Mapper->move_toggle_button = GTK_RADIO_TOOL_BUTTON(ti);
	gtk_tool_item_set_tooltip (ti, tt, "Select point(s)", "Select point(s) in region");
	/* move trackpoint */
	w = load_icon("pixmaps/stock_node-move.png");
	gtk_widget_show(w);
	ti = gtk_radio_tool_button_new(gtk_radio_tool_button_get_group(GTK_RADIO_TOOL_BUTTON(Mapper->move_toggle_button)));
	gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(ti), w);
	gtk_tool_button_set_label(GTK_TOOL_BUTTON(ti), "Move Trackpoint");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(on_move_trackpoint_cb), Mapper);
	Mapper->move_toggle_button = GTK_RADIO_TOOL_BUTTON(ti);
	gtk_tool_item_set_tooltip (ti, tt, "Move point(s)", "Move selected track point(s)");
	/* split track at selected nodes */
	w = load_icon("pixmaps/stock_node-curve-split.png");
	gtk_widget_show(w);
	ti = gtk_tool_button_new(w, "Split Track");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(on_split_track), Mapper);
	gtk_tool_item_set_tooltip (ti, tt, "Split at selection(s)", "Split track at selected track point(s)");
	/* delete selected nodes */
	w = load_icon("pixmaps/stock_node-delete.png");
	gtk_widget_show(w);
	ti = gtk_tool_button_new(w, "Delete Node(s)");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(on_delete_nodes_cb), Mapper);
	gtk_tool_item_set_tooltip (ti, tt, "Delete node(s)", "Delete selected track point(s)");
	/* seperator */
	ti = gtk_separator_tool_item_new();
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	/* delete track */
	w = load_icon("pixmaps/stock_delete.png");
	gtk_widget_show(w);
	ti = gtk_tool_button_new(w, "Delete Track");
	gtk_toolbar_insert(GTK_TOOLBAR(tb), ti, -1);
	gtk_widget_show(GTK_WIDGET(ti));
	g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(on_track_delete), Mapper);
	gtk_tool_item_set_tooltip (ti, tt, "Delete track", "Delete selected track");

	gtk_tooltips_enable(tt);

	mhb = gtk_hbox_new(FALSE, 0);
	gtk_container_add (GTK_CONTAINER(mvb), mhb);
	gtk_widget_show(mhb);

	/* track list in treeview */
	w = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
	gtk_box_pack_start (GTK_BOX (mhb), w, FALSE, FALSE, 0);
	gtk_widget_show(w);
	tree_model = GTK_TREE_MODEL(gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER));
	Mapper->track_treeview = gtk_tree_view_new_with_model (tree_model);
#ifdef HILDON
	g_object_set(G_OBJECT(Mapper->track_treeview), "allow-checkbox-mode", FALSE, NULL);
	gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(Mapper->track_treeview), FALSE);
#endif
	gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (Mapper->track_treeview), TRUE);
	g_object_unref (tree_model);
	gtk_container_add (GTK_CONTAINER (w), Mapper->track_treeview);
	gtk_widget_show(Mapper->track_treeview);
	add_columns(GTK_TREE_VIEW (Mapper->track_treeview), Mapper);

	/* drawing area for drawing the tracks */
	Mapper->drawarea = gtk_drawing_area_new();
	gtk_container_add (GTK_CONTAINER (mhb), Mapper->drawarea);
	gtk_box_set_child_packing(GTK_BOX(mhb), Mapper->drawarea, TRUE, TRUE, 2, GTK_PACK_START);
	gtk_widget_show(Mapper->drawarea);
	gtk_widget_set_events (Mapper->drawarea, (GDK_EXPOSURE_MASK));
	g_signal_connect(G_OBJECT(Mapper->drawarea), "expose-event", G_CALLBACK(mappix_expose), Mapper);
	g_signal_connect(G_OBJECT(Mapper->drawarea), "enter-notify-event", G_CALLBACK(mappix_drfocus_in), Mapper);
	g_signal_connect(G_OBJECT(Mapper->drawarea), "leave-notify-event", G_CALLBACK(mappix_drfocus_out), Mapper);
	gtk_widget_realize(Mapper->drawarea);
	Mapper->red_gc = gdk_gc_new (Mapper->drawarea->window);
	color.red = 65535; // full red
	color.green = 0;
	color.blue = 0;
	gdk_gc_set_rgb_fg_color (Mapper->red_gc, &color);
	Mapper->blue_gc = gdk_gc_new (Mapper->drawarea->window);
	color.red = 0;
	color.green = 0;
	color.blue = 65535;
	gdk_gc_set_rgb_fg_color (Mapper->blue_gc, &color);
	Mapper->select_gc = gdk_gc_new (Mapper->drawarea->window);
	color.red = 65535;
	color.green = 65535;
	color.blue = 0;
	gdk_gc_set_rgb_fg_color (Mapper->select_gc, &color);
	gdk_gc_set_function(Mapper->select_gc, GDK_XOR);
	g_signal_connect(G_OBJECT(Mapper->drawarea), "configure-event", G_CALLBACK(mappix_configure), Mapper);

	Mapper->statbar = gtk_statusbar_new();
	Mapper->lstatid = 0;
	gtk_container_add (GTK_CONTAINER (mvb), Mapper->statbar);
	gtk_widget_show(Mapper->statbar);
	gtk_box_set_child_packing(GTK_BOX(mvb), Mapper->statbar, FALSE, FALSE, 2, GTK_PACK_START);

	Mapper->lstatid = gtk_statusbar_get_context_id(GTK_STATUSBAR(Mapper->statbar), "pcoord");
	gtk_statusbar_push(GTK_STATUSBAR(Mapper->statbar), Mapper->lstatid, "none");

	g_signal_connect (G_OBJECT (Mapper->drawarea), "motion_notify_event", G_CALLBACK (motion_notify_event), Mapper);
	g_signal_connect (G_OBJECT (Mapper->drawarea), "button_press_event", G_CALLBACK (button_press_event), Mapper);
	g_signal_connect (G_OBJECT (Mapper->drawarea), "button_release_event", G_CALLBACK (button_press_event), Mapper);
	gtk_widget_add_events (Mapper->drawarea, GDK_EXPOSURE_MASK
		| GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK
		| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_RELEASE_MASK);

	gtk_widget_show (Mapper->mainwin);
#ifdef HILDON
	gtk_widget_show(GTK_WIDGET(Mapper->hildon_app));
#endif

return 0;
}