added gnome-map

1 files changed, 786 insertions, 0 deletions

diff --git a/gnome-map/gglobe-canvas.c b/gnome-map/gglobe-canvas.c
new file mode 100644
index 000000000..68f92682f
--- /dev/null
+++ b/gnome-map/gglobe-canvas.c
@@ -0,0 +1,786 @@
+/* Copyright (C) 1999 Red Hat, Inc. */
+/* Original work by Michael Fulbright <drmike@redhat.com> */
+
+#include <gnome.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+
+#include "gnome-map.h"
+#include "gnome-canvas-dot.h"
+#include "timezones.h"
+
+
+/* Command line options */
+/* image     - filename of file to use for map (must be PNG for antialias) */
+/* mapwidth  - width to scale image to (also size of canvas widget)        */
+/* mapheight - height to scale image to (also size of canvas widget)       */
+/* aa        - if TRUE use antialiased canvas instead of normal            */
+static gchar *image = NULL;
+static int mapwidth = -1;
+static int mapheight = -1;
+static int aa=FALSE;
+
+static const struct poptOption options[] = {
+    {"image", '\0', POPT_ARG_STRING, &image, 0, N_("Map Image to display"), NULL},
+    {"width", '\0', POPT_ARG_INT, &mapwidth, 0, N_("Width of map (in pixels)"), NULL},
+    {"antialias", '\0', POPT_ARG_INT, &aa, 0, N_("Enable antialias"), NULL},
+    { NULL, '\0', 0, NULL, 0}
+};
+
+
+/* time zone data */
+/* This is an array of TimeZoneLocations (see timezone.h). Created */
+/* by a call to loadTZDB                                           */
+GPtrArray      *Locations=NULL;
+
+/* index in all Locations GPtrArray of currently selected city */
+gint            curselection=-1;
+
+/* toplevel app window */
+GtkWidget *mainwindow;
+
+/* other widgets for the top-level GUI */
+GtkWidget *statusbar;
+
+/* locationlist is the clist on the right side of the GUI showing all the */
+/* currently viewable locations.                                          */
+/* It is created and updated by the create_location_list () function      */
+GtkWidget *locationlist;
+
+/* if TRUE we do not want to act on the select_row events to locationlist */
+/* used when we are manually manipulating rows in locationlist and we     */
+/* want to ignore the events going to the callback.                       */
+gboolean ignore_locationlist_selectevents=FALSE;
+
+/* Canvas item circle for selected location */
+GnomeCanvasItem *selmarker=NULL;
+double          oldselx, oldsely; /* old location of selection */
+#define SELECTED_COLOR "red"
+
+/* Canvas item circle for hilited location and optionally rubberband */
+/* line pointing from cursor to hilited location                     */
+GnomeCanvasItem *hilitemarker=NULL;
+GnomeCanvasItem *hiliterubberband=NULL;
+gint            hiliteindex=-1;         /* index in markers array of */
+                                        /* currently hilted location */
+double          oldhilitex, oldhilitey; /* old location of hilite circle */
+#define HILITED_COLOR   "limegreen"
+
+/* set to appropriate value to enable/disable the rubberband */
+#define USE_HILITE_RUBBERBAND TRUE
+
+/* color for normal (non-hilited or -selected locations */
+#define CITY_COLOR     "yellow"
+
+/* map and city structures */
+/* See gnome-map.h for more info on the GnomeMap structure */
+/* markers is an array of pointers to GnomeCanvasItems which are the */
+/* indicators for the locations in the Locations array */
+GnomeMap *WorldMap;
+GnomeCanvasItem **markers=NULL;
+
+/* view data */
+/* Views are defined by a range of either longitude or latitude     */
+/* as well as the central value for the other axis.                 */
+typedef enum
+{
+    LONGITUDE_CONSTRAINT,
+    LATITUDE_CONSTRAINT
+} ViewContraintType;
+
+struct _VIEW_DEF {
+    gchar    *name;
+    ViewContraintType type;
+    double   constraint1, constraint2, constraint3;
+};
+
+typedef struct _VIEW_DEF ViewDefinition;
+
+ViewDefinition Views[] = {
+    { "World",         LONGITUDE_CONSTRAINT, -180.0, 180.0, 0.0 },
+    { "North America", LONGITUDE_CONSTRAINT, -171.0, -21.0, 40.0 },
+    { "South America", LATITUDE_CONSTRAINT,   15.0,   -70.0, -70.0 },
+    { "Pacific Rim",   LATITUDE_CONSTRAINT,    -47.0, 47.0, 155.0},
+    { "Europe",        LONGITUDE_CONSTRAINT,  -25.0, 70.0, 45.0 },
+    { "Africa",        LATITUDE_CONSTRAINT,   40.0,   -40.0, 15.0},
+    { "Asia",          LONGITUDE_CONSTRAINT,  20.0, 165.0, 40.0}
+};
+
+gint numviews = sizeof(Views)/sizeof(ViewDefinition);
+
+
+static gint item_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data);
+static GtkWidget *create_location_list ( GtkWidget **returnlist );
+
+/* give a location name search for match in Locations db */
+/* returns index if found, -1 if not                     */
+static int
+find_location (gchar *locname)
+{
+    TimeZoneLocation  *loc;
+    gint i;
+
+    for (i=0; i < Locations->len; i++) {
+	loc = g_ptr_array_index (Locations, i);
+
+	if (!strcmp (loc->zone, locname))
+	    return i;
+    }
+
+    return -1;
+}
+
+
+/* find nearest location to specified map coords - clips to current view */
+/* if no match return -1                                                 */
+static int
+find_nearest ( double longitude, double latitude )
+{
+    double mindist;
+    double dist;
+    double dx, dy;
+    int    i, mini;
+    gboolean first=TRUE;
+    TimeZoneLocation  *loc;
+
+    mini = -1;
+    for (i=0; i < Locations->len; i++) {
+	loc = g_ptr_array_index (Locations, i);
+
+	if (!gnome_map_is_loc_in_view (WorldMap, 
+				       loc->longitude, loc->latitude))
+	    continue;
+
+	dx = (loc->longitude-longitude);
+	dy = (loc->latitude-latitude);
+	dist = dx*dx + dy*dy;
+
+	if (dist < mindist || first) {
+	    mindist = dist;
+	    mini = i;
+	    first = FALSE;
+	}
+    }
+
+    return mini;
+}
+
+/* attach to signal for canvas items so we can track motion and mouse */
+/* events                                                             */
+static void
+setup_item (GnomeCanvasItem *item)
+{
+    gtk_signal_connect (GTK_OBJECT (item), "event",
+			(GtkSignalFunc) item_event,
+			NULL);
+}
+
+/* Moves marker (a circle currently) to the specified location */
+/* and sets it to the specified color.  The oldx and oldy      */
+/* variables are required because the canvas only allows one   */
+/* to do relative moves for items.  These are automatically    */
+/* set to x and y by this function before it returns.          */
+/*                                                             */
+/* The first time this function is called for a given marker   */
+/* *curmarker should equal NULL.  The marker will be created   */
+/* automatically.                                              */
+
+static void
+set_flag_marker (GnomeCanvasItem **curmarker, gchar *color,
+		 double x, double y, double *oldx, double *oldy)
+{
+    GnomeCanvasGroup  *canvas_root;
+    GnomeCanvasItem   *group;
+
+    g_return_if_fail ( color != NULL );
+
+    canvas_root = gnome_canvas_root (GNOME_CANVAS(WorldMap->canvas));
+    if (!*curmarker) {
+
+	group = gnome_canvas_item_new ( canvas_root,
+					gnome_canvas_group_get_type(),
+					"x", x,
+					"y", y,
+					NULL);
+	
+#define MARKER_RADIUS 3.5
+#define MARKER_WIDTH_PIX 1
+
+        setup_item (gnome_canvas_item_new (GNOME_CANVAS_GROUP (group),
+					   gnome_canvas_text_get_type (),
+					   "font", "-adobe-helvetica-bold-r-normal--12-*-72-72-p-*-iso8859-1",
+					   "anchor", GTK_ANCHOR_CENTER,
+					   "fill_color", "red",
+					   "text", "X",
+					   NULL));
+
+  	*curmarker = GNOME_CANVAS_ITEM (group); 
+    } else {
+	gnome_canvas_item_move ( *curmarker, x - *oldx, y - *oldy );
+    }
+
+    *oldx = x;
+    *oldy = y;
+}
+
+/* Given a pointer to a GnomeMap and an index into the Locations db */
+/* mark it as the selected location on the canvas                   */
+static void
+map_mark_location_selected (GnomeMap *map, gint index)
+{
+    TimeZoneLocation *loc;
+    double selx, sely;
+
+    g_return_if_fail ( map != NULL );
+    g_return_if_fail ( index >= 0 );
+
+    loc = g_ptr_array_index (Locations, index);
+    
+    gnome_map_xlat_map2screen ( map, 
+				loc->longitude,	loc->latitude,
+				&selx, &sely );
+    set_flag_marker (&selmarker, SELECTED_COLOR,
+		     selx, sely, &oldselx, &oldsely);
+    
+    if (curselection >= 0) {
+	gnome_canvas_item_set (markers[curselection],
+			       "fill_color", CITY_COLOR, NULL);
+	gnome_canvas_item_show (markers[curselection]);
+    }
+/*      gnome_canvas_item_set (markers[index], "fill_color",  */
+/*  			   SELECTED_COLOR, NULL); */
+    gnome_canvas_item_hide (markers[index]);
+    gnome_canvas_item_raise_to_top (selmarker);
+}
+
+/* Given a pointer to a GnomeMap and an index into the Locations db */
+/* mark it as the selected location in the clist of locations       */
+/* The jumpto gboolean is used to specify if the clist should be    */
+/* forced to scroll to the new location.  Used because when the     */
+/* clist is autoscrolling we do not want to force selection to be   */
+/* constantly recentered.                                           */
+static void
+list_mark_location_selected (GnomeMap *map, gint index, gboolean jumpto)
+{
+    gint newrow;
+
+    /* We're messing with list manually, so let callback know to */
+    /* ignore any events till we're done                         */
+    ignore_locationlist_selectevents = TRUE;
+
+    /* if current selection is visible then select it again, otherwise */
+    /* change clist to not have a current selection                    */
+    if (index >= 0) {
+	TimeZoneLocation *loc = g_ptr_array_index (Locations, index);
+	
+	if (gnome_map_is_loc_in_view (map,loc->longitude,loc->latitude)) {
+	    gtk_clist_set_selection_mode (GTK_CLIST (locationlist), 
+					  GTK_SELECTION_BROWSE);
+	} else {
+	    gtk_clist_set_selection_mode (GTK_CLIST (locationlist), 
+					  GTK_SELECTION_SINGLE);
+	}
+    }
+
+    /* find in list of locations and set as current */
+    newrow = gtk_clist_find_row_from_data( GTK_CLIST (locationlist),
+					   GINT_TO_POINTER (index));
+
+    if (newrow >= 0 ) {
+	gtk_clist_select_row (GTK_CLIST(locationlist), newrow, 0);
+	if (jumpto && gtk_clist_row_is_visible (GTK_CLIST (locationlist), newrow) != GTK_VISIBILITY_FULL) {
+	    gtk_clist_moveto (GTK_CLIST (locationlist), newrow , 0, 0.5, 0.5 );
+	}
+    }
+
+    /* We're done mucking with clist, ok to listen to events again */
+    ignore_locationlist_selectevents = FALSE;
+
+}
+/* handles all canvas drawing for making the selected location # index */
+/* in the sorted list in the Locations variable                        */
+static void
+set_selection (gint index, gboolean jumpto)
+{
+    g_return_if_fail ( index >= 0 );
+
+    map_mark_location_selected (WorldMap, index);
+
+    list_mark_location_selected (WorldMap, index, jumpto);
+
+    /* NOTE: curselection is global variable. Only place it gets set */
+    curselection = index;
+}
+
+/* Given an index into the Locations db and a position, draw the hilite */
+/* marker around it to indicate it is city cursor is pointing at        */
+static void
+set_hilited (gint index, double item_x, double item_y)
+{
+    TimeZoneLocation *loc;
+    GnomeCanvasPoints *points;
+
+    g_return_if_fail ( index >= 0 );
+
+    loc = g_ptr_array_index (Locations, index);
+
+    points = gnome_canvas_points_new (2);
+    points->coords[0] = item_x;
+    points->coords[1] = item_y;
+    gnome_map_xlat_map2screen ( WorldMap,
+				loc->longitude, loc->latitude,
+				&points->coords[2], &points->coords[3] );
+    if (hiliterubberband) {
+	gnome_canvas_item_set (hiliterubberband, "points", points, NULL);
+	gnome_canvas_item_show (hiliterubberband);
+    } else {
+	GnomeCanvasGroup *canvas_root = gnome_canvas_root (GNOME_CANVAS (WorldMap->canvas));
+	
+	hiliterubberband = gnome_canvas_item_new (canvas_root,
+					  gnome_canvas_line_get_type (),
+					  "points", points,
+					  "fill_color", HILITED_COLOR,
+					  "width_pixels", 2,
+					  "first_arrowhead", FALSE,
+					  "last_arrowhead", TRUE,
+					  "arrow_shape_a", 4.0,
+					  "arrow_shape_b", 8.0,
+					  "arrow_shape_c", 4.0,
+					  NULL);
+	setup_item (hiliterubberband);
+    }
+
+    /* Set USE_HILITE_RUBBER band define at top of file for desired */
+    /* behavior                                                     */
+    if (!USE_HILITE_RUBBERBAND)
+	gnome_canvas_item_hide (hiliterubberband);
+
+    /* if hilited city isn't also currently selected city, draw the */
+    /* hilite marker as well                                        */
+    if (index != curselection) {
+	/*
+	set_flag_marker ( &hilitemarker, HILITED_COLOR,
+			  points->coords[2], points->coords[3],
+			  &oldhilitex, &oldhilitey );
+	*/
+	
+/*  	gnome_canvas_item_set ( markers[index],  */
+/*  				"fill_color", HILITED_COLOR,  */
+/*  				NULL); */
+	
+	if (hiliteindex >= 0 && hiliteindex != index) {
+	    if (hiliteindex != curselection)
+		gnome_canvas_item_set ( markers[hiliteindex], 
+					"fill_color", CITY_COLOR, 
+					NULL);
+	    else
+		gnome_canvas_item_set ( markers[hiliteindex], 
+					"fill_color", SELECTED_COLOR, 
+					NULL);
+	}
+	hiliteindex = index;
+
+/*  	gnome_canvas_item_show (hilitemarker);  */
+    } else {
+/*  	gnome_canvas_item_hide (hilitemarker);  */
+    }
+    
+    gnome_canvas_points_free (points);
+
+    gtk_statusbar_pop ( GTK_STATUSBAR (statusbar), 1);
+    gtk_statusbar_push ( GTK_STATUSBAR (statusbar), 1, loc->zone );
+}
+
+/* Handles case where cursor leaves the map */
+static int
+canvas_event (GtkWidget *canvas, GdkEvent *event, gpointer data)
+{
+    /* if pointer just left canvas, hide hilite marker(s) */
+    if (event->type == GDK_LEAVE_NOTIFY) {
+/*  	if (hilitemarker) */
+/*  	    gnome_canvas_item_hide (hilitemarker); */
+	if (hiliterubberband)
+	    gnome_canvas_item_hide (hiliterubberband);
+	if (hiliteindex >= 0 && hiliteindex != curselection)
+	    gnome_canvas_item_set ( markers[hiliteindex], 
+				    "fill_color", CITY_COLOR, 
+				    NULL);
+
+    }
+    return FALSE;
+}
+
+/* Handles as motion and mouse button events in the map */
+static gint
+item_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
+{
+    double longitude, latitude;
+    double item_x, item_y;
+    int    nearest;
+
+    item_x = event->button.x;
+    item_y = event->button.y;
+    gnome_canvas_item_w2i (WorldMap->image_item, &item_x, &item_y);
+
+    switch (event->type) {
+
+	/* User selected a new location with a left mouse button press */
+      case GDK_BUTTON_PRESS:
+	switch (event->button.button) {
+	  case 1:
+	    
+	    gnome_map_xlat_screen2map ( WorldMap, item_x, item_y,
+					&longitude, &latitude );
+	    
+	    nearest  = find_nearest( longitude, latitude );
+
+	    set_selection (nearest, TRUE);
+
+	    break;
+	    
+	  default:
+	    break;
+	}
+	
+	break;
+	
+	/* highlight city which a button press will select */
+      case GDK_MOTION_NOTIFY:
+
+	gnome_map_xlat_screen2map ( WorldMap, item_x, item_y, 
+				    &longitude, &latitude);
+
+	nearest  = find_nearest( longitude, latitude );
+	set_hilited (nearest, item_x, item_y);
+	break;
+
+      default:
+	break;
+    }
+    
+    return FALSE;
+}
+
+/* Handles events for the clist of locations */
+static void
+list_select_event ( GtkWidget *clist, gint row, gint column,
+		    GdkEventButton *event, gpointer data)
+{
+
+    gchar       *text;
+    gint        index;
+
+    /* should we do anything? */
+    if (ignore_locationlist_selectevents)
+	return;
+
+    /* msf - always read zero because sometimes col == -1 if they select */
+    /*       without a mouse click (ie. keyboard navigation )            */
+    gtk_clist_get_text(GTK_CLIST(clist), row, 0, &text);
+    
+    /* Just prints some information about the selected row */
+    g_print("You selected row %d. More specifically you clicked in column %d, and the text in this cell is %s\n\n", row, column, text);
+    
+    index = find_location (text);
+    if (index < 0)
+	return;
+
+    set_selection (index, FALSE);
+    return;
+}
+
+
+static GnomeCanvasItem *
+draw_city_marker ( GnomeMap *map, double longitude, double latitude)
+{
+    double  x, y;
+    GnomeCanvasItem *item;
+    GnomeCanvasGroup *canvas_root;
+
+    canvas_root = gnome_canvas_root (GNOME_CANVAS (map->canvas));
+
+    gnome_map_xlat_map2screen (map, longitude, latitude, &x, &y);
+
+#define RAD 1
+#ifdef ELLIPSE
+    item = gnome_canvas_item_new (canvas_root,
+				  gnome_canvas_ellipse_get_type (),
+				  "x1", x-RAD,
+				  "y1", y-RAD,
+				  "x2", x+RAD,
+				  "y2", y+RAD,
+				  "fill_color", CITY_COLOR,
+				  NULL);
+#else
+    item = gnome_canvas_item_new (canvas_root,
+				  gnome_canvas_dot_get_type (),
+				  "x", x,
+				  "y", y,
+				  "diameter_pixels", RAD,
+				  "fill_color", CITY_COLOR,
+				  NULL);
+#endif
+    
+    setup_item ( item );
+    return item;
+}
+
+static void
+draw_cities (GnomeMap *map)
+{
+    gint i;
+
+    if (markers)
+	g_free(markers);
+
+    markers = g_new( GnomeCanvasItem *, Locations->len);
+    for (i=0; i < Locations->len; i++) {
+	TimeZoneLocation  *loc = g_ptr_array_index (Locations, i);
+    
+	markers[i] = draw_city_marker (map, loc->longitude, loc->latitude);
+    }
+}
+
+static void
+view_menu_activate (GtkWidget *widget, void *data)
+{
+    static gint curitem = -1;
+    gint   item = GPOINTER_TO_INT (data);
+
+    double lat1, long1, lat2, long2;
+    double dlat, dlong;
+
+    if ( item == curitem )
+	return;
+
+    curitem = item; 
+
+    /* compute aspect correct view and set canvas to it */
+    /* we may have to shift view if it extends outside of map */
+    if (Views[item].type == LONGITUDE_CONSTRAINT) {
+	long1 = Views[item].constraint1;
+	long2 = Views[item].constraint2;
+	dlong = fabs(long2 - long1);
+	dlat  = dlong/2.0;
+	lat1  = Views[item].constraint3 - dlat/2.0;
+	lat2  = Views[item].constraint3 + dlat/2.0;
+
+	if (lat1 < -90.0) {
+	    lat2 -= (lat1-90.0);
+	    lat1 = -90.0;
+	} else if (lat2 > 90.0) {
+	    lat1 -= (lat2-90.0);
+	    lat2 = 90.0;
+	}
+    } else if (Views[item].type == LATITUDE_CONSTRAINT) {
+	lat1 = Views[item].constraint1;
+	lat2 = Views[item].constraint2;
+	dlat = fabs(lat2 - lat1);
+	dlong = 2.0*dlat;
+	long1 = Views[item].constraint3 - dlong/2.0;
+	long2 = Views[item].constraint3 + dlong/2.0;
+
+	if (long1 < -180.0) {
+	    long2 -= (long1-180.0);
+	    long1 = -180.0;
+	} else if (long2 > 180.0) {
+	    long1 -= (long2-180.0);
+	    long2 = 180.0;
+	}
+    } else {
+	g_warning ("Bad contraint type %d in Views structure item # %d.\n", 
+		   item, Views[item].type);
+	return;
+    }
+
+    gnome_map_set_view (WorldMap, long1, lat1, long2, lat2);
+
+    /* make locationlist clist entries reflect those visible*/
+    create_location_list (&locationlist);
+
+}
+
+GtkWidget *
+create_view_menu ( void )
+{
+    GtkWidget *omenu;
+    GtkWidget *menu;
+    GtkWidget *menu_item;
+    gint   i;
+
+    omenu = gtk_option_menu_new ();
+
+    menu = gtk_menu_new ();
+    
+    for  (i=0; i < numviews; i++) {
+	menu_item = gtk_menu_item_new_with_label (Views[i].name);
+	gtk_menu_append (GTK_MENU (menu), menu_item);
+
+	gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
+			    (GtkSignalFunc) view_menu_activate, 
+			    GINT_TO_POINTER (i));
+
+	gtk_widget_show (menu_item);
+    }
+    gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
+    gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), 0);
+
+    gtk_widget_show (omenu);
+    return omenu;
+}
+
+/* returns pointer to the scrolled window containing the clist          */
+/* pointer to clist is returned via the passed argument if it doesnt    */
+/* already exist.  The list is clipped to the current world view        */
+static GtkWidget *
+create_location_list ( GtkWidget **returnlist )
+{
+    TimeZoneLocation   *loc;
+    GtkWidget *scrolledwin;
+    gchar *titles[] = { "Location", NULL };
+    gchar *row[1];
+    gint i;
+
+    ignore_locationlist_selectevents = TRUE;
+
+    if ( !*returnlist) {
+	scrolledwin = gtk_scrolled_window_new (NULL, NULL);
+    
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwin),
+					GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+	
+	gtk_widget_show (scrolledwin);
+	
+	*returnlist = gtk_clist_new_with_titles (1, titles);
+	gtk_clist_set_selection_mode (GTK_CLIST(*returnlist), 
+				      GTK_SELECTION_BROWSE);
+	gtk_clist_column_title_passive (GTK_CLIST(*returnlist), 0);
+	gtk_signal_connect(GTK_OBJECT(*returnlist), "select_row",
+			   GTK_SIGNAL_FUNC(list_select_event),
+			   NULL);
+
+
+	gtk_container_add (GTK_CONTAINER (scrolledwin), *returnlist);
+    } else {
+	gtk_clist_clear (GTK_CLIST (*returnlist));
+	scrolledwin = NULL;
+    }
+
+    for (i=0; i < Locations->len; i++) {
+	gint  newrow;
+
+	loc = g_ptr_array_index (Locations, i);	
+	if (!gnome_map_is_loc_in_view (WorldMap,loc->longitude,loc->latitude))
+	    continue;
+
+	row[0] = loc->zone;
+	newrow = gtk_clist_append (GTK_CLIST (*returnlist), row);
+	gtk_clist_set_row_data (GTK_CLIST (*returnlist), newrow, 
+				GINT_TO_POINTER (i));
+    }
+
+    /* restore selection of location in list now we've recreated it */
+    list_mark_location_selected(WorldMap, curselection, TRUE);
+
+    gtk_widget_show (locationlist);
+
+    ignore_locationlist_selectevents = FALSE;
+    return scrolledwin;
+}
+
+
+int
+main (int argc, char **argv)
+{
+    GtkWidget *frame;
+    GtkWidget *hbox1, *hbox2;
+    GtkWidget *vbox1, *vbox2;
+
+    GtkWidget *viewcombo;
+
+/*
+    tzset ();
+    printf ("tzname[0]=|%s|  tzname[1]=|%s|\n",tzname[0], tzname[1]);
+*/
+    gnome_init_with_popt_table("gglobe", "0.1", argc, argv, 
+			       options, 0, NULL);
+    
+    /* load timezone data */
+    Locations = loadTZDB ();
+    if (!Locations) {
+	g_warning (_("Cannot load timezone data"));
+	exit (1);
+    }
+    
+    mainwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_position (GTK_WINDOW (mainwindow), GTK_WIN_POS_CENTER);
+    gtk_window_set_title (GTK_WINDOW (mainwindow), _("gglobe-canvas"));
+
+    gtk_signal_connect (GTK_OBJECT (mainwindow), "destroy",
+			GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
+
+    /* top-level hbox for packing map/statusbar and view combo/tz list box */
+    hbox1 = gtk_hbox_new (FALSE, 2);
+    gtk_container_add (GTK_CONTAINER (mainwindow), hbox1);
+
+    /* create frame and world map first */
+    vbox1 = gtk_vbox_new (FALSE, 2);
+    gtk_box_pack_start (GTK_BOX (hbox1), vbox1, FALSE, FALSE, 0);
+
+    frame = gtk_frame_new (NULL);
+    gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, FALSE, 0);
+
+    WorldMap = gnome_map_new ( image, mapwidth, mapheight, aa );
+    if (!WorldMap) {
+	g_warning ("Could not create map view.");
+	exit (1);
+    }
+
+    setup_item(WorldMap->image_item);
+    gtk_signal_connect (GTK_OBJECT (WorldMap->canvas), "event",
+			(GtkSignalFunc) canvas_event,
+			NULL);
+
+    gtk_container_add (GTK_CONTAINER (frame), WorldMap->canvas);
+
+    statusbar = gtk_statusbar_new ();
+    gtk_box_pack_start (GTK_BOX (vbox1), statusbar, FALSE, FALSE, 0);
+    gtk_statusbar_push (GTK_STATUSBAR (statusbar), 1, "Unselected");
+    gtk_widget_show (statusbar);
+
+    /* add View combo box */
+    frame = gtk_frame_new (NULL);
+    gtk_box_pack_start (GTK_BOX (hbox1), frame, FALSE, FALSE, 2);
+
+    vbox2 = gtk_vbox_new (FALSE, 2);
+    gtk_container_add (GTK_CONTAINER (frame), vbox2);
+
+    hbox2 = gtk_hbox_new (FALSE, 2);
+    gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 2);
+    
+    viewcombo = create_view_menu ();
+    gtk_box_pack_start (GTK_BOX (hbox2), gtk_label_new ("View: "),
+			FALSE, FALSE, 0);
+    gtk_box_pack_start (GTK_BOX (hbox2), viewcombo, FALSE, FALSE, 2);
+
+    /* put cities on the world map */
+    draw_cities (WorldMap);
+
+    /* add list of all timezones */
+    frame = gtk_frame_new (NULL);
+    gtk_box_pack_start (GTK_BOX (vbox2), 
+			create_location_list (&locationlist), 
+			TRUE, TRUE, 2);
+    
+    /* display and wait */
+    gtk_widget_show_all (mainwindow);
+
+    /* pick New York City as default */
+    set_selection (find_location ("America/New_York"), TRUE);
+
+    gtk_main ();
+    
+    return 0;
+}
+