static void
position_changed_cb (GeocluePosition *position,
GeocluePositionFields fields,
int timestamp,
double latitude,
double longitude,
double altitude,
GeoclueAccuracy *accuracy,
GError *error,
EmerillonWindow *self)
{
if (error)
{
g_printerr ("Error retrieving the current position: %s\n", error->message);
g_error_free (error);
return;
}
else if (fields & GEOCLUE_POSITION_FIELDS_LATITUDE &&
fields & GEOCLUE_POSITION_FIELDS_LONGITUDE && self->priv->position_auto_update)
{
/* FIXME: if the next calls are inverted then the wrong position is
* shown (libchamplain bug). */
set_zoom_for_accuracy (self, accuracy);
champlain_view_center_on (self->priv->view, latitude, longitude);
}
}
void
gth_map_view_real_set_file (GthPropertyView *base,
GthFileData *file_data)
{
GthMapView *self = GTH_MAP_VIEW (base);
int coordinates_available;
double latitude;
double longitude;
coordinates_available = 0;
if (file_data != NULL) {
GthMetadata *metadata;
metadata = (GthMetadata *) g_file_info_get_attribute_object (file_data->info, "Exif::GPSInfo::GPSLatitude");
if (metadata != NULL) {
latitude = exif_coordinate_to_decimal (gth_metadata_get_raw (metadata));
metadata = (GthMetadata *) g_file_info_get_attribute_object (file_data->info, "Exif::GPSInfo::GPSLatitudeRef");
if (metadata != NULL) {
if (g_strcmp0 (gth_metadata_get_raw (metadata), "S") == 0)
latitude = - latitude;
}
coordinates_available++;
}
metadata = (GthMetadata *) g_file_info_get_attribute_object (file_data->info, "Exif::GPSInfo::GPSLongitude");
if (metadata != NULL) {
longitude = exif_coordinate_to_decimal (gth_metadata_get_raw (metadata));
metadata = (GthMetadata *) g_file_info_get_attribute_object (file_data->info, "Exif::GPSInfo::GPSLongitudeRef");
if (metadata != NULL) {
if (g_strcmp0 (gth_metadata_get_raw (metadata), "W") == 0)
longitude = - longitude;
}
coordinates_available++;
}
}
if (coordinates_available == 2) {
char *position;
gtk_widget_hide (self->priv->no_gps_label);
gtk_widget_show (self->priv->embed);
position = decimal_coordinates_to_string (latitude, longitude);
champlain_label_set_text (CHAMPLAIN_LABEL (self->priv->marker), position);
g_free (position);
champlain_location_set_location (CHAMPLAIN_LOCATION (self->priv->marker), latitude, longitude);
champlain_view_center_on (CHAMPLAIN_VIEW (self->priv->map_view), latitude, longitude);
}
else {
gtk_widget_hide (self->priv->embed);
gtk_widget_show (self->priv->no_gps_label);
}
}
static gboolean
gps_callback (GpsCallbackData *data)
{
lat += 0.005;
lon += 0.005;
champlain_view_center_on (data->view, lat, lon);
champlain_location_set_location (CHAMPLAIN_LOCATION (data->marker), lat, lon);
return TRUE;
}
static void
selection_changed_cb (EogThumbView *view,
EogMapPlugin *plugin)
{
EogImage *image;
ChamplainLabel *marker;
if (!eog_thumb_view_get_n_selected (view))
return;
image = eog_thumb_view_get_first_selected_image (view);
g_return_if_fail (image != NULL);
marker = g_object_get_data (G_OBJECT (image), "marker");
if (marker) {
gdouble lat, lon;
g_object_get (marker,
"latitude", &lat,
"longitude", &lon,
NULL);
champlain_view_center_on (CHAMPLAIN_VIEW (plugin->map),
lat,
lon);
/* Reset the previous selection */
if (plugin->marker)
update_marker_image (plugin->marker, GTK_ICON_SIZE_MENU);
plugin->marker = marker;
update_marker_image (plugin->marker, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_set_sensitive (plugin->jump_to_button, TRUE);
}
else {
gtk_widget_set_sensitive (plugin->jump_to_button, FALSE);
/* Reset the previous selection */
if (plugin->marker)
update_marker_image (plugin->marker, GTK_ICON_SIZE_MENU);
plugin->marker = NULL;
}
g_object_unref (image);
}
static void
jump_to (GtkWidget *widget,
EogMapPlugin *plugin)
{
if (!plugin->marker)
return;
gdouble lat, lon;
g_object_get (plugin->marker,
"latitude", &lat,
"longitude", &lon,
NULL);
champlain_view_center_on (CHAMPLAIN_VIEW (plugin->map),
lat,
lon);
}
/**
* Go to the specified placemark
*/
static void
go_cb (GtkAction *action,
PlacemarksPlugin *plugin)
{
GtkTreeIter iter;
PlacemarksPluginPrivate *priv;
const gchar *id;
gboolean found = FALSE;
GtkTreeIter found_iter;
gfloat lat, lon;
gint zoom;
priv = PLACEMARKS_PLUGIN (plugin)->priv;
id = gtk_action_get_name (action);
gtk_tree_model_get_iter_first (priv->model, &iter);
do
{
gchar *vid;
gtk_tree_model_get (priv->model, &iter, COL_ID, &vid, -1);
if (strcmp (id, vid) == 0)
{
found = TRUE;
found_iter = iter;
}
g_free (vid);
}
while (gtk_tree_model_iter_next (priv->model, &iter) && !found);
if (!found)
return;
gtk_tree_model_get (priv->model, &found_iter,
COL_LAT, &lat,
COL_LON, &lon,
COL_ZOOM, &zoom,
-1);
champlain_view_set_zoom_level (priv->map_view, zoom);
champlain_view_center_on (priv->map_view, lat, lon);
}
int
main (int argc, char *argv[])
{
ClutterActor *actor, *marker, *stage;
ChamplainMarkerLayer *layer;
GpsCallbackData callback_data;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_actor_set_size (stage, 800, 600);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* Create the map view */
actor = champlain_view_new ();
clutter_actor_set_size (CLUTTER_ACTOR (actor), 800, 600);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor);
/* Create the marker layer */
layer = champlain_marker_layer_new_full (CHAMPLAIN_SELECTION_SINGLE);
clutter_actor_show (CLUTTER_ACTOR (layer));
champlain_view_add_layer (CHAMPLAIN_VIEW (actor), CHAMPLAIN_LAYER (layer));
/* Create a marker */
marker = create_marker ();
champlain_marker_layer_add_marker (layer, CHAMPLAIN_MARKER (marker));
/* Finish initialising the map view */
g_object_set (G_OBJECT (actor), "zoom-level", 12,
"kinetic-mode", TRUE, NULL);
champlain_view_center_on (CHAMPLAIN_VIEW (actor), lat, lon);
/* Create callback that updates the map periodically */
callback_data.view = CHAMPLAIN_VIEW (actor);
callback_data.marker = CHAMPLAIN_MARKER (marker);
g_timeout_add (1000, (GSourceFunc) gps_callback, &callback_data);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
static void
contact_widget_location_update (EmpathyContactWidget *information)
{
GHashTable *location;
GValue *value;
gdouble lat = 0.0, lon = 0.0;
gboolean has_position = TRUE;
GtkWidget *label;
guint row = 0;
GHashTableIter iter;
gpointer key, pvalue;
if (!(information->flags & EMPATHY_CONTACT_WIDGET_SHOW_LOCATION))
{
gtk_widget_hide (information->vbox_location);
return;
}
location = empathy_contact_get_location (information->contact);
if (location == NULL || g_hash_table_size (location) == 0)
{
gtk_widget_hide (information->vbox_location);
return;
}
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LAT);
if (value == NULL)
has_position = FALSE;
else
lat = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LON);
if (value == NULL)
has_position = FALSE;
else
lon = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_TIMESTAMP);
if (value == NULL)
gtk_label_set_markup (GTK_LABEL (information->label_location), _("<b>Location</b>"));
else
{
gchar *user_date;
gchar *text;
gint64 stamp;
time_t time;
stamp = g_value_get_int64 (value);
time = stamp;
user_date = empathy_time_to_string_relative (time);
text = g_strconcat ( _("<b>Location</b>, "), user_date, NULL);
gtk_label_set_markup (GTK_LABEL (information->label_location), text);
g_free (text);
}
/* Prepare the location information table */
if (information->table_location != NULL)
{
gtk_widget_destroy (information->table_location);
}
information->table_location = gtk_table_new (1, 2, FALSE);
gtk_box_pack_start (GTK_BOX (information->subvbox_location),
information->table_location, FALSE, FALSE, 5);
g_hash_table_iter_init (&iter, location);
while (g_hash_table_iter_next (&iter, &key, &pvalue))
{
const gchar *skey;
const gchar* user_label;
GValue *gvalue;
char *svalue = NULL;
skey = (const gchar *) key;
user_label = location_key_to_label (skey);
gvalue = (GValue *) pvalue;
label = gtk_label_new (user_label);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (information->table_location),
label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 10, 0);
gtk_widget_show (label);
if (G_VALUE_TYPE (gvalue) == G_TYPE_DOUBLE)
{
gdouble dvalue;
dvalue = g_value_get_double (gvalue);
svalue = g_strdup_printf ("%f", dvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_STRING)
{
svalue = g_value_dup_string (gvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_INT64)
{
time_t time;
time = g_value_get_int64 (value);
svalue = empathy_time_to_string_utc (time, _("%B %e, %Y at %R UTC"));
}
if (svalue != NULL)
{
label = gtk_label_new (svalue);
gtk_table_attach_defaults (GTK_TABLE (information->table_location),
label, 1, 2, row, row + 1);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_widget_show (label);
}
g_free (svalue);
row++;
}
gtk_widget_show (information->table_location);
#if HAVE_LIBCHAMPLAIN
/* Cannot be displayed in tooltips until Clutter-Gtk can deal with such
* windows
*/
if (has_position &&
!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))
{
ClutterActor *marker;
ChamplainLayer *layer;
information->map_view_embed = gtk_champlain_embed_new ();
information->map_view = gtk_champlain_embed_get_view (
GTK_CHAMPLAIN_EMBED (information->map_view_embed));
gtk_container_add (GTK_CONTAINER (information->viewport_map),
information->map_view_embed);
g_object_set (G_OBJECT (information->map_view), "show-license", FALSE,
"scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
NULL);
layer = champlain_layer_new ();
champlain_view_add_layer (information->map_view, layer);
marker = champlain_marker_new_with_text (
empathy_contact_get_name (information->contact), NULL, NULL, NULL);
champlain_base_marker_set_position (CHAMPLAIN_BASE_MARKER (marker), lat, lon);
clutter_container_add (CLUTTER_CONTAINER (layer), marker, NULL);
champlain_view_center_on (information->map_view, lat, lon);
gtk_widget_show_all (information->viewport_map);
}
#endif
gtk_widget_show (information->vbox_location);
}
static void
contact_widget_location_update (EmpathyContactWidget *information)
{
GHashTable *location;
GValue *value;
gdouble lat = 0.0, lon = 0.0;
gboolean has_position = TRUE;
GtkWidget *label;
guint row = 0;
static const gchar* ordered_geolocation_keys[] = {
EMPATHY_LOCATION_TEXT,
EMPATHY_LOCATION_URI,
EMPATHY_LOCATION_DESCRIPTION,
EMPATHY_LOCATION_BUILDING,
EMPATHY_LOCATION_FLOOR,
EMPATHY_LOCATION_ROOM,
EMPATHY_LOCATION_STREET,
EMPATHY_LOCATION_AREA,
EMPATHY_LOCATION_LOCALITY,
EMPATHY_LOCATION_REGION,
EMPATHY_LOCATION_COUNTRY,
NULL
};
int i;
const gchar *skey;
gboolean display_map = FALSE;
if (!(information->flags & EMPATHY_CONTACT_WIDGET_SHOW_LOCATION))
{
gtk_widget_hide (information->vbox_location);
return;
}
location = empathy_contact_get_location (information->contact);
if (location == NULL || g_hash_table_size (location) == 0)
{
gtk_widget_hide (information->vbox_location);
return;
}
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LAT);
if (value == NULL)
has_position = FALSE;
else
lat = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LON);
if (value == NULL)
has_position = FALSE;
else
lon = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_TIMESTAMP);
if (value == NULL)
{
gchar *loc = g_strdup_printf ("<b>%s</b>", _("Location"));
gtk_label_set_markup (GTK_LABEL (information->label_location), loc);
g_free (loc);
}
else
{
gchar *user_date;
gchar *text;
gint64 stamp;
time_t time_;
stamp = g_value_get_int64 (value);
time_ = stamp;
user_date = empathy_time_to_string_relative (time_);
text = g_strconcat ( _("<b>Location</b>, "), user_date, NULL);
gtk_label_set_markup (GTK_LABEL (information->label_location), text);
g_free (text);
}
/* Prepare the location information table */
if (information->table_location != NULL)
{
gtk_widget_destroy (information->table_location);
}
information->table_location = gtk_table_new (1, 2, FALSE);
gtk_box_pack_start (GTK_BOX (information->subvbox_location),
information->table_location, FALSE, FALSE, 5);
for (i = 0; (skey = ordered_geolocation_keys[i]); i++)
{
const gchar* user_label;
GValue *gvalue;
char *svalue = NULL;
gvalue = g_hash_table_lookup (location, (gpointer) skey);
if (gvalue == NULL)
continue;
user_label = location_key_to_label (skey);
label = gtk_label_new (user_label);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (information->table_location),
label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 10, 0);
gtk_widget_show (label);
if (G_VALUE_TYPE (gvalue) == G_TYPE_DOUBLE)
{
gdouble dvalue;
dvalue = g_value_get_double (gvalue);
svalue = g_strdup_printf ("%f", dvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_STRING)
{
svalue = g_value_dup_string (gvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_INT64)
{
time_t time_;
time_ = g_value_get_int64 (value);
svalue = empathy_time_to_string_utc (time_, _("%B %e, %Y at %R UTC"));
}
if (svalue != NULL)
{
label = gtk_label_new (svalue);
gtk_table_attach_defaults (GTK_TABLE (information->table_location),
label, 1, 2, row, row + 1);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_widget_show (label);
if (!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
}
g_free (svalue);
row++;
}
#if HAVE_LIBCHAMPLAIN
if (has_position &&
!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))
{
/* Cannot be displayed in tooltips until Clutter-Gtk can deal with such
* windows */
display_map = TRUE;
}
#endif
if (row > 0)
{
/* We can display some fields */
gtk_widget_show (information->table_location);
}
else if (!display_map)
{
/* Can't display either fields or map */
gtk_widget_hide (information->vbox_location);
return;
}
#if HAVE_LIBCHAMPLAIN
if (display_map)
{
ClutterActor *marker;
ChamplainLayer *layer;
information->map_view_embed = gtk_champlain_embed_new ();
information->map_view = gtk_champlain_embed_get_view (
GTK_CHAMPLAIN_EMBED (information->map_view_embed));
gtk_container_add (GTK_CONTAINER (information->viewport_map),
information->map_view_embed);
g_object_set (G_OBJECT (information->map_view),
"show-license", TRUE,
"scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
"zoom-level", 10,
NULL);
layer = champlain_layer_new ();
champlain_view_add_layer (information->map_view, layer);
marker = champlain_marker_new_with_text (
empathy_contact_get_name (information->contact), NULL, NULL, NULL);
champlain_base_marker_set_position (CHAMPLAIN_BASE_MARKER (marker), lat, lon);
clutter_container_add (CLUTTER_CONTAINER (layer), marker, NULL);
champlain_view_center_on (information->map_view, lat, lon);
gtk_widget_show_all (information->viewport_map);
}
#endif
gtk_widget_show (information->vbox_location);
}
static void
build_ui (EmerillonWindow *self)
{
GtkAction *action;
GtkWidget *vbox;
GtkWidget *menubar;
GtkToolItem *throbber;
GtkWidget *viewport;
GtkWidget *hpaned;
GtkWidget *embed_view;
ClutterActor *scale;
GError *error = NULL;
/* Action entries. */
self->priv->main_actions = gtk_action_group_new ("MenuActionsWindow");
gtk_action_group_set_translation_domain (self->priv->main_actions,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (self->priv->main_actions, action_entries,
G_N_ELEMENTS (action_entries), self);
/* Toggle entries. */
gtk_action_group_add_toggle_actions (self->priv->main_actions,
toggle_entries, G_N_ELEMENTS (toggle_entries), self);
/* Radio entries. */
gtk_action_group_add_radio_actions (self->priv->main_actions,
radio_entries, G_N_ELEMENTS (radio_entries), 0,
G_CALLBACK (cmd_map_change_map), self);
/* Short labels. */
action = gtk_action_group_get_action (self->priv->main_actions,
"ViewZoomIn");
g_object_set (action, "short_label", _("In"), NULL);
action = gtk_action_group_get_action (self->priv->main_actions,
"ViewZoomOut");
g_object_set (action, "short_label", _("Out"), NULL);
/* UI manager. */
self->priv->ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (self->priv->ui_manager,
self->priv->main_actions, 0);
if (!gtk_ui_manager_add_ui_from_file (self->priv->ui_manager,
EMERILLON_DATADIR "/emerillon-ui.xml", &error))
{
g_warning ("building menus failed: %s", error->message);
g_error_free (error);
return;
}
g_signal_connect (self->priv->ui_manager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), self);
g_signal_connect (self->priv->ui_manager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), self);
gtk_window_add_accel_group (GTK_WINDOW (self),
gtk_ui_manager_get_accel_group (self->priv->ui_manager));
/* Main box. */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (self), vbox);
gtk_widget_show (vbox);
/* Menu. */
menubar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/MainMenu");
g_assert (GTK_IS_WIDGET (menubar));
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
/* Toolbar. */
self->priv->toolbar = gtk_ui_manager_get_widget (self->priv->ui_manager,
"/Toolbar");
gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->toolbar),
"primary-toolbar");
self->priv->throbber = gtk_spinner_new ();
throbber = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (throbber), self->priv->throbber);
gtk_widget_show (GTK_WIDGET (self->priv->throbber));
gtk_widget_show (GTK_WIDGET (throbber));
gtk_toolbar_insert (GTK_TOOLBAR (self->priv->toolbar), throbber,
-1);
gtk_box_pack_start (GTK_BOX (vbox), self->priv->toolbar,
FALSE, FALSE, 0);
gtk_widget_show (self->priv->toolbar);
/* Statusbar. */
self->priv->statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (vbox),
GTK_WIDGET (self->priv->statusbar), FALSE, FALSE, 0);
gtk_widget_show (self->priv->statusbar);
self->priv->tooltip_message_context_id = gtk_statusbar_get_context_id (
GTK_STATUSBAR (self->priv->statusbar), "tooltip-message");
/* Viewport. */
viewport = gtk_frame_new (NULL);
/* Map. */
embed_view = gtk_champlain_embed_new ();
gtk_container_add (GTK_CONTAINER (viewport), embed_view);
/* FIXME: workaround for a champlain-gtk bug, replace with _show(). */
gtk_widget_show_all (embed_view);
self->priv->view = gtk_champlain_embed_get_view (GTK_CHAMPLAIN_EMBED (embed_view));
g_signal_connect (self->priv->view, "notify::zoom-level",
G_CALLBACK (zoom_changed_cb), self);
g_signal_connect (self->priv->view, "notify::map-source",
G_CALLBACK (zoom_changed_cb), self);
g_signal_connect (self->priv->view, "notify::state",
G_CALLBACK (state_changed_cb), self);
g_object_set (self->priv->view, "zoom-level", 1,
"kinetic-mode", TRUE,
NULL);
champlain_view_center_on (self->priv->view, 40, 0);
scale = champlain_scale_new ();
champlain_scale_connect_view (CHAMPLAIN_SCALE (scale), self->priv->view);
/* align to the bottom left */
champlain_view_bin_layout_add (self->priv->view, scale,
CLUTTER_BIN_ALIGNMENT_START, CLUTTER_BIN_ALIGNMENT_END);
/* Sidebar. */
self->priv->sidebar = emerillon_sidebar_new ();
gtk_widget_set_size_request (self->priv->sidebar, 200, -1);
/* Horizontal pane. */
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack1 (GTK_PANED (hpaned), self->priv->sidebar, FALSE, FALSE);
gtk_paned_pack2 (GTK_PANED (hpaned), viewport, TRUE, FALSE);
gtk_widget_show (self->priv->sidebar);
gtk_widget_show (viewport);
g_signal_connect_after (self->priv->sidebar, "show",
G_CALLBACK (sidebar_visibility_changed_cb), self);
g_signal_connect_after (self->priv->sidebar, "hide",
G_CALLBACK (sidebar_visibility_changed_cb), self);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show (hpaned);
update_ui_visibility (self);
}
GtkWidget *bar_pane_gps_new(const gchar *id, const gchar *title, const gchar *map_id,
const gint zoom, const gdouble latitude, const gdouble longitude,
gboolean expanded, gint height)
{
PaneGPSData *pgd;
GtkWidget *vbox, *frame;
GtkWidget *gpswidget, *viewport;
GtkWidget *status, *state, *progress, *slider;
ChamplainLayer *layer;
ChamplainView *view;
const gchar *slider_list[] = {GTK_STOCK_ZOOM_IN, GTK_STOCK_ZOOM_OUT, NULL};
const gchar **slider_icons = slider_list;
pgd = g_new0(PaneGPSData, 1);
pgd->pane.pane_set_fd = bar_pane_gps_set_fd;
pgd->pane.pane_notify_selection = bar_pane_gps_notify_selection;
pgd->pane.pane_event = bar_pane_gps_event;
pgd->pane.pane_write_config = bar_pane_gps_write_config;
pgd->pane.title = bar_pane_expander_title(title);
pgd->pane.id = g_strdup(id);
pgd->pane.type = PANE_GPS;
pgd->pane.expanded = expanded;
pgd->height = height;
frame = gtk_frame_new(NULL);
vbox = gtk_vbox_new(FALSE, 0);
gpswidget = gtk_champlain_embed_new();
view = gtk_champlain_embed_get_view(GTK_CHAMPLAIN_EMBED(gpswidget));
gtk_box_pack_start(GTK_BOX(vbox), gpswidget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
status = gtk_hbox_new(FALSE,0);
slider = gtk_scale_button_new(GTK_ICON_SIZE_SMALL_TOOLBAR, 1, 17, 1, slider_icons);
gtk_widget_set_tooltip_text(slider, "Zoom");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(slider), (gdouble)zoom);
progress = gtk_progress_bar_new();
state = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(state), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(slider), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(state), FALSE, FALSE, 5);
gtk_box_pack_end(GTK_BOX(status), GTK_WIDGET(progress), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox),GTK_WIDGET(status), FALSE, FALSE, 0);
layer = champlain_layer_new();
champlain_view_add_layer(view, layer);
pgd->icon_layer = layer;
pgd->gps_view = CLUTTER_ACTOR(view);
pgd->widget = frame;
pgd->progress = progress;
pgd->slider = slider;
pgd->state = state;
bar_pane_gps_set_map_source(pgd, map_id);
g_object_set(G_OBJECT(view), "scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
"zoom-level", zoom,
"keep-center-on-resize", TRUE,
/* This seems to be broken, https://bugzilla.gnome.org/show_bug.cgi?id=596419
"decel-rate", 1.0,
*/
"show-license", TRUE,
"zoom-on-double-click", FALSE,
"max-zoom-level", 17,
"min-zoom-level", 1,
NULL);
champlain_view_center_on(view, latitude, longitude);
pgd->centre_map_checked = TRUE;
g_object_set_data(G_OBJECT(pgd->widget), "pane_data", pgd);
g_signal_connect(G_OBJECT(pgd->widget), "destroy", G_CALLBACK(bar_pane_gps_destroy), pgd);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request(pgd->widget, -1, height);
clutter_set_motion_events_enabled(TRUE);
g_signal_connect(G_OBJECT(gpswidget), "button_press_event", G_CALLBACK(bar_pane_gps_map_keypress_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::state", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::zoom-level", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(G_OBJECT(slider), "value-changed", G_CALLBACK(bar_pane_gps_slider_changed_cb), pgd);
file_data_register_notify_func(bar_pane_gps_notify_cb, pgd, NOTIFY_PRIORITY_LOW);
pgd->create_markers_id = 0;
pgd->enable_markers_checked = TRUE;
pgd->centre_map_checked = TRUE;
return pgd->widget;
}
int
main (int argc,
char *argv[])
{
ClutterActor *actor, *stage, *buttons, *button;
ChamplainMarkerLayer *layer;
ChamplainPathLayer *path;
gfloat width, total_width = 0;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_actor_set_size (stage, 800, 600);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* Create the map view */
actor = champlain_view_new ();
clutter_actor_set_size (CLUTTER_ACTOR (actor), 800, 600);
clutter_actor_add_child (stage, actor);
/* Create the buttons */
buttons = clutter_actor_new ();
clutter_actor_set_position (buttons, PADDING, PADDING);
button = make_button ("Zoom in");
clutter_actor_add_child (buttons, button);
clutter_actor_set_reactive (button, TRUE);
clutter_actor_get_size (button, &width, NULL);
total_width += width + PADDING;
g_signal_connect (button, "button-release-event",
G_CALLBACK (zoom_in),
actor);
button = make_button ("Zoom out");
clutter_actor_add_child (buttons, button);
clutter_actor_set_reactive (button, TRUE);
clutter_actor_set_position (button, total_width, 0);
clutter_actor_get_size (button, &width, NULL);
g_signal_connect (button, "button-release-event",
G_CALLBACK (zoom_out),
actor);
clutter_actor_add_child (stage, buttons);
ClutterContent *canvas;
canvas = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 512, 256);
g_signal_connect (canvas, "draw", G_CALLBACK (draw_background_tile), NULL);
clutter_content_invalidate (canvas);
champlain_view_set_background_pattern (CHAMPLAIN_VIEW (actor), canvas);
/* Create the markers and marker layer */
layer = create_marker_layer (CHAMPLAIN_VIEW (actor), &path);
champlain_view_add_layer (CHAMPLAIN_VIEW (actor), CHAMPLAIN_LAYER (layer));
/* Connect to the click event */
clutter_actor_set_reactive (actor, TRUE);
g_signal_connect (actor, "button-release-event",
G_CALLBACK (map_view_button_release_cb),
actor);
/* Finish initialising the map view */
g_object_set (G_OBJECT (actor), "zoom-level", 12,
"kinetic-mode", TRUE, NULL);
champlain_view_center_on (CHAMPLAIN_VIEW (actor), 45.466, -73.75);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
int
main (int argc,
char *argv[])
{
GtkWidget *window;
GtkWidget *widget, *vbox, *bbox, *button, *viewport, *image;
ChamplainView *view;
ChamplainMarkerLayer *layer;
ClutterActor *scale;
ChamplainLicense *license_actor;
if (gtk_clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
/* create the main, top level, window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* give the window a 10px wide border */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* give it the title */
gtk_window_set_title (GTK_WINDOW (window), "libchamplain Gtk+ demo");
/* Connect the destroy event of the window with our on_destroy function
* When the window is about to be destroyed we get a notificaiton and
* stop the main GTK loop
*/
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (on_destroy),
NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
widget = gtk_champlain_embed_new ();
view = gtk_champlain_embed_get_view (GTK_CHAMPLAIN_EMBED (widget));
clutter_actor_set_reactive (CLUTTER_ACTOR (view), TRUE);
g_signal_connect (view, "button-release-event", G_CALLBACK (mouse_click_cb), view);
g_object_set (G_OBJECT (view),
"kinetic-mode", TRUE,
"zoom-level", 5,
NULL);
g_object_set_data (G_OBJECT (view), "window", window);
scale = champlain_scale_new ();
champlain_scale_connect_view (CHAMPLAIN_SCALE (scale), view);
/* align to the bottom left */
clutter_actor_set_x_expand (scale, TRUE);
clutter_actor_set_y_expand (scale, TRUE);
clutter_actor_set_x_align (scale, CLUTTER_ACTOR_ALIGN_START);
clutter_actor_set_y_align (scale, CLUTTER_ACTOR_ALIGN_END);
clutter_actor_add_child (CLUTTER_ACTOR (view), scale);
license_actor = champlain_view_get_license_actor (view);
champlain_license_set_extra_text (license_actor, "Don't eat cereals with orange juice\nIt tastes bad");
champlain_view_center_on (CHAMPLAIN_VIEW (view), 45.466, -73.75);
layer = create_marker_layer (view, &path);
champlain_view_add_layer (view, CHAMPLAIN_LAYER (path));
champlain_view_add_layer (view, CHAMPLAIN_LAYER (layer));
path_layer = champlain_path_layer_new ();
/* Cheap approx of Highway 10 */
append_point (path_layer, 45.4095, -73.3197);
append_point (path_layer, 45.4104, -73.2846);
append_point (path_layer, 45.4178, -73.2239);
append_point (path_layer, 45.4176, -73.2181);
append_point (path_layer, 45.4151, -73.2126);
append_point (path_layer, 45.4016, -73.1926);
append_point (path_layer, 45.3994, -73.1877);
append_point (path_layer, 45.4000, -73.1815);
append_point (path_layer, 45.4151, -73.1218);
champlain_view_add_layer (view, CHAMPLAIN_LAYER (path_layer));
gtk_widget_set_size_request (widget, 640, 481);
bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("zoom-in", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), image);
gtk_button_set_label (GTK_BUTTON (button), "Zoom In");
g_signal_connect (button, "clicked", G_CALLBACK (zoom_in), view);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("zoom-out", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), image);
gtk_button_set_label (GTK_BUTTON (button), "Zoom Out");
g_signal_connect (button, "clicked", G_CALLBACK (zoom_out), view);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_toggle_button_new_with_label ("Markers");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (button, "toggled", G_CALLBACK (toggle_layer), layer);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_toggle_button_new_with_label ("Toggle wrap");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
champlain_view_get_horizontal_wrap (view));
g_signal_connect (button, "toggled", G_CALLBACK (toggle_wrap), view);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_combo_box_new ();
build_combo_box (GTK_COMBO_BOX (button));
gtk_combo_box_set_active (GTK_COMBO_BOX (button), 0);
g_signal_connect (button, "changed", G_CALLBACK (map_source_changed), view);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_spin_button_new_with_range (0, 20, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (button),
champlain_view_get_zoom_level (view));
g_signal_connect (button, "changed", G_CALLBACK (zoom_changed), view);
g_signal_connect (view, "notify::zoom-level", G_CALLBACK (map_zoom_changed),
button);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("list-add", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), image);
g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), view);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("camera-photo-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), image);
g_signal_connect (button, "clicked", G_CALLBACK (export_png), view);
gtk_container_add (GTK_CONTAINER (bbox), button);
button = gtk_image_new ();
gtk_widget_set_size_request (button, 22, -1);
g_signal_connect (view, "notify::state", G_CALLBACK (view_state_changed),
button);
gtk_box_pack_end (GTK_BOX (bbox), button, FALSE, FALSE, 0);
viewport = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (viewport), widget);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (vbox), viewport);
/* and insert it into the main window */
gtk_container_add (GTK_CONTAINER (window), vbox);
/* make sure that everything, window and label, are visible */
gtk_widget_show_all (window);
/* start the main loop */
gtk_main ();
return 0;
}
