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 );
542 g_regex_unref ( regex );
544 if ( !g_file_set_contents (vml->filename_xml, mystdout, -1, &error) ) {
545 g_warning ("%s: %s", __FUNCTION__, error->message );
546 g_error_free (error);
553 g_warning ("%s: %s", __FUNCTION__, error->message );
554 g_error_free (error);
559 gchar *msg = g_strdup_printf ( "%s %s %.1f %s", vlpd->s, _(" completed in "), (gdouble)(tt2-tt1)/G_USEC_PER_SEC, _("seconds") );
560 vik_window_statusbar_update ( vw, msg, VIK_STATUSBAR_INFO );
562 vik_window_clear_busy_cursor ( vw );
570 static void mapnik_layer_post_read (VikLayer *vl, VikViewport *vvp, gboolean from_file)
572 VikMapnikLayer *vml = VIK_MAPNIK_LAYER(vl);
574 // Determine if carto needs to be run
575 gboolean do_carto = FALSE;
576 if ( vml->filename_css && strlen(vml->filename_css) > 1 ) {
577 if ( vml->filename_xml && strlen(vml->filename_xml) > 1) {
578 // Compare timestamps
580 if ( g_stat ( vml->filename_xml, &gsb1 ) == 0 ) {
582 if ( g_stat ( vml->filename_css, &gsb2 ) == 0 ) {
583 // Is CSS file newer than the XML file
584 if ( gsb2.st_mtime > gsb1.st_mtime )
587 g_debug ( "No need to run carto" );
591 // XML file doesn't exist
596 // No XML specified thus need to generate
602 // Don't load the XML config if carto load fails
603 if ( !carto_load ( vml, vvp ) )
606 gchar* ans = mapnik_interface_load_map_file ( vml->mi, vml->filename_xml, vml->tile_size_x, vml->tile_size_x );
608 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_WIDGET(vvp),
609 _("Mapnik error loading configuration file:\n%s"),
616 ui_add_recent_file ( vml->filename_xml );
620 #define MAPNIK_LAYER_FILE_CACHE_LAYOUT "%s"G_DIR_SEPARATOR_S"%d"G_DIR_SEPARATOR_S"%d"G_DIR_SEPARATOR_S"%d.png"
622 // Free returned string after use
623 static gchar *get_filename ( gchar *dir, guint x, guint y, guint z)
625 return g_strdup_printf ( MAPNIK_LAYER_FILE_CACHE_LAYOUT, dir, (17-z), x, y );
628 static void possibly_save_pixbuf ( VikMapnikLayer *vml, GdkPixbuf *pixbuf, MapCoord *ulm )
630 if ( vml->use_file_cache ) {
631 if ( vml->file_cache_dir ) {
632 GError *error = NULL;
633 gchar *filename = get_filename ( vml->file_cache_dir, ulm->x, ulm->y, ulm->scale );
635 gchar *dir = g_path_get_dirname ( filename );
636 if ( !g_file_test ( filename, G_FILE_TEST_EXISTS ) )
637 if ( g_mkdir_with_parents ( dir , 0777 ) != 0 )
638 g_warning ("%s: Failed to mkdir %s", __FUNCTION__, dir );
641 if ( !gdk_pixbuf_save (pixbuf, filename, "png", &error, NULL ) ) {
642 g_warning ("%s: %s", __FUNCTION__, error->message );
643 g_error_free (error);
656 const gchar* request;
662 * Common render function which can run in separate thread
664 static void render ( VikMapnikLayer *vml, VikCoord *ul, VikCoord *br, MapCoord *ulm )
666 gint64 tt1 = g_get_real_time ();
667 GdkPixbuf *pixbuf = mapnik_interface_render ( vml->mi, ul->north_south, ul->east_west, br->north_south, br->east_west );
668 gint64 tt2 = g_get_real_time ();
669 gdouble tt = (gdouble)(tt2-tt1)/1000000;
670 g_debug ( "Mapnik rendering completed in %.3f seconds", tt );
672 // A pixbuf to stick into cache incase of an unrenderable area - otherwise will get continually re-requested
673 pixbuf = gdk_pixbuf_scale_simple ( gdk_pixbuf_from_pixdata(&vikmapniklayer_pixbuf, FALSE, NULL), vml->tile_size_x, vml->tile_size_x, GDK_INTERP_BILINEAR );
675 possibly_save_pixbuf ( vml, pixbuf, ulm );
677 // NB Mapnik can apply alpha, but use our own function for now
678 if ( vml->alpha < 255 )
679 pixbuf = ui_pixbuf_scale_alpha ( pixbuf, vml->alpha );
680 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 );
681 g_object_unref(pixbuf);
684 static void render_info_free ( RenderInfo *data )
688 g_free ( data->ulmc );
689 // NB No need to free the request/key - as this is freed by the hash table destructor
693 static void background ( RenderInfo *data, gpointer threaddata )
695 int res = a_background_thread_progress ( threaddata, 0 );
697 render ( data->vml, data->ul, data->br, data->ulmc );
700 g_mutex_lock(tp_mutex);
701 g_hash_table_remove (requests, data->request);
702 g_mutex_unlock(tp_mutex);
705 vik_layer_emit_update ( VIK_LAYER(data->vml) ); // NB update display from background
708 static void render_cancel_cleanup (RenderInfo *data)
713 #define REQUEST_HASHKEY_FORMAT "%d-%d-%d-%d-%d"
718 static void thread_add (VikMapnikLayer *vml, MapCoord *mul, VikCoord *ul, VikCoord *br, gint x, gint y, gint z, gint zoom, const gchar* name )
721 guint nn = name ? g_str_hash ( name ) : 0;
722 gchar *request = g_strdup_printf ( REQUEST_HASHKEY_FORMAT, x, y, z, zoom, nn );
724 g_mutex_lock(tp_mutex);
726 if ( g_hash_table_lookup_extended (requests, request, NULL, NULL ) ) {
728 g_mutex_unlock (tp_mutex);
732 RenderInfo *ri = g_malloc ( sizeof(RenderInfo) );
734 ri->ul = g_malloc ( sizeof(VikCoord) );
735 ri->br = g_malloc ( sizeof(VikCoord) );
736 ri->ulmc = g_malloc ( sizeof(MapCoord) );
737 memcpy(ri->ul, ul, sizeof(VikCoord));
738 memcpy(ri->br, br, sizeof(VikCoord));
739 memcpy(ri->ulmc, mul, sizeof(MapCoord));
740 ri->request = request;
742 g_hash_table_insert ( requests, request, NULL );
744 g_mutex_unlock (tp_mutex);
746 gchar *basename = g_path_get_basename (name);
747 gchar *description = g_strdup_printf ( _("Mapnik Render %d:%d:%d %s"), zoom, x, y, basename );
749 a_background_thread ( BACKGROUND_POOL_LOCAL_MAPNIK,
750 VIK_GTK_WINDOW_FROM_LAYER(vml),
752 (vik_thr_func) background,
754 (vik_thr_free_func) render_info_free,
755 (vik_thr_free_func) render_cancel_cleanup,
757 g_free ( description );
763 * If function returns GdkPixbuf properly, reference counter to this
764 * buffer has to be decreased, when buffer is no longer needed.
766 static GdkPixbuf *load_pixbuf ( VikMapnikLayer *vml, MapCoord *ulm, MapCoord *brm, gboolean *rerender )
769 GdkPixbuf *pixbuf = NULL;
770 gchar *filename = get_filename ( vml->file_cache_dir, ulm->x, ulm->y, ulm->scale );
773 if ( g_stat ( filename, &gsb ) == 0 ) {
775 GError *error = NULL;
776 pixbuf = gdk_pixbuf_new_from_file ( filename, &error );
778 g_warning ("%s: %s", __FUNCTION__, error->message );
779 g_error_free ( error );
782 if ( vml->alpha < 255 )
783 pixbuf = ui_pixbuf_set_alpha ( pixbuf, vml->alpha );
784 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 );
786 // If file is too old mark for rerendering
787 if ( planet_import_time < gsb.st_mtime ) {
797 * Caller has to decrease reference counter of returned
798 * GdkPixbuf, when buffer is no longer needed.
800 static GdkPixbuf *get_pixbuf ( VikMapnikLayer *vml, MapCoord *ulm, MapCoord *brm )
802 VikCoord ul; VikCoord br;
803 GdkPixbuf *pixbuf = NULL;
805 map_utils_iTMS_to_vikcoord (ulm, &ul);
806 map_utils_iTMS_to_vikcoord (brm, &br);
808 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 );
811 gboolean rerender = FALSE;
812 if ( vml->use_file_cache && vml->file_cache_dir )
813 pixbuf = load_pixbuf ( vml, ulm, brm, &rerender );
814 if ( ! pixbuf || rerender ) {
816 thread_add (vml, ulm, &ul, &br, ulm->x, ulm->y, ulm->z, ulm->scale, vml->filename_xml );
818 // Run in the foreground
819 render ( vml, &ul, &br, ulm );
820 vik_layer_emit_update ( VIK_LAYER(vml) );
831 static void mapnik_layer_draw ( VikMapnikLayer *vml, VikViewport *vvp )
836 if ( vik_viewport_get_drawmode(vvp) != VIK_VIEWPORT_DRAWMODE_MERCATOR ) {
837 vik_statusbar_set_message ( vik_window_get_statusbar (VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vml))),
838 VIK_STATUSBAR_INFO, _("Mapnik Rendering must be in Mercator mode") );
843 gchar *copyright = mapnik_interface_get_copyright ( vml->mi );
845 vik_viewport_add_copyright ( vvp, copyright );
850 ul.mode = VIK_COORD_LATLON;
851 br.mode = VIK_COORD_LATLON;
852 vik_viewport_screen_to_coord ( vvp, 0, 0, &ul );
853 vik_viewport_screen_to_coord ( vvp, vik_viewport_get_width(vvp), vik_viewport_get_height(vvp), &br );
855 gdouble xzoom = vik_viewport_get_xmpp ( vvp );
856 gdouble yzoom = vik_viewport_get_ympp ( vvp );
860 if ( map_utils_vikcoord_to_iTMS ( &ul, xzoom, yzoom, &ulm ) &&
861 map_utils_vikcoord_to_iTMS ( &br, xzoom, yzoom, &brm ) ) {
862 // TODO: Understand if tilesize != 256 does this need to use shrinkfactors??
867 gint xmin = MIN(ulm.x, brm.x), xmax = MAX(ulm.x, brm.x);
868 gint ymin = MIN(ulm.y, brm.y), ymax = MAX(ulm.y, brm.y);
870 // Split rendering into a grid for the current viewport
871 // thus each individual 'tile' can then be stored in the map cache
872 for (gint x = xmin; x <= xmax; x++ ) {
873 for (gint y = ymin; y <= ymax; y++ ) {
879 pixbuf = get_pixbuf ( vml, &ulm, &brm );
882 map_utils_iTMS_to_vikcoord ( &ulm, &coord );
883 vik_viewport_coord_to_screen ( vvp, &coord, &xx, &yy );
884 vik_viewport_draw_pixbuf ( vvp, pixbuf, 0, 0, xx, yy, vml->tile_size_x, vml->tile_size_x );
885 g_object_unref(pixbuf);
890 // Done after so drawn on top
891 // Just a handy guide to tile blocks.
892 if ( vik_debug && vik_verbose ) {
893 GdkGC *black_gc = GTK_WIDGET(vvp)->style->black_gc;
894 gint width = vik_viewport_get_width(vvp);
895 gint height = vik_viewport_get_height(vvp);
897 ulm.x = xmin; ulm.y = ymin;
898 map_utils_iTMS_to_center_vikcoord ( &ulm, &coord );
899 vik_viewport_coord_to_screen ( vvp, &coord, &xx, &yy );
900 xx = xx - (vml->tile_size_x/2);
901 yy = yy - (vml->tile_size_x/2); // Yes use X ATM
902 for (gint x = xmin; x <= xmax; x++ ) {
903 vik_viewport_draw_line ( vvp, black_gc, xx, 0, xx, height );
904 xx += vml->tile_size_x;
906 for (gint y = ymin; y <= ymax; y++ ) {
907 vik_viewport_draw_line ( vvp, black_gc, 0, yy, width, yy );
908 yy += vml->tile_size_x; // Yes use X ATM
917 static void mapnik_layer_free ( VikMapnikLayer *vml )
919 mapnik_interface_free ( vml->mi );
920 if ( vml->filename_css )
921 g_free ( vml->filename_css );
922 if ( vml->filename_xml )
923 g_free ( vml->filename_xml );
926 static VikMapnikLayer *mapnik_layer_create ( VikViewport *vp )
928 return mapnik_layer_new ( vp );
937 typedef gpointer menu_array_values[MA_LAST];
942 static void mapnik_layer_flush_memory ( menu_array_values values )
944 a_mapcache_flush_type ( MAP_ID_MAPNIK_RENDER );
950 static void mapnik_layer_reload ( menu_array_values values )
952 VikMapnikLayer *vml = values[MA_VML];
953 VikViewport *vvp = values[MA_VVP];
954 mapnik_layer_post_read (VIK_LAYER(vml), vvp, FALSE);
955 mapnik_layer_draw ( vml, vvp );
961 * Most carto projects will consist of many files
962 * ATM don't have a way of detecting when any of the included files have changed
963 * Thus allow a manual method to force re-running carto
965 static void mapnik_layer_carto ( menu_array_values values )
967 VikMapnikLayer *vml = values[MA_VML];
968 VikViewport *vvp = values[MA_VVP];
970 // Don't load the XML config if carto load fails
971 if ( !carto_load ( vml, vvp ) )
974 gchar* ans = mapnik_interface_load_map_file ( vml->mi, vml->filename_xml, vml->tile_size_x, vml->tile_size_x );
976 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_WIDGET(vvp),
977 _("Mapnik error loading configuration file:\n%s"),
982 mapnik_layer_draw ( vml, vvp );
986 * Show Mapnik configuration parameters
988 static void mapnik_layer_information ( menu_array_values values )
990 VikMapnikLayer *vml = values[MA_VML];
993 GArray *array = mapnik_interface_get_parameters( vml->mi );
995 a_dialog_list ( VIK_GTK_WINDOW_FROM_LAYER(vml), _("Mapnik Information"), array, 1 );
996 // Free the copied strings
997 for ( int i = 0; i < array->len; i++ )
998 g_free ( g_array_index(array,gchar*,i) );
1000 g_array_free ( array, FALSE );
1006 static void mapnik_layer_about ( menu_array_values values )
1008 VikMapnikLayer *vml = values[MA_VML];
1009 gchar *msg = mapnik_interface_about();
1010 a_dialog_info_msg ( VIK_GTK_WINDOW_FROM_LAYER(vml), msg );
1017 static void mapnik_layer_add_menu_items ( VikMapnikLayer *vml, GtkMenu *menu, gpointer vlp )
1019 static menu_array_values values;
1020 values[MA_VML] = vml;
1021 values[MA_VVP] = vik_layers_panel_get_viewport( VIK_LAYERS_PANEL(vlp) );
1023 GtkWidget *item = gtk_menu_item_new();
1024 gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
1025 gtk_widget_show ( item );
1027 // Typical users shouldn't need to use this functionality - so debug only ATM
1029 item = gtk_image_menu_item_new_with_mnemonic ( _("_Flush Memory Cache") );
1030 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU) );
1031 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_flush_memory), values );
1032 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1033 gtk_widget_show ( item );
1036 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_REFRESH, NULL );
1037 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_reload), values );
1038 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1039 gtk_widget_show ( item );
1041 if ( g_strcmp0 ("", vml->filename_css) ) {
1042 item = gtk_image_menu_item_new_with_mnemonic ( _("_Run Carto Command") );
1043 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU) );
1044 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_carto), values );
1045 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1046 gtk_widget_show ( item );
1049 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_INFO, NULL );
1050 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_information), values );
1051 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1052 gtk_widget_show ( item );
1054 item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_ABOUT, NULL );
1055 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_about), values );
1056 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1057 gtk_widget_show ( item );
1061 * Rerender a specific tile
1063 static void mapnik_layer_rerender ( VikMapnikLayer *vml )
1066 // Requested position to map coord
1067 map_utils_vikcoord_to_iTMS ( &vml->rerender_ul, vml->rerender_zoom, vml->rerender_zoom, &ulm );
1068 // Reconvert back - thus getting the coordinate at the tile *ul corner*
1069 map_utils_iTMS_to_vikcoord (&ulm, &vml->rerender_ul );
1070 // Bottom right bound is simply +1 in TMS coords
1074 map_utils_iTMS_to_vikcoord (&brm, &vml->rerender_br );
1075 thread_add (vml, &ulm, &vml->rerender_ul, &vml->rerender_br, ulm.x, ulm.y, ulm.z, ulm.scale, vml->filename_xml );
1081 static void mapnik_layer_tile_info ( VikMapnikLayer *vml )
1084 // Requested position to map coord
1085 map_utils_vikcoord_to_iTMS ( &vml->rerender_ul, vml->rerender_zoom, vml->rerender_zoom, &ulm );
1087 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 );
1089 gchar *filename = get_filename ( vml->file_cache_dir, ulm.x, ulm.y, ulm.scale );
1090 gchar *filemsg = NULL;
1091 gchar *timemsg = NULL;
1093 if ( g_file_test ( filename, G_FILE_TEST_EXISTS ) ) {
1094 filemsg = g_strconcat ( "Tile File: ", filename, NULL );
1095 // Get some timestamp information of the tile
1097 if ( g_stat ( filename, &stat_buf ) == 0 ) {
1099 strftime ( time_buf, sizeof(time_buf), "%c", gmtime((const time_t *)&stat_buf.st_mtime) );
1100 timemsg = g_strdup_printf ( _("Tile File Timestamp: %s"), time_buf );
1103 timemsg = g_strdup ( _("Tile File Timestamp: Not Available") );
1107 filemsg = g_strdup_printf ( "Tile File: %s [Not Available]", filename );
1108 timemsg = g_strdup("");
1111 GArray *array = g_array_new (FALSE, TRUE, sizeof(gchar*));
1112 g_array_append_val ( array, filemsg );
1113 g_array_append_val ( array, timemsg );
1115 gchar *rendmsg = NULL;
1117 if ( extra.duration > 0.0 ) {
1118 rendmsg = g_strdup_printf ( _("Rendering time %.2f seconds"), extra.duration );
1119 g_array_append_val ( array, rendmsg );
1122 a_dialog_list ( VIK_GTK_WINDOW_FROM_LAYER(vml), _("Tile Information"), array, 5 );
1123 g_array_free ( array, FALSE );
1128 g_free ( filename );
1131 static gboolean mapnik_feature_release ( VikMapnikLayer *vml, GdkEventButton *event, VikViewport *vvp )
1135 if ( event->button == 3 ) {
1136 vik_viewport_screen_to_coord ( vvp, MAX(0, event->x), MAX(0, event->y), &vml->rerender_ul );
1137 vml->rerender_zoom = vik_viewport_get_zoom ( vvp );
1139 if ( ! vml->right_click_menu ) {
1141 vml->right_click_menu = gtk_menu_new ();
1143 item = gtk_image_menu_item_new_with_mnemonic ( _("_Rerender Tile") );
1144 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
1145 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_rerender), vml );
1146 gtk_menu_shell_append ( GTK_MENU_SHELL(vml->right_click_menu), item );
1148 item = gtk_image_menu_item_new_with_mnemonic ( _("_Info") );
1149 gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU) );
1150 g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(mapnik_layer_tile_info), vml );
1151 gtk_menu_shell_append ( GTK_MENU_SHELL(vml->right_click_menu), item );
1154 gtk_menu_popup ( GTK_MENU(vml->right_click_menu), NULL, NULL, NULL, NULL, event->button, event->time );
1155 gtk_widget_show_all ( GTK_WIDGET(vml->right_click_menu) );