diff options
Diffstat (limited to 'gnome-map/gglobe-canvas.c')
| -rw-r--r-- | gnome-map/gglobe-canvas.c | 786 |
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; +} + |