2 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
4 * Copyright (c) 2015, Rob Norris <rw_norris@hotmail.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #include <glib/gstdio.h>
30 #include <glib/gi18n.h>
43 #include "preferences.h"
44 #include "icons/icons.h"
45 #include "mapnik_interface.h"
46 #include "background.h"
48 #include "vikmapslayer.h"
50 struct _VikMapnikLayerClass
52 VikLayerClass object_class;
55 static VikLayerParamData file_default ( void )
57 VikLayerParamData data;
62 static VikLayerParamData size_default ( void ) { return VIK_LPD_UINT ( 256 ); }
63 static VikLayerParamData alpha_default ( void ) { return VIK_LPD_UINT ( 255 ); }
65 static VikLayerParamData cache_dir_default ( void )
67 VikLayerParamData data;
68 data.s = g_strconcat ( maps_layer_default_dir(), "MapnikRendering", NULL );
72 static VikLayerParamScale scales[] = {
73 { 0, 255, 5, 0 }, // Alpha
74 { 64, 1024, 8, 0 }, // Tile size
75 { 0, 1024, 12, 0 }, // Rerender timeout hours
78 VikLayerParam mapnik_layer_params[] = {
79 { VIK_LAYER_MAPNIK, "config-file-mml", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("CSS (MML) Config File:"), VIK_LAYER_WIDGET_FILEENTRY, GINT_TO_POINTER(VF_FILTER_CARTO), NULL,
80 N_("CartoCSS configuration file"), file_default, NULL, NULL },
81 { VIK_LAYER_MAPNIK, "config-file-xml", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("XML Config File:"), VIK_LAYER_WIDGET_FILEENTRY, GINT_TO_POINTER(VF_FILTER_XML), NULL,
82 N_("Mapnik XML configuration file"), file_default, NULL, NULL },
83 { VIK_LAYER_MAPNIK, "alpha", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Alpha:"), VIK_LAYER_WIDGET_HSCALE, &scales[0], NULL,
84 NULL, alpha_default, NULL, NULL },
85 { VIK_LAYER_MAPNIK, "use-file-cache", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_GROUP_NONE, N_("Use File Cache:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL,
86 NULL, vik_lpd_true_default, NULL, NULL },
87 { VIK_LAYER_MAPNIK, "file-cache-dir", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("File Cache Directory:"), VIK_LAYER_WIDGET_FOLDERENTRY, NULL, NULL,
88 NULL, cache_dir_default, NULL, NULL },
99 static const gchar* mapnik_layer_tooltip ( VikMapnikLayer *vml );
100 static void mapnik_layer_marshall( VikMapnikLayer *vml, guint8 **data, gint *len );
101 static VikMapnikLayer *mapnik_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp );
102 static gboolean mapnik_layer_set_param ( VikMapnikLayer *vml, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation );
103 static VikLayerParamData mapnik_layer_get_param ( VikMapnikLayer *vml, guint16 id, gboolean is_file_operation );
104 static VikMapnikLayer *mapnik_layer_new ( VikViewport *vvp );
105 static VikMapnikLayer *mapnik_layer_create ( VikViewport *vp );
106 static void mapnik_layer_free ( VikMapnikLayer *vml );
107 static void mapnik_layer_draw ( VikMapnikLayer *vml, VikViewport *vp );
108 static void mapnik_layer_add_menu_items ( VikMapnikLayer *vml, GtkMenu *menu, gpointer vlp );
110 static gpointer mapnik_feature_create ( VikWindow *vw, VikViewport *vvp)
115 static gboolean mapnik_feature_release ( VikMapnikLayer *vml, GdkEventButton *event, VikViewport *vvp );
117 // See comment in viktrwlayer.c for advice on values used
119 static VikToolInterface mapnik_tools[] = {
122 { { "MapnikFeatures", GTK_STOCK_INFO, N_("_Mapnik Features"), NULL, N_("Mapnik Features"), 0 },
123 (VikToolConstructorFunc) mapnik_feature_create,
129 (VikToolMouseFunc) mapnik_feature_release,
132 GDK_LEFT_PTR, NULL, NULL },
135 static void mapnik_layer_post_read (VikLayer *vl, VikViewport *vvp, gboolean from_file);
137 VikLayerInterface vik_mapnik_layer_interface = {
139 N_("Mapnik Rendering"),
141 &vikmapniklayer_pixbuf, // icon
144 sizeof(mapnik_tools) / sizeof(VikToolInterface),
153 (VikLayerFuncCreate) mapnik_layer_create,
154 (VikLayerFuncRealize) NULL,
155 (VikLayerFuncPostRead) mapnik_layer_post_read,
156 (VikLayerFuncFree) mapnik_layer_free,
158 (VikLayerFuncProperties) NULL,
159 (VikLayerFuncDraw) mapnik_layer_draw,
160 (VikLayerFuncChangeCoordMode) NULL,
162 (VikLayerFuncGetTimestamp) NULL,
164 (VikLayerFuncSetMenuItemsSelection) NULL,
165 (VikLayerFuncGetMenuItemsSelection) NULL,
167 (VikLayerFuncAddMenuItems) mapnik_layer_add_menu_items,
168 (VikLayerFuncSublayerAddMenuItems) NULL,
170 (VikLayerFuncSublayerRenameRequest) NULL,
171 (VikLayerFuncSublayerToggleVisible) NULL,
172 (VikLayerFuncSublayerTooltip) NULL,
173 (VikLayerFuncLayerTooltip) mapnik_layer_tooltip,
174 (VikLayerFuncLayerSelected) NULL,
176 (VikLayerFuncMarshall) mapnik_layer_marshall,
177 (VikLayerFuncUnmarshall) mapnik_layer_unmarshall,
179 (VikLayerFuncSetParam) mapnik_layer_set_param,
180 (VikLayerFuncGetParam) mapnik_layer_get_param,
181 (VikLayerFuncChangeParam) NULL,
183 (VikLayerFuncReadFileData) NULL,
184 (VikLayerFuncWriteFileData) NULL,
186 (VikLayerFuncDeleteItem) NULL,
187 (VikLayerFuncCutItem) NULL,
188 (VikLayerFuncCopyItem) NULL,
189 (VikLayerFuncPasteItem) NULL,
190 (VikLayerFuncFreeCopiedItem) NULL,
191 (VikLayerFuncDragDropRequest) NULL,
193 (VikLayerFuncSelectClick) NULL,
194 (VikLayerFuncSelectMove) NULL,
195 (VikLayerFuncSelectRelease) NULL,
196 (VikLayerFuncSelectedViewportMenu) NULL,
199 struct _VikMapnikLayer {
201 gchar *filename_css; // CartoCSS MML File - use 'carto' to convert into xml
205 guint tile_size_x; // Y is the same as X ATM
208 guint rerender_timeout;
210 gboolean use_file_cache;
211 gchar *file_cache_dir;
213 VikCoord rerender_ul;
214 VikCoord rerender_br;
215 gdouble rerender_zoom;
216 GtkWidget *right_click_menu;
219 #define MAPNIK_PREFS_GROUP_KEY "mapnik"
220 #define MAPNIK_PREFS_NAMESPACE "mapnik."
222 static VikLayerParamData plugins_default ( void )
224 VikLayerParamData data;
226 data.s = g_strdup ( "input" );
228 if ( g_file_test ( "/usr/lib/mapnik/input", G_FILE_TEST_EXISTS ) )
229 data.s = g_strdup ( "/usr/lib/mapnik/input" );
230 // Current Debian locations
231 else if ( g_file_test ( "/usr/lib/mapnik/3.0/input", G_FILE_TEST_EXISTS ) )
232 data.s = g_strdup ( "/usr/lib/mapnik/3.0/input" );
233 else if ( g_file_test ( "/usr/lib/mapnik/2.2/input", G_FILE_TEST_EXISTS ) )
234 data.s = g_strdup ( "/usr/lib/mapnik/2.2/input" );
236 data.s = g_strdup ( "" );
241 static VikLayerParamData fonts_default ( void )
243 // Possibly should be string list to allow loading from multiple directories
244 VikLayerParamData data;
246 data.s = g_strdup ( "C:\\Windows\\Fonts" );
247 #elif defined __APPLE__
248 data.s = g_strdup ( "/Library/Fonts" );
250 data.s = g_strdup ( "/usr/share/fonts" );
255 static VikLayerParam prefs[] = {
256 // Changing these values only applies before first mapnik layer is 'created'
257 { VIK_LAYER_NUM_TYPES, MAPNIK_PREFS_NAMESPACE"plugins_directory", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("Plugins Directory:"), VIK_LAYER_WIDGET_FOLDERENTRY, NULL, NULL, N_("You need to restart Viking for a change to this value to be used"), plugins_default, NULL, NULL },
258 { VIK_LAYER_NUM_TYPES, MAPNIK_PREFS_NAMESPACE"fonts_directory", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("Fonts Directory:"), VIK_LAYER_WIDGET_FOLDERENTRY, NULL, NULL, N_("You need to restart Viking for a change to this value to be used"), fonts_default, NULL, NULL },
259 { VIK_LAYER_NUM_TYPES, MAPNIK_PREFS_NAMESPACE"recurse_fonts_directory", VIK_LAYER_PARAM_BOOLEAN, VIK_LAYER_GROUP_NONE, N_("Recurse Fonts Directory:"), VIK_LAYER_WIDGET_CHECKBUTTON, NULL, NULL, N_("You need to restart Viking for a change to this value to be used"), vik_lpd_true_default, NULL, NULL },
260 { VIK_LAYER_NUM_TYPES, MAPNIK_PREFS_NAMESPACE"rerender_after", VIK_LAYER_PARAM_UINT, VIK_LAYER_GROUP_NONE, N_("Rerender Timeout (hours):"), VIK_LAYER_WIDGET_SPINBUTTON, &scales[2], NULL, N_("You need to restart Viking for a change to this value to be used"), NULL, NULL, NULL },
261 // Changeable any time
262 { VIK_LAYER_NUM_TYPES, MAPNIK_PREFS_NAMESPACE"carto", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("CartoCSS:"), VIK_LAYER_WIDGET_FILEENTRY, NULL, NULL, N_("The program to convert CartoCSS files into Mapnik XML"), NULL, NULL, NULL },
265 static time_t planet_import_time;
267 static GMutex *tp_mutex;
268 static GHashTable *requests = NULL;
271 * vik_mapnik_layer_init:
273 * Just initialize preferences
275 void vik_mapnik_layer_init (void)
277 a_preferences_register_group ( MAPNIK_PREFS_GROUP_KEY, "Mapnik" );
280 VikLayerParamData tmp = plugins_default();
281 a_preferences_register(&prefs[i++], tmp, MAPNIK_PREFS_GROUP_KEY);
283 tmp = fonts_default();
284 a_preferences_register(&prefs[i++], tmp, MAPNIK_PREFS_GROUP_KEY);
287 a_preferences_register(&prefs[i++], tmp, MAPNIK_PREFS_GROUP_KEY);
289 tmp.u = 168; // One week
290 a_preferences_register(&prefs[i++], tmp, MAPNIK_PREFS_GROUP_KEY);
293 a_preferences_register(&prefs[i++], tmp, MAPNIK_PREFS_GROUP_KEY);
297 * vik_mapnik_layer_post_init:
299 * Initialize data structures - now that reading preferences is OK to perform
301 void vik_mapnik_layer_post_init (void)
303 tp_mutex = vik_mutex_new();
305 // Just storing keys only
306 requests = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL );
308 guint hours = a_preferences_get (MAPNIK_PREFS_NAMESPACE"rerender_after")->u;
309 GDateTime *now = g_date_time_new_now_local ();
310 GDateTime *then = g_date_time_add_hours (now, -hours);
311 planet_import_time = g_date_time_to_unix (then);
312 g_date_time_unref ( now );
313 g_date_time_unref ( then );
316 // Similar to mod_tile method to mark DB has been imported/significantly changed to cause a rerendering of all tiles
317 gchar *import_time_file = g_strconcat ( a_get_viking_dir(), G_DIR_SEPARATOR_S, "planet-import-complete", NULL );
318 if ( g_stat ( import_time_file, &gsb ) == 0 ) {
319 // Only update if newer
320 if ( planet_import_time > gsb.st_mtime )
321 planet_import_time = gsb.st_mtime;
323 g_free ( import_time_file );
326 void vik_mapnik_layer_uninit ()
328 vik_mutex_free (tp_mutex);
331 // NB Only performed once per program run
332 static void mapnik_layer_class_init ( VikMapnikLayerClass *klass )
334 VikLayerParamData *pd = a_preferences_get (MAPNIK_PREFS_NAMESPACE"plugins_directory");
335 VikLayerParamData *fd = a_preferences_get (MAPNIK_PREFS_NAMESPACE"fonts_directory");
336 VikLayerParamData *rfd = a_preferences_get (MAPNIK_PREFS_NAMESPACE"recurse_fonts_directory");
338 if ( pd && fd && rfd )
339 mapnik_interface_initialize ( pd->s, fd->s, rfd->b );
341 g_critical ( "Unable to initialize mapnik interface from preferences" );
344 GType vik_mapnik_layer_get_type ()
346 static GType vml_type = 0;
349 static const GTypeInfo vml_info = {
350 sizeof (VikMapnikLayerClass),
351 NULL, /* base_init */
352 NULL, /* base_finalize */
353 (GClassInitFunc) mapnik_layer_class_init, /* class init */
354 NULL, /* class_finalize */
355 NULL, /* class_data */
356 sizeof (VikMapnikLayer),
358 NULL /* instance init */
360 vml_type = g_type_register_static ( VIK_LAYER_TYPE, "VikMapnikLayer", &vml_info, 0 );
366 static const gchar* mapnik_layer_tooltip ( VikMapnikLayer *vml )
368 return vml->filename_xml;
371 static void mapnik_layer_set_file_xml ( VikMapnikLayer *vml, const gchar *name )
373 if ( vml->filename_xml )
374 g_free (vml->filename_xml);
375 // Mapnik doesn't seem to cope with relative filenames
376 if ( g_strcmp0 (name, "" ) )
377 vml->filename_xml = vu_get_canonical_filename ( VIK_LAYER(vml), name);
379 vml->filename_xml = g_strdup (name);
382 static void mapnik_layer_set_file_css ( VikMapnikLayer *vml, const gchar *name )
384 if ( vml->filename_css )
385 g_free (vml->filename_css);
386 vml->filename_css = g_strdup (name);
389 static void mapnik_layer_set_cache_dir ( VikMapnikLayer *vml, const gchar *name )
391 if ( vml->file_cache_dir )
392 g_free (vml->file_cache_dir);
393 vml->file_cache_dir = g_strdup (name);
396 static void mapnik_layer_marshall( VikMapnikLayer *vml, guint8 **data, gint *len )
398 vik_layer_marshall_params ( VIK_LAYER(vml), data, len );
401 static VikMapnikLayer *mapnik_layer_unmarshall( guint8 *data, gint len, VikViewport *vvp )
403 VikMapnikLayer *rv = mapnik_layer_new ( vvp );
404 vik_layer_unmarshall_params ( VIK_LAYER(rv), data, len, vvp );
408 static gboolean mapnik_layer_set_param ( VikMapnikLayer *vml, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation )
411 case PARAM_CONFIG_CSS: mapnik_layer_set_file_css (vml, data.s); break;
412 case PARAM_CONFIG_XML: mapnik_layer_set_file_xml (vml, data.s); break;
413 case PARAM_ALPHA: if ( data.u <= 255 ) vml->alpha = data.u; break;
414 case PARAM_USE_FILE_CACHE: vml->use_file_cache = data.b; break;
415 case PARAM_FILE_CACHE_DIR: mapnik_layer_set_cache_dir (vml, data.s); break;
421 static VikLayerParamData mapnik_layer_get_param ( VikMapnikLayer *vml, guint16 id, gboolean is_file_operation )
423 VikLayerParamData data;
425 case PARAM_CONFIG_CSS: {
426 data.s = vml->filename_css;
427 gboolean set = FALSE;
428 if ( is_file_operation ) {
429 if ( a_vik_get_file_ref_format() == VIK_FILE_REF_FORMAT_RELATIVE ) {
430 gchar *cwd = g_get_current_dir();
432 data.s = file_GetRelativeFilename ( cwd, vml->filename_css );
433 if ( !data.s ) data.s = "";
439 data.s = vml->filename_css ? vml->filename_css : "";
442 case PARAM_CONFIG_XML: {
443 data.s = vml->filename_xml;
444 gboolean set = FALSE;
445 if ( is_file_operation ) {
446 if ( a_vik_get_file_ref_format() == VIK_FILE_REF_FORMAT_RELATIVE ) {
447 gchar *cwd = g_get_current_dir();
449 data.s = file_GetRelativeFilename ( cwd, vml->filename_xml );
450 if ( !data.s ) data.s = "";
456 data.s = vml->filename_xml ? vml->filename_xml : "";
459 case PARAM_ALPHA: data.u = vml->alpha; break;
460 case PARAM_USE_FILE_CACHE: data.b = vml->use_file_cache; break;
461 case PARAM_FILE_CACHE_DIR: data.s = vml->file_cache_dir; break;
470 static VikMapnikLayer *mapnik_layer_new ( VikViewport *vvp )
472 VikMapnikLayer *vml = VIK_MAPNIK_LAYER ( g_object_new ( VIK_MAPNIK_LAYER_TYPE, NULL ) );
473 vik_layer_set_type ( VIK_LAYER(vml), VIK_LAYER_MAPNIK );
474 vik_layer_set_defaults ( VIK_LAYER(vml), vvp );
475 vml->tile_size_x = size_default().u; // FUTURE: Is there any use in this being configurable?
477 vml->mi = mapnik_interface_new();
483 * ATM don't have any version issues AFAIK
484 * Tested with carto 0.14.0
486 gboolean carto_load ( VikMapnikLayer *vml, VikViewport *vvp )
488 gchar *mystdout = NULL;
489 gchar *mystderr = NULL;
490 GError *error = NULL;
492 VikLayerParamData *vlpd = a_preferences_get(MAPNIK_PREFS_NAMESPACE"carto");
493 gchar *command = g_strdup_printf ( "%s %s", vlpd->s, vml->filename_css );
495 gboolean answer = TRUE;
496 //gchar *args[2]; args[0] = vlpd->s; args[1] = vml->filename_css;
498 //if ( g_spawn_async_with_pipes ( NULL, args, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, &pid, NULL, &carto_stdout, &carto_error, &error ) ) {
499 // cf code in babel.c to handle stdout
501 // NB Running carto may take several seconds
502 // especially for large style sheets like the default OSM Mapnik style (~6 seconds on my system)
503 VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_WIDGET(vvp));
505 gchar *msg = g_strdup_printf ( "%s: %s", _("Running"), command );
506 vik_window_statusbar_update ( vw, msg, VIK_STATUSBAR_INFO );
507 vik_window_set_busy_cursor ( vw );
512 // You won't get a sensible timing measurement if running too old a GLIB
513 #if GLIB_CHECK_VERSION (2, 28, 0)
514 tt1 = g_get_real_time ();
517 if ( g_spawn_command_line_sync ( command, &mystdout, &mystderr, NULL, &error ) ) {
518 #if GLIB_CHECK_VERSION (2, 28, 0)
519 tt2 = g_get_real_time ();
522 if ( strlen(mystderr) > 1 ) {
523 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_WIDGET(vvp), _("Error running carto command:\n%s"), mystderr );
527 // NB This will overwrite the specified XML file
528 if ( ! ( vml->filename_xml && strlen (vml->filename_xml) > 1 ) ) {
529 // XML Not specified so try to create based on CSS file name
530 GRegex *regex = g_regex_new ( "\\.mml$|\\.mss|\\.css$", G_REGEX_CASELESS, 0, &error );
532 g_critical ("%s: %s", __FUNCTION__, error->message );
533 if ( vml->filename_xml )
534 g_free (vml->filename_xml);
535 vml->filename_xml = g_regex_replace_literal ( regex, vml->filename_css, -1, 0, ".xml", 0, &error );
537 g_warning ("%s: %s", __FUNCTION__, error->message );
538 // Prevent overwriting self
539 if ( !g_strcmp0 ( vml->filename_xml, vml->filename_css ) ) {
540 vml->filename_xml = g_strconcat ( vml->filename_css, ".xml", NULL );
543 if ( !g_file_set_contents (vml->filename_xml, mystdout, -1, &error) ) {
544 g_warning ("%s: %s", __FUNCTION__, error->message );
545 g_error_free (error);
552 g_warning ("%s: %s", __FUNCTION__, error->message );
553 g_error_free (error);
558 gchar *msg = g_strdup_printf ( "%s %s %.1f %s", vlpd->s, _(" completed in "), (gdouble)(tt2-tt1)/G_USEC_PER_SEC, _("seconds") );
559 vik_window_statusbar_update ( vw, msg, VIK_STATUSBAR_INFO );
561 vik_window_clear_busy_cursor ( vw );
569 static void mapnik_layer_post_read (VikLayer *vl, VikViewport *vvp, gboolean from_file)
571 VikMapnikLayer *vml = VIK_MAPNIK_LAYER(vl);
573 // Determine if carto needs to be run
574 gboolean do_carto = FALSE;
575 if ( vml->filename_css && strlen(vml->filename_css) > 1 ) {
576 if ( vml->filename_xml && strlen(vml->filename_xml) > 1) {
577 // Compare timestamps
579 if ( g_stat ( vml->filename_xml, &gsb1 ) == 0 ) {
581 if ( g_stat ( vml->filename_css, &gsb2 ) == 0 ) {
582 // Is CSS file newer than the XML file
583 if ( gsb2.st_mtime > gsb1.st_mtime )
586 g_debug ( "No need to run carto" );
590 // XML file doesn't exist
595 // No XML specified thus need to generate
601 // Don't load the XML config if carto load fails
602 if ( !carto_load ( vml, vvp ) )
605 gchar* ans = mapnik_interface_load_map_file ( vml->mi, vml->filename_xml, vml->tile_size_x, vml->tile_size_x );
607 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_WIDGET(vvp),
608 _("Mapnik error loading configuration file:\n%s"),
615 ui_add_recent_file ( vml->filename_xml );
619 #define MAPNIK_LAYER_FILE_CACHE_LAYOUT "%s"G_DIR_SEPARATOR_S"%d"G_DIR_SEPARATOR_S"%d"G_DIR_SEPARATOR_S"%d.png"
621 // Free returned string after use
622 static gchar *get_filename ( gchar *dir, guint x, guint y, guint z)
624 return g_strdup_printf ( MAPNIK_LAYER_FILE_CACHE_LAYOUT, dir, (17-z), x, y );
627 static void possibly_save_pixbuf ( VikMapnikLayer *vml, GdkPixbuf *pixbuf, MapCoord *ulm )
629 if ( vml->use_file_cache ) {
630 if ( vml->file_cache_dir ) {
631 GError *error = NULL;
632 gchar *filename = get_filename ( vml->file_cache_dir, ulm->x, ulm->y, ulm->scale );
634 gchar *dir = g_path_get_dirname ( filename );
635 if ( !g_file_test ( filename, G_FILE_TEST_EXISTS ) )
636 if ( g_mkdir_with_parents ( dir , 0777 ) != 0 )
637 g_warning ("%s: Failed to mkdir %s", __FUNCTION__, dir );
640 if ( !gdk_pixbuf_save (pixbuf, filename, "png", &error, NULL ) ) {
641 g_warning ("%s: %s", __FUNCTION__, error->message );
642 g_error_free (error);
655 const gchar* request;
661 * Common render function which can run in separate thread
663 static void render ( VikMapnikLayer *vml, VikCoord *ul, VikCoord *br, MapCoord *ulm )
665 gint64 tt1 = g_get_real_time ();
666 GdkPixbuf *pixbuf = mapnik_interface_render ( vml->mi, ul->north_south, ul->east_west, br->north_south, br->east_west );
667 gint64 tt2 = g_get_real_time ();
668 gdouble tt = (gdouble)(tt2-tt1)/1000000;
669 g_debug ( "Mapnik rendering completed in %.3f seconds", tt );
671 // A pixbuf to stick into cache incase of an unrenderable area - otherwise will get continually re-requested
672 pixbuf = gdk_pixbuf_scale_simple ( gdk_pixbuf_from_pixdata(&vikmapniklayer_pixbuf, FALSE, NULL), vml->tile_size_x, vml->tile_size_x, GDK_INTERP_BILINEAR );
674 possibly_save_pixbuf ( vml, pixbuf, ulm );
676 // NB Mapnik can apply alpha, but use our own function for now
677 if ( vml->alpha < 255 )
678 pixbuf = ui_pixbuf_scale_alpha ( pixbuf, vml->alpha );
679 a_mapcache_add ( pixbuf, (mapcache_extra_t){ tt }, ulm->x, ulm->y, ulm->z, MAP_ID_MAPNIK_RENDER, ulm->scale, vml->alpha, 0.0, 0.0, vml->filename_xml );
680 g_object_unref(pixbuf);
683 static void render_info_free ( RenderInfo *data )
687 g_free ( data->ulmc );
688 // NB No need to free the request/key - as this is freed by the hash table destructor
692 static void background ( RenderInfo *data, gpointer threaddata )
694 int res = a_background_thread_progress ( threaddata, 0 );
696 render ( data->vml, data->ul, data->br, data->ulmc );
699 g_mutex_lock(tp_mutex);
700 g_hash_table_remove (requests, data->request);
701 g_mutex_unlock(tp_mutex);
704 vik_layer_emit_update ( VIK_LAYER(data->vml) ); // NB update display from background
707 static void render_cancel_cleanup (RenderInfo *data)
712 #define REQUEST_HASHKEY_FORMAT "%d-%d-%d-%d-%d"
717 static void thread_add (VikMapnikLayer *vml, MapCoord *mul, VikCoord *ul, VikCoord *br, gint x, gint y, gint z, gint zoom, const gchar* name )
720 guint nn = name ? g_str_hash ( name ) : 0;
721 gchar *request = g_strdup_printf ( REQUEST_HASHKEY_FORMAT, x, y, z, zoom, nn );
723 g_mutex_lock(tp_mutex);
725 if ( g_hash_table_lookup_extended (requests, request, NULL, NULL ) ) {
727 g_mutex_unlock (tp_mutex);
731 RenderInfo *ri = g_malloc ( sizeof(RenderInfo) );
733 ri->ul = g_malloc ( sizeof(VikCoord) );
734 ri->br = g_malloc ( sizeof(VikCoord) );
735 ri->ulmc = g_malloc ( sizeof(MapCoord) );
736 memcpy(ri->ul, ul, sizeof(VikCoord));
737 memcpy(ri->br, br, sizeof(VikCoord));
738 memcpy(ri->ulmc, mul, sizeof(MapCoord));
739 ri->request = request;
741 g_hash_table_insert ( requests, request, NULL );
743 g_mutex_unlock (tp_mutex);
745 gchar *basename = g_path_get_basename (name);
746 gchar *description = g_strdup_printf ( _("Mapnik Render %d:%d:%d %s"), zoom, x, y, basename );
748 a_background_thread ( BACKGROUND_POOL_LOCAL_MAPNIK,
749 VIK_GTK_WINDOW_FROM_LAYER(vml),
751 (vik_thr_func) background,
753 (vik_thr_free_func) render_info_free,
754 (vik_thr_free_func) render_cancel_cleanup,
756 g_free ( description );
762 * If function returns GdkPixbuf properly, reference counter to this
763 * buffer has to be decreased, when buffer is no longer needed.
765 static GdkPixbuf *load_pixbuf ( VikMapnikLayer *vml, MapCoord *ulm, MapCoord *brm, gboolean *rerender )
768 GdkPixbuf *pixbuf = NULL;
769 gchar *filename = get_filename ( vml->file_cache_dir, ulm->x, ulm->y, ulm->scale );
772 if ( g_stat ( filename, &gsb ) == 0 ) {
774 GError *error = NULL;
775 pixbuf = gdk_pixbuf_new_from_file ( filename, &error );
777 g_warning ("%s: %s", __FUNCTION__, error->message );
778 g_error_free ( error );
781 if ( vml->alpha < 255 )
782 pixbuf = ui_pixbuf_set_alpha ( pixbuf, vml->alpha );
783 a_mapcache_add ( pixbuf, (mapcache_extra_t) { -42.0 }, ulm->x, ulm->y, ulm->z, MAP_ID_MAPNIK_RENDER, ulm->scale, vml->alpha, 0.0, 0.0, vml->filename_xml );
785 // If file is too old mark for rerendering
786 if ( planet_import_time < gsb.st_mtime ) {
796 * Caller has to decrease reference counter of returned
797 * GdkPixbuf, when buffer is no longer needed.
799 static GdkPixbuf *get_pixbuf ( VikMapnikLayer *vml, MapCoord *ulm, MapCoord *brm )
801 VikCoord ul; VikCoord br;
802 GdkPixbuf *pixbuf = NULL;
804 map_utils_iTMS_to_vikcoord (ulm, &ul);
805 map_utils_iTMS_to_vikcoord (brm, &br);
807 pixbuf = a_mapcache_get ( ulm->x, ulm->y, ulm->z, MAP_ID_MAPNIK_RENDER, ulm->scale, vml->alpha, 0.0, 0.0, vml->filename_xml );
810 gboolean rerender = FALSE;
811 if ( vml->use_file_cache && vml->file_cache_dir )
812 pixbuf = load_pixbuf ( vml, ulm, brm, &rerender );
813 if ( ! pixbuf || rerender ) {
815 thread_add (vml, ulm, &ul, &br, ulm->x, ulm->y, ulm->z, ulm->scale, vml->filename_xml );
817 // Run in the foreground
818 render ( vml, &ul, &br, ulm );
819 vik_layer_emit_update ( VIK_LAYER(vml) );
830 static void mapnik_layer_draw ( VikMapnikLayer *vml, VikViewport *vvp )
835 if ( vik_viewport_get_drawmode(vvp) != VIK_VIEWPORT_DRAWMODE_MERCATOR ) {
836 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vml))),
837 VIK_STATUSBAR_INFO, _("Mapnik Rendering must be in Mercator mode") );
842 gchar *copyright = mapnik_interface_get_copyright ( vml->mi );
844 vik_viewport_add_copyright ( vvp, copyright );
849 ul.mode = VIK_COORD_LATLON;
850 br.mode = VIK_COORD_LATLON;
851 vik_viewport_screen_to_coord ( vvp, 0, 0, &ul );
852 vik_viewport_screen_to_coord ( vvp, vik_viewport_get_width(vvp), vik_viewport_get_height(vvp), &br );
854 gdouble xzoom = vik_viewport_get_xmpp ( vvp );
855 gdouble yzoom = vik_viewport_get_ympp ( vvp );
859 if ( map_utils_vikcoord_to_iTMS ( &ul, xzoom, yzoom, &ulm ) &&
860 map_utils_vikcoord_to_iTMS ( &br, xzoom, yzoom, &brm ) ) {
861 // TODO: Understand if tilesize != 256 does this need to use shrinkfactors??
866 gint xmin = MIN(ulm.x, brm.x), xmax = MAX(ulm.x, brm.x);
867 gint ymin = MIN(ulm.y, brm.y), ymax = MAX(ulm.y, brm.y);
869 // Split rendering into a grid for the current viewport
870 // thus each individual 'tile' can then be stored in the map cache
871 for (gint x = xmin; x <= xmax; x++ ) {
872 for (gint y = ymin; y <= ymax; y++ ) {
878 pixbuf = get_pixbuf ( vml, &ulm, &brm );
881 map_utils_iTMS_to_vikcoord ( &ulm, &coord );
882 vik_viewport_coord_to_screen ( vvp, &coord, &xx, &yy );
883 vik_viewport_draw_pixbuf ( vvp, pixbuf, 0, 0, xx, yy, vml->tile_size_x, vml->tile_size_x );
884 g_object_unref(pixbuf);
889 // Done after so drawn on top
890 // Just a handy guide to tile blocks.
891 if ( vik_debug && vik_verbose ) {
892 GdkGC *black_gc = GTK_WIDGET(vvp)->style->black_gc;
893 gint width = vik_viewport_get_width(vvp);
894 gint height = vik_viewport_get_height(vvp);
896 ulm.x = xmin; ulm.y = ymin;
897 map_utils_iTMS_to_center_vikcoord ( &ulm, &coord );
898 vik_viewport_coord_to_screen ( vvp, &coord, &xx, &yy );
899 xx = xx - (vml->tile_size_x/2);
900 yy = yy - (vml->tile_size_x/2); // Yes use X ATM
901 for (gint x = xmin; x <= xmax; x++ ) {
902 vik_viewport_draw_line ( vvp, black_gc, xx, 0, xx, height );
903 xx += vml->tile_size_x;
905 for (gint y = ymin; y <= ymax; y++ ) {
906 vik_viewport_draw_line ( vvp, black_gc, 0, yy, width, yy );
907 yy += vml->tile_size_x; // Yes use X ATM
916 static void mapnik_layer_free ( VikMapnikLayer *vml )
918 mapnik_interface_free ( vml->mi );
919 if ( vml->filename_css )
920 g_free ( vml->filename_css );
921 if ( vml->filename_xml )
922 g_free ( vml->filename_xml );
925 static VikMapnikLayer *mapnik_layer_create ( VikViewport *vp )
927 return mapnik_layer_new ( vp );
936 typedef gpointer menu_array_values[MA_LAST];
941 static void mapnik_layer_flush_memory ( menu_array_values values )
943 a_mapcache_flush_type ( MAP_ID_MAPNIK_RENDER );
949 static void mapnik_layer_reload ( menu_array_values values )
951 VikMapnikLayer *vml = values[MA_VML];
952 VikViewport *vvp = values[MA_VVP];
953 mapnik_layer_post_read (VIK_LAYER(vml), vvp, FALSE);
954 mapnik_layer_draw ( vml, vvp );
960 * Most carto projects will consist of many files
961 * ATM don't have a way of detecting when any of the included files have changed
962 * Thus allow a manual method to force re-running carto
964 static void mapnik_layer_carto ( menu_array_values values )
966 VikMapnikLayer *vml = values[MA_VML];
967 VikViewport *vvp = values[MA_VVP];
969 // Don't load the XML config if carto load fails
970 if ( !carto_load ( vml, vvp ) )
973 gchar* ans = mapnik_interface_load_map_file ( vml->mi, vml->filename_xml, vml->tile_size_x, vml->tile_size_x );
975 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_WIDGET(vvp),
976 _("Mapnik error loading configuration file:\n%s"),
981 mapnik_layer_draw ( vml, vvp );
985 * Show Mapnik configuration parameters
987 static void mapnik_layer_information ( menu_array_values values )
989 VikMapnikLayer *vml = values[MA_VML];
992 GArray *array = mapnik_interface_get_parameters( vml->mi );
994 a_dialog_list ( VIK_GTK_WINDOW_FROM_LAYER(vml), _("Mapnik Information"), array, 1 );
995 // Free the copied strings
996 for ( int i = 0; i < array->len; i++ )
997 g_free ( g_array_index(array,gchar*,i) );
999 g_array_free ( array, FALSE );
1005 static void mapnik_layer_about ( menu_array_values values )
1007 VikMapnikLayer *vml = values[MA_VML];
1008 gchar *msg = mapnik_interface_about();
1009 a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(vml), msg );
1016 static void mapnik_layer_add_menu_items ( VikMapnikLayer *vml, GtkMenu *menu, gpointer vlp )
1018 static menu_array_values values;
1019 values[MA_VML] = vml;
1020 values[MA_VVP] = vik_layers_panel_get_viewport( VIK_LAYERS_PANEL(vlp) );
1022 GtkWidget *item = gtk_menu_item_new();
1023 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1024 gtk_widget_show ( item );
1026 // Typical users shouldn't need to use this functionality - so debug only ATM
1028 item = gtk_image_menu_item_new_with_mnemonic ( _("_Flush Memory Cache") );
1029 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
1030 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_flush_memory), values );
1031 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1032 gtk_widget_show ( item );
1035 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_REFRESH, NULL );
1036 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_reload), values );
1037 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1038 gtk_widget_show ( item );
1040 if ( g_strcmp0 ("", vml->filename_css) ) {
1041 item = gtk_image_menu_item_new_with_mnemonic ( _("_Run Carto Command") );
1042 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU) );
1043 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_carto), values );
1044 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1045 gtk_widget_show ( item );
1048 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_INFO, NULL );
1049 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_information), values );
1050 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1051 gtk_widget_show ( item );
1053 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_ABOUT, NULL );
1054 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_about), values );
1055 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1056 gtk_widget_show ( item );
1060 * Rerender a specific tile
1062 static void mapnik_layer_rerender ( VikMapnikLayer *vml )
1065 // Requested position to map coord
1066 map_utils_vikcoord_to_iTMS ( &vml->rerender_ul, vml->rerender_zoom, vml->rerender_zoom, &ulm );
1067 // Reconvert back - thus getting the coordinate at the tile *ul corner*
1068 map_utils_iTMS_to_vikcoord (&ulm, &vml->rerender_ul );
1069 // Bottom right bound is simply +1 in TMS coords
1073 map_utils_iTMS_to_vikcoord (&brm, &vml->rerender_br );
1074 thread_add (vml, &ulm, &vml->rerender_ul, &vml->rerender_br, ulm.x, ulm.y, ulm.z, ulm.scale, vml->filename_xml );
1080 static void mapnik_layer_tile_info ( VikMapnikLayer *vml )
1083 // Requested position to map coord
1084 map_utils_vikcoord_to_iTMS ( &vml->rerender_ul, vml->rerender_zoom, vml->rerender_zoom, &ulm );
1086 mapcache_extra_t extra = a_mapcache_get_extra ( ulm.x, ulm.y, ulm.z, MAP_ID_MAPNIK_RENDER, ulm.scale, vml->alpha, 0.0, 0.0, vml->filename_xml );
1088 gchar *filename = get_filename ( vml->file_cache_dir, ulm.x, ulm.y, ulm.scale );
1089 gchar *filemsg = NULL;
1090 gchar *timemsg = NULL;
1092 if ( g_file_test ( filename, G_FILE_TEST_EXISTS ) ) {
1093 filemsg = g_strconcat ( "Tile File: ", filename, NULL );
1094 // Get some timestamp information of the tile
1096 if ( g_stat ( filename, &stat_buf ) == 0 ) {
1098 strftime ( time_buf, sizeof(time_buf), "%c", gmtime((const time_t *)&stat_buf.st_mtime) );
1099 timemsg = g_strdup_printf ( _("Tile File Timestamp: %s"), time_buf );
1102 timemsg = g_strdup ( _("Tile File Timestamp: Not Available") );
1106 filemsg = g_strdup_printf ( "Tile File: %s [Not Available]", filename );
1107 timemsg = g_strdup("");
1110 GArray *array = g_array_new (FALSE, TRUE, sizeof(gchar*));
1111 g_array_append_val ( array, filemsg );
1112 g_array_append_val ( array, timemsg );
1114 gchar *rendmsg = NULL;
1116 if ( extra.duration > 0.0 ) {
1117 rendmsg = g_strdup_printf ( _("Rendering time %.2f seconds"), extra.duration );
1118 g_array_append_val ( array, rendmsg );
1121 a_dialog_list ( VIK_GTK_WINDOW_FROM_LAYER(vml), _("Tile Information"), array, 5 );
1122 g_array_free ( array, FALSE );
1127 g_free ( filename );
1130 static gboolean mapnik_feature_release ( VikMapnikLayer *vml, GdkEventButton *event, VikViewport *vvp )
1134 if ( event->button == 3 ) {
1135 vik_viewport_screen_to_coord ( vvp, MAX(0, event->x), MAX(0, event->y), &vml->rerender_ul );
1136 vml->rerender_zoom = vik_viewport_get_zoom ( vvp );
1138 if ( ! vml->right_click_menu ) {
1140 vml->right_click_menu = gtk_menu_new ();
1142 item = gtk_image_menu_item_new_with_mnemonic ( _("_Rerender Tile") );
1143 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
1144 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_rerender), vml );
1145 gtk_menu_shell_append ( GTK_MENU_SHELL(vml->right_click_menu), item );
1147 item = gtk_image_menu_item_new_with_mnemonic ( _("_Info") );
1148 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU) );
1149 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_tile_info), vml );
1150 gtk_menu_shell_append ( GTK_MENU_SHELL(vml->right_click_menu), item );
1153 gtk_menu_popup ( GTK_MENU(vml->right_click_menu), NULL, NULL, NULL, NULL, event->button, event->time );
1154 gtk_widget_show_all ( GTK_WIDGET(vml->right_click_menu) );