GnuCash  5.6-150-g038405b370+
gnc-plugin-page-report.cpp
1 /* gnc-plugin-page-report.c
2  * Copyright (C) 2004 Joshua Sled <jsled@asynchronous.org>
3  * Copyright (C) 2005 David Hampton <hampton@employees.org>
4  *
5  * Originally from window-report.c:
6  * Copyright (C) 1997 Robin D. Clark
7  * Copyright (C) 1998 Linas Vepstas
8  * Copyright (C) 1999 Jeremy Collins ( gtk-xmhtml port )
9  * Copyright (C) 2000 Dave Peticolas
10  * Copyright (C) 2000 Bill Gribble
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License as
14  * published by the Free Software Foundation; either version 2 of
15  * the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, contact:
24  *
25  * Free Software Foundation Voice: +1-617-542-5942
26  * 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652
27  * Boston, MA 02110-1301, USA gnu@gnu.org
28  */
29 
39 #include <gtk/gtk.h>
40 #include <glib/gi18n.h>
41 #include <glib/gstdio.h>
42 #include <gnc-optiondb-impl.hpp>
43 #include <libguile.h>
44 
45 #include <config.h>
46 
47 #include <sys/stat.h>
48 #include <errno.h>
49 
50 #include <gnc-glib-utils.h>
51 #include "gfec.h"
52 #include "dialog-custom-report.h"
53 #include "dialog-utils.h"
54 #include "gnc-component-manager.h"
55 #include "gnc-engine.h"
56 #include "gnc-gnome-utils.h"
57 #include "gnc-guile-utils.h"
58 #include "gnc-html-history.h"
59 #include "gnc-html.h"
60 #include "gnc-html-factory.h"
61 #include "gnc-file.h"
62 #include "gnc-filepath-utils.h"
63 #include "gnc-gtk-utils.h"
64 #include "gnc-plugin.h"
65 #include "gnc-plugin-page-report.h"
67 #include "gnc-prefs.h"
68 #include "gnc-session.h"
69 #include "gnc-ui-util.h"
70 #include "gnc-ui.h"
71 #include "gnc-window.h"
72 #include "window-report.h"
73 #include "swig-runtime.h"
74 #include "guile-mappings.h"
75 #include "gnc-icons.h"
76 #include "print-session.h"
77 
78 #include <unordered_map>
79 #include <memory>
80 #include <gnc-report.h>
81 
82 /* NW: you can add GNC_MOD_REPORT to gnc-engine.h
83 or simply define it locally. Any unique string with
84 a gnucash- prefix will do. Then just set a log level
85 with qof_log_set_level().*/
86 static QofLogModule log_module = GNC_MOD_GUI;
87 
88 // A static GHashTable to record the usage count for each printer
89 // output name.
90 
91 static std::unordered_map<std::string,unsigned> static_report_printnames;
92 
93 // Property-id values.
94 enum
95 {
96  PROP_0,
97  PROP_REPORT_ID,
98 };
99 
101 {
103  int reportId;
104  gint component_manager_id;
105  GSimpleActionGroup* action_group;
110  size_t option_change_cb_id = 0;
111 
112  /* initial_report is special; it's the one that's saved and
113  * restored. The name_change_callback only gets called when
114  * the initial_report name is changed. */
115  SCM initial_report;
116  GncOptionDB * initial_odb;
117  size_t name_change_cb_id;
118 
119  /* keep a list of edited reports so that we can destroy them when
120  * the window is closed. */
121  SCM edited_reports;
122 
123  /* The page is in the process of reloading the html */
124  gboolean reloading;
125  gboolean loaded;
126 
128 // gnc_html *html;
129  GncHtml *html;
130  gboolean webkit2;
131 
133  GtkContainer *container;
135 
136 G_DEFINE_TYPE_WITH_PRIVATE(GncPluginPageReport, gnc_plugin_page_report, GNC_TYPE_PLUGIN_PAGE)
137 
138 #define GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(o) \
139  ((GncPluginPageReportPrivate*)gnc_plugin_page_report_get_instance_private((GncPluginPageReport*)o))
140 
141 static GObject *gnc_plugin_page_report_constructor(GType this_type, guint n_properties, GObjectConstructParam *properties);
142 static void gnc_plugin_page_report_finalize (GObject *object);
143 static void gnc_plugin_page_report_setup( GncPluginPage *ppage );
144 
145 static void gnc_plugin_page_report_constr_init(GncPluginPageReport *plugin_page, gint reportId);
146 
147 static GtkWidget* gnc_plugin_page_report_create_widget( GncPluginPage *plugin_page );
148 static void gnc_plugin_page_report_destroy_widget( GncPluginPage *plugin_page );
149 static void gnc_plugin_page_report_save_page (GncPluginPage *plugin_page, GKeyFile *file, const gchar *group);
150 static GncPluginPage *gnc_plugin_page_report_recreate_page (GtkWidget *window, GKeyFile *file, const gchar *group);
151 static void gnc_plugin_page_report_name_changed (GncPluginPage *page, const gchar *name);
152 static void gnc_plugin_page_report_update_edit_menu (GncPluginPage *page, gboolean hide);
153 static gboolean gnc_plugin_page_report_finish_pending (GncPluginPage *page);
154 static void gnc_plugin_page_report_load_uri (GncPluginPage *page);
155 
156 static int gnc_plugin_page_report_check_urltype(URLType t);
157 //static void gnc_plugin_page_report_load_cb(gnc_html * html, URLType type,
158 static void gnc_plugin_page_report_load_cb(GncHtml * html, URLType type,
159  const gchar * location, const gchar * label,
160  gpointer data);
161 static void gnc_plugin_page_report_refresh (gpointer data);
162 static void gnc_plugin_page_report_set_fwd_button(GncPluginPageReport * page, int enabled);
163 static void gnc_plugin_page_report_set_back_button(GncPluginPageReport * page, int enabled);
164 static void gnc_plugin_page_report_history_destroy_cb(gnc_html_history_node * node, gpointer user_data);
165 static void close_handler(gpointer user_data);
166 void gnc_plugin_page_report_destroy(GncPluginPageReportPrivate *priv);
167 static void gnc_plugin_page_report_option_change_cb(gpointer data);
168 
169 void gnc_plugin_page_report_remove_edited_report(GncPluginPageReportPrivate *priv, SCM report);
170 void gnc_plugin_page_report_add_edited_report(GncPluginPageReportPrivate *priv, SCM report);
171 static void gnc_plugin_page_report_menu_updates (GncPluginPage *plugin_page);
172 void gnc_plugin_page_report_raise_editor(SCM report);
173 
174 static void gnc_plugin_page_report_forw_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
175 static void gnc_plugin_page_report_back_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
176 static void gnc_plugin_page_report_reload_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
177 static void gnc_plugin_page_report_stop_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
178 static void gnc_plugin_page_report_save_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
179 static void gnc_plugin_page_report_save_as_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
180 static void gnc_plugin_page_report_export_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
181 static void gnc_plugin_page_report_options_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
182 static void gnc_plugin_page_report_print_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
183 static void gnc_plugin_page_report_exportpdf_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
184 static void gnc_plugin_page_report_copy_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
185 static void gnc_plugin_page_report_edit_tax_cb (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
186 
187 static GActionEntry report_actions[] =
188 {
189  { "FilePrintAction", gnc_plugin_page_report_print_cb, nullptr, nullptr, nullptr },
190  { "FilePrintPDFAction", gnc_plugin_page_report_exportpdf_cb, nullptr, nullptr, nullptr },
191  { "EditCopyAction", gnc_plugin_page_report_copy_cb, nullptr, nullptr, nullptr },
192  { "EditTaxOptionsAction", gnc_plugin_page_report_edit_tax_cb, nullptr, nullptr, nullptr },
193  { "ViewRefreshAction", gnc_plugin_page_report_reload_cb, nullptr, nullptr, nullptr },
194  { "ReportSaveAction", gnc_plugin_page_report_save_cb, nullptr, nullptr, nullptr },
195  { "ReportSaveAsAction", gnc_plugin_page_report_save_as_cb, nullptr, nullptr, nullptr },
196  { "ReportExportAction", gnc_plugin_page_report_export_cb, nullptr, nullptr, nullptr },
197  { "ReportOptionsAction", gnc_plugin_page_report_options_cb, nullptr, nullptr, nullptr },
198  { "ReportBackAction", gnc_plugin_page_report_back_cb, nullptr, nullptr, nullptr },
199  { "ReportForwAction", gnc_plugin_page_report_forw_cb, nullptr, nullptr, nullptr },
200  { "ReportReloadAction", gnc_plugin_page_report_reload_cb, nullptr, nullptr, nullptr },
201  { "ReportStopAction", gnc_plugin_page_report_stop_cb, nullptr, nullptr, nullptr },
202 };
203 static guint num_report_actions = G_N_ELEMENTS(report_actions);
204 static const gchar *initially_insensitive_actions[] =
205 {
206  nullptr
207 };
208 
209 static const gchar *disable_during_load_actions[] =
210 {
211  "FilePrintAction",
212  "FilePrintPDFAction",
213  "ReportOptionsAction",
214  nullptr
215 };
216 
218 static const gchar *gnc_plugin_load_ui_items [] =
219 {
220  "FilePlaceholder3",
221  "FilePlaceholder4",
222  "FilePlaceholder5",
223  "EditPlaceholder3",
224  "EditPlaceholder5",
225  "EditPlaceholder6",
226  "ViewPlaceholder4",
227  "ReportsPlaceholder1",
228  NULL,
229 };
230 
232 static GncToolBarShortNames toolbar_labels[] =
233 {
234  { "FilePrintAction", N_("Print") },
235  { "ReportExportAction", N_("Export") },
236  { "ReportOptionsAction", N_("Options") },
237  /* Translators: This string is meant to be a short alternative for "Save Report Configuration"
238  to be used as toolbar button label. */
239  { "ReportSaveAction", N_("Save Config") },
240  /* Translators: This string is meant to be a short alternative for "Save Report Configuration As…"
241  to be used as toolbar button label. */
242  { "ReportSaveAsAction", N_("Save Config As…") },
243  { "FilePrintPDFAction", N_("Make Pdf") },
244  { nullptr, nullptr },
245 };
246 
247 static void
248 gnc_plugin_page_report_get_property( GObject *obj,
249  guint prop_id,
250  GValue *value,
251  GParamSpec *pspec )
252 {
253  GncPluginPageReport *rep;
255 
256  rep = GNC_PLUGIN_PAGE_REPORT( obj );
257  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(rep);
258 
259  switch ( prop_id )
260  {
261  case PROP_REPORT_ID:
262  g_value_set_int( value, priv->reportId );
263  break;
264  default:
265  PERR( "Unknown property id %d", prop_id );
266  break;
267  }
268 }
269 
270 static void
271 gnc_plugin_page_report_set_property( GObject *obj,
272  guint prop_id,
273  const GValue *value,
274  GParamSpec *pspec )
275 {
276  GncPluginPageReport *rep;
278 
279  rep = GNC_PLUGIN_PAGE_REPORT( obj );
280  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(rep);
281 
282  DEBUG( "setting property with id %d / %p to value %d",
283  prop_id, priv, g_value_get_int( value ) );
284 
285  switch ( prop_id )
286  {
287  case PROP_REPORT_ID:
288  priv->reportId = g_value_get_int( value );
289  break;
290  default:
291  PERR( "unknown property id %d", prop_id );
292  break;
293  }
294 
295 }
296 
301 static gboolean
302 gnc_plugin_page_report_focus_widget (GncPluginPage *report_plugin_page)
303 {
304  if (GNC_IS_PLUGIN_PAGE_REPORT(report_plugin_page))
305  {
306  GncPluginPageReportPrivate *priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report_plugin_page);
307  GtkWidget *window;
308  GAction *action;
309 
310  if (!priv)
311  return FALSE;
312 
313  /* Disable the Transaction Menu */
314  action = gnc_main_window_find_action (GNC_MAIN_WINDOW(report_plugin_page->window), "TransactionAction");
315  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), FALSE);
316  /* Disable the Schedule menu */
317  action = gnc_main_window_find_action (GNC_MAIN_WINDOW(report_plugin_page->window), "ScheduledAction");
318  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), FALSE);
319 
320  gnc_main_window_update_menu_and_toolbar (GNC_MAIN_WINDOW(report_plugin_page->window),
321  report_plugin_page,
322  gnc_plugin_load_ui_items);
323 
324  // setup any short toolbar names
325  gnc_main_window_init_short_names (GNC_MAIN_WINDOW(report_plugin_page->window), toolbar_labels);
326 
327  gnc_plugin_page_report_menu_updates (report_plugin_page);
328 
329  window = gnc_plugin_page_get_window (report_plugin_page);
330 
331  if (window && !gnc_main_window_is_restoring_pages (GNC_MAIN_WINDOW(window)))
332  {
333  GtkWidget *widget = gnc_html_get_webview (priv->html);
334 
335  if (!priv->loaded) // so we only do the load once
336  gnc_plugin_page_report_load_uri (report_plugin_page);
337 
338  if (widget && GTK_IS_WIDGET(widget))
339  {
340  if (!gtk_widget_is_focus (GTK_WIDGET(widget)))
341  gtk_widget_grab_focus (GTK_WIDGET(widget));
342  }
343  }
344  }
345  return FALSE;
346 }
347 
348 static void
349 gnc_plugin_page_report_class_init (GncPluginPageReportClass *klass)
350 {
351  GObjectClass *object_class = G_OBJECT_CLASS (klass);
352  GncPluginPageClass *gnc_plugin_page_class = GNC_PLUGIN_PAGE_CLASS(klass);
353 
354  object_class->constructor = gnc_plugin_page_report_constructor;
355  object_class->finalize = gnc_plugin_page_report_finalize;
356 
357  object_class->set_property = gnc_plugin_page_report_set_property;
358  object_class->get_property = gnc_plugin_page_report_get_property;
359 
360  gnc_plugin_page_class->tab_icon = GNC_ICON_ACCOUNT_REPORT;
361  gnc_plugin_page_class->plugin_name = GNC_PLUGIN_PAGE_REPORT_NAME;
362 
363  gnc_plugin_page_class->create_widget = gnc_plugin_page_report_create_widget;
364  gnc_plugin_page_class->destroy_widget = gnc_plugin_page_report_destroy_widget;
365  gnc_plugin_page_class->save_page = gnc_plugin_page_report_save_page;
366  gnc_plugin_page_class->recreate_page = gnc_plugin_page_report_recreate_page;
367  gnc_plugin_page_class->page_name_changed = gnc_plugin_page_report_name_changed;
368  gnc_plugin_page_class->update_edit_menu_actions = gnc_plugin_page_report_update_edit_menu;
369  gnc_plugin_page_class->finish_pending = gnc_plugin_page_report_finish_pending;
370  gnc_plugin_page_class->focus_page_function = gnc_plugin_page_report_focus_widget;
371 
372  // create the "reportId" property
373  auto paramspec{static_cast<GParamFlags>(G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)};
374  g_object_class_install_property( object_class,
375  PROP_REPORT_ID,
376  g_param_spec_int( "report-id",
377  _("The numeric ID of the report."),
378  _("The numeric ID of the report."),
379  -1, G_MAXINT, -1,
380  paramspec));
381 }
382 
383 static void
384 gnc_plugin_page_report_finalize (GObject *object)
385 {
386  g_return_if_fail (GNC_IS_PLUGIN_PAGE_REPORT (object));
387 
388  ENTER("object %p", object);
389  G_OBJECT_CLASS (gnc_plugin_page_report_parent_class)->finalize (object);
390  LEAVE(" ");
391 }
392 
393 static void
394 gnc_plugin_page_report_set_progressbar (GncPluginPage *page, gboolean set)
395 {
396  GtkWidget *progressbar;
397  GtkAllocation allocation;
398 
399  progressbar = gnc_window_get_progressbar (GNC_WINDOW(page->window));
400  gtk_widget_get_allocation (GTK_WIDGET(progressbar), &allocation);
401 
402  // this sets the minimum size of the progressbar to that allocated
403  if (set)
404  gtk_widget_set_size_request (GTK_WIDGET(progressbar), -1, allocation.height);
405  else
406  gtk_widget_set_size_request (GTK_WIDGET(progressbar), -1, -1); //reset
407 }
408 
409 static void
410 gnc_plugin_page_report_load_uri (GncPluginPage *page)
411 {
412  GncPluginPageReport *report;
414  GncPluginPage *weak_page = page;
415  URLType type;
416  char * id_name;
417  char * child_name;
418  char * url_location = nullptr;
419  char * url_label = nullptr;
420 
421  report = GNC_PLUGIN_PAGE_REPORT(page);
422  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
423  if (!priv)
424  return; // No priv means the page doesn't exist anymore.
425 
426  DEBUG( "Load uri id=%d", priv->reportId );
427  id_name = g_strdup_printf("id=%d", priv->reportId );
428  child_name = gnc_build_url( URL_TYPE_REPORT, id_name, nullptr );
429  type = gnc_html_parse_url( priv->html, child_name, &url_location, &url_label);
430  DEBUG( "passing id_name=[%s] child_name=[%s] type=[%s], location=[%s], label=[%s]",
431  id_name, child_name ? child_name : "(null)",
432  type ? type : "(null)", url_location ? url_location : "(null)",
433  url_label ? url_label : "(null)" );
434 
435  g_free(id_name);
436  g_free(child_name);
437 
438  g_object_add_weak_pointer(G_OBJECT(page), (gpointer*)(&weak_page));
439  gtk_widget_show_all( GTK_WIDGET(priv->container) );
440 
441  priv->loaded = TRUE;
442 
443  // this sets the window for the progressbar
444  gnc_window_set_progressbar_window( GNC_WINDOW(page->window) );
445 
446  // this sets the minimum size of the progressbar to that allocated
447  gnc_plugin_page_report_set_progressbar( page, TRUE );
448 
449  gnc_html_show_url(priv->html, type, url_location, url_label, 0);
450  g_free(url_location);
451 
452  if (weak_page)
453  {
454  gnc_plugin_page_report_set_progressbar( page, FALSE );
455  g_object_remove_weak_pointer(G_OBJECT(page), (gpointer*)(&weak_page));
456  }
457 
458  gnc_plugin_set_actions_enabled(G_ACTION_MAP(priv->action_group),
459  disable_during_load_actions, TRUE);
460  // this resets the window for the progressbar to nullptr
461  gnc_window_set_progressbar_window( nullptr );
462 }
463 
464 /* used to capture Ctrl+Alt+PgUp/Down for tab selection */
465 static gboolean
466 webkit_key_press_event_cb (GtkWidget *widget, GdkEventKey *event, gpointer user_data)
467 {
468  GncPluginPageReport *report = GNC_PLUGIN_PAGE_REPORT(user_data);
469  GncPluginPageReportPrivate *priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
470  GdkModifierType modifiers = gtk_accelerator_get_default_mod_mask ();
471  GtkWidget *window = gnc_plugin_page_get_window (GNC_PLUGIN_PAGE(report));
472 
473  if (GNC_PLUGIN_PAGE(report) != gnc_main_window_get_current_page (GNC_MAIN_WINDOW(window)))
474  return FALSE;
475 
476  if ((event->keyval == GDK_KEY_Page_Up || event->keyval == GDK_KEY_Page_Down ||
477  event->keyval == GDK_KEY_KP_Page_Up || event->keyval == GDK_KEY_KP_Page_Down)
478  && (event->state & modifiers) == (GDK_CONTROL_MASK | GDK_MOD1_MASK))
479  {
480  GtkNotebook *notebook = GTK_NOTEBOOK(gtk_widget_get_parent (GTK_WIDGET(priv->container)));
481  gint pages = gtk_notebook_get_n_pages (notebook);
482  gint current_page = gtk_notebook_get_current_page (notebook);
483 
484  if (event->keyval == GDK_KEY_Page_Up || event->keyval == GDK_KEY_KP_Page_Up)
485  {
486  if (current_page == 0)
487  gtk_notebook_set_current_page (notebook, pages - 1);
488  else
489  gtk_notebook_prev_page (notebook);
490  }
491  else
492  {
493  if (pages == current_page + 1)
494  gtk_notebook_set_current_page (notebook, 0);
495  else
496  gtk_notebook_next_page (notebook);
497  }
498  return TRUE;
499  }
500  return FALSE;
501 }
502 
503 static
504 GtkWidget*
505 gnc_plugin_page_report_create_widget( GncPluginPage *page )
506 {
507  GncPluginPageReport *report;
509  GtkWindow *topLvl;
510  GtkWidget *webview;
511  URLType type;
512  char * id_name;
513  char * child_name;
514  char * url_location = nullptr;
515  char * url_label = nullptr;
516 
517  ENTER("page %p", page);
518 
519  report = GNC_PLUGIN_PAGE_REPORT(page);
520  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
521 
522 #ifndef WEBKIT1
523  /* Hide the ExportPdf action for Webkit2 */
524  priv->webkit2 = TRUE;
525 #endif
526 
527  topLvl = gnc_ui_get_main_window (nullptr);
528 // priv->html = gnc_html_new( topLvl );
529  priv->html = gnc_html_factory_create_html();
530  gnc_html_set_parent( priv->html, topLvl );
531  priv->loaded = FALSE;
532 
533  gnc_html_history_set_node_destroy_cb(gnc_html_get_history(priv->html),
534  gnc_plugin_page_report_history_destroy_cb,
535  (gpointer)priv);
536 
537  priv->container = GTK_CONTAINER(gtk_frame_new(nullptr));
538  gtk_frame_set_shadow_type(GTK_FRAME(priv->container), GTK_SHADOW_NONE);
539 
540  // Set the name for this widget so it can be easily manipulated with css
541  gtk_widget_set_name (GTK_WIDGET(priv->container), "gnc-id-report-page");
542 
543  gtk_container_add(GTK_CONTAINER(priv->container),
544  gnc_html_get_widget(priv->html));
545 
546  priv->component_manager_id =
547  gnc_register_gui_component(WINDOW_REPORT_CM_CLASS, nullptr,
548  close_handler, page);
549  gnc_gui_component_set_session(priv->component_manager_id,
550  gnc_get_current_session());
551 
552  gnc_html_set_urltype_cb(priv->html, gnc_plugin_page_report_check_urltype);
553  gnc_html_set_load_cb(priv->html, gnc_plugin_page_report_load_cb, report);
554 
555  /* We need to call the load call back so the report appears to have been run
556  so it will get saved properly if the report is not realized in session */
557  id_name = g_strdup_printf("id=%d", priv->reportId );
558  child_name = gnc_build_url( URL_TYPE_REPORT, id_name, nullptr );
559  type = gnc_html_parse_url( priv->html, child_name, &url_location, &url_label);
560 
561  gnc_plugin_page_report_load_cb (priv->html, type, id_name, url_label, report);
562  g_free(id_name);
563  g_free(child_name);
564  g_free (url_label);
565  g_free (url_location);
566 
567  // FIXME. This is f^-1(f(x)), isn't it?
568  DEBUG( "id=%d", priv->reportId );
569 
570  g_signal_connect (G_OBJECT(page), "inserted",
571  G_CALLBACK(gnc_plugin_page_inserted_cb),
572  nullptr);
573 
574  // used to capture Ctrl+Alt+PgUp/Down for tab selection
575  webview = gnc_html_get_webview (priv->html);
576  if (webview)
577  {
578  gtk_widget_add_events (webview, gtk_widget_get_events (webview) |
579  GDK_KEY_PRESS_MASK);
580 
581  g_signal_connect (webview, "key-press-event",
582  G_CALLBACK(webkit_key_press_event_cb),
583  page);
584  }
585 
586  gtk_widget_show_all( GTK_WIDGET(priv->container) );
587  LEAVE("container %p", priv->container);
588  return GTK_WIDGET( priv->container );
589 }
590 
591 /********************************************************************
592  * gnc_plugin_page_report_check_urltype
593  * is it OK to show a certain URLType in this window?
594  ********************************************************************/
595 static int
596 gnc_plugin_page_report_check_urltype(URLType t)
597 {
598  if (!g_strcmp0 (t, URL_TYPE_REPORT))
599  {
600  return TRUE;
601  }
602  else
603  {
604  return FALSE;
605  }
606 }
607 
612 static void
613 gnc_plugin_page_report_setup( GncPluginPage *ppage )
614 {
615  GncPluginPageReport *report = GNC_PLUGIN_PAGE_REPORT(ppage);
617  SCM set_needs_save = scm_c_eval_string("gnc:report-set-needs-save?!");
618  SCM inst_report;
619  int report_id;
620 
621  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
622  priv->cur_report = SCM_BOOL_F;
623  priv->initial_report = SCM_BOOL_F;
624  priv->edited_reports = SCM_EOL;
625  priv->name_change_cb_id = 0;
626 
627  g_object_get( ppage, "report-id", &report_id, nullptr );
628 
629  PINFO("report-id: %d\n", report_id);
630 
631  /* get the inst-report from the Scheme-side hash, and get its
632  * options and editor thunk */
633  if ((inst_report = gnc_report_find(report_id)) == SCM_BOOL_F)
634  {
635  return;
636  }
637 
638  if (priv->initial_report == SCM_BOOL_F)
639  {
640  priv->initial_report = inst_report;
641  scm_gc_protect_object(priv->initial_report);
642  }
643 
644  // all reports need [to be] saved immediately after they're created.
645  PINFO("set needs save");
646  scm_call_2(set_needs_save, inst_report, SCM_BOOL_T);
647 }
648 
649 /********************************************************************
650  * gnc_plugin_page_report_load_cb
651  * called after a report is loaded into the gnc_html widget
652  ********************************************************************/
653 static void
654 gnc_plugin_page_report_load_cb (GncHtml * html, URLType type,
655  const gchar * location, const gchar * label,
656  gpointer data)
657 {
658  GncPluginPageReport *report = GNC_PLUGIN_PAGE_REPORT(data);
660  int report_id;
661  SCM set_needs_save = scm_c_eval_string("gnc:report-set-needs-save?!");
662  SCM inst_report;
663 
664  ENTER( "load_cb: type=[%s], location=[%s], label=[%s]",
665  type ? type : "(null)", location ? location : "(null)",
666  label ? label : "(null)" );
667 
668  /* we get this callback if a new report is requested to be loaded OR
669  * if any URL is clicked. If an options URL is clicked, we want to
670  * know about it */
671  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
672  if (!g_strcmp0 (type, URL_TYPE_REPORT)
673  && location
674  && (strlen(location) > 3)
675  && !strncmp("id=", location, 3))
676  {
677  report_id = atoi(location + 3);
678  DEBUG( "parsed id=%d", report_id );
679  }
680  else if (!g_strcmp0( type, URL_TYPE_OPTIONS)
681  && location
682  && (strlen(location) > 10)
683  && !strncmp("report-id=", location, 10))
684  {
685  report_id = atoi(location + 10);
686  inst_report = gnc_report_find(report_id);
687  if (inst_report != SCM_BOOL_F)
688  {
689  gnc_plugin_page_report_add_edited_report(priv, inst_report);
690  }
691  LEAVE("");
692  return;
693  }
694  else
695  {
696  LEAVE( " unknown URL type [%s] location [%s]", type, location );
697  return;
698  }
699 
700  /* get the inst-report from the hash, and get its
701  * options and editor thunk */
702  if ((inst_report = gnc_report_find(report_id)) == SCM_BOOL_F)
703  {
704  LEAVE( "error getting inst_report" );
705  return;
706  }
707 
708  if (priv->initial_report == SCM_BOOL_F)
709  {
710  priv->initial_report = inst_report;
711  scm_gc_protect_object(priv->initial_report);
712 
713  DEBUG("calling set_needs_save for report with id=%d", report_id);
714  scm_call_2(set_needs_save, inst_report, SCM_BOOL_T);
715 
716  priv->initial_odb = gnc_get_report_optiondb(inst_report);
717 
718  priv->name_change_cb_id =
719  priv->initial_odb->register_callback(
720  gnc_plugin_page_report_refresh, priv);
721 
722  }
723 
724  if ((priv->cur_report != SCM_BOOL_F) && (priv->cur_odb != nullptr))
725  {
726  priv->cur_odb->unregister_callback(priv->option_change_cb_id);
727  priv->option_change_cb_id = 0;
728  priv->cur_odb = nullptr;
729  }
730 
731  if (priv->cur_report != SCM_BOOL_F)
732  scm_gc_unprotect_object(priv->cur_report);
733  priv->cur_report = inst_report;
734  scm_gc_protect_object(priv->cur_report);
735 
736  priv->cur_odb = gnc_get_report_optiondb(inst_report);
737 
738  priv->option_change_cb_id =
739  priv->cur_odb->register_callback(
740  gnc_plugin_page_report_option_change_cb, report);
741 
742  if (gnc_html_history_forward_p(gnc_html_get_history(priv->html)))
743  {
744  gnc_plugin_page_report_set_fwd_button(report, TRUE);
745  }
746  else
747  {
748  gnc_plugin_page_report_set_fwd_button(report, FALSE);
749  }
750 
751  if (gnc_html_history_back_p(gnc_html_get_history(priv->html)))
752  {
753  gnc_plugin_page_report_set_back_button(report, TRUE);
754  }
755  else
756  {
757  gnc_plugin_page_report_set_back_button(report, FALSE);
758  }
759 
760  LEAVE( "done" );
761 }
762 
763 
775 static void
776 gnc_plugin_page_report_option_change_cb(gpointer data)
777 {
778  GncPluginPage *page;
779  GncPluginPageReport *report;
781  SCM dirty_report = scm_c_eval_string("gnc:report-set-dirty?!");
782 
783  g_return_if_fail(GNC_IS_PLUGIN_PAGE_REPORT(data));
784  report = GNC_PLUGIN_PAGE_REPORT(data);
785  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
786  page = GNC_PLUGIN_PAGE(report);
787 
788  DEBUG( "option_change" );
789  if (priv->cur_report == SCM_BOOL_F)
790  return;
791  DEBUG( "set-dirty, queue-draw" );
792 
793  /* Update the page (i.e. the notebook tab and window title) */
794  std::string old_name{gnc_plugin_page_get_page_name(GNC_PLUGIN_PAGE(report))};
795  auto new_name{priv->cur_odb->lookup_string_option("General",
796  "Report name")};
797  if (new_name != old_name)
798  {
799  /* Bug 727130, 760711 - remove only the non-printable
800  * characters from the new name */
801  char *clean_name{g_strdup(new_name.c_str())};
803  ENTER("Cleaned-up new report name: %s", clean_name ? clean_name : "(null)");
804  main_window_update_page_name(GNC_PLUGIN_PAGE(report), clean_name);
805  g_free(clean_name);
806  }
807 
808  /* it's probably already dirty, but make sure */
809  scm_call_2(dirty_report, priv->cur_report, SCM_BOOL_T);
810 
811  gnc_plugin_set_actions_enabled(G_ACTION_MAP(priv->action_group),
812  disable_during_load_actions, FALSE);
813  // prevent closing this page while loading...
814  priv->reloading = TRUE;
815 
816  // this sets the window for the progressbar
817  gnc_window_set_progressbar_window( GNC_WINDOW(page->window) );
818 
819  // this sets the minimum size of the progressbar to that allocated
820  gnc_plugin_page_report_set_progressbar( page, TRUE );
821 
822  /* Now queue the fact that we need to reload this report */
823  gnc_html_reload( priv->html, TRUE ); //reload by rebuild
824 
825  gnc_plugin_page_report_set_progressbar( page, FALSE );
826 
827  // this resets the window for the progressbar to nullptr
828  gnc_window_set_progressbar_window( nullptr );
829 
830  gnc_plugin_set_actions_enabled(G_ACTION_MAP(priv->action_group),
831  disable_during_load_actions, TRUE);
832  priv->reloading = FALSE;
833 }
834 
835 /* FIXME: This function does... nothing? */
836 static void
837 gnc_plugin_page_report_history_destroy_cb(gnc_html_history_node * node,
838  gpointer user_data)
839 {
840 #if 0
841  static SCM remover = SCM_BOOL_F;
842  int report_id;
843 
844  if (remover == SCM_BOOL_F)
845  {
846  remover = scm_c_eval_string("gnc:report-remove-by-id");
847  }
848 
849  if (node
850  && !g_strcmp0 (node->type, URL_TYPE_REPORT)\
851  && !strncmp("id=", node->location, 3))
852  {
853  sscanf(node->location + 3, "%d", &report_id);
854  /* printf("unreffing report %d and children\n", report_id);
855  scm_call_1(remover, scm_from_int (report_id)); */
856  }
857  else
858  {
859  return;
860  }
861 #endif
862 }
863 
864 // @param data is actually GncPluginPageReportPrivate
865 static void
866 gnc_plugin_page_report_refresh(gpointer data)
867 {
868  // FIXME?
869  DEBUG( "report-refresh called" );
870  // something like ... gnc_plugin_page_report_redraw( nullptr, (GncPluginPageReportPrivate*)data );
871  return;
872 }
873 
874 static void
875 gnc_plugin_page_report_destroy_widget(GncPluginPage *plugin_page)
876 {
878 
879  // FIXME: cleanup other resources.
880 
881  PINFO("destroy widget");
882  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(plugin_page);
883 
884  // Remove the page_changed signal callback
885  gnc_plugin_page_disconnect_page_changed (GNC_PLUGIN_PAGE(plugin_page));
886 
887  // Remove the page focus idle function if present
888  g_idle_remove_by_data (plugin_page);
889 
890  if (priv->component_manager_id)
891  {
892  gnc_unregister_gui_component(priv->component_manager_id);
893  priv->component_manager_id = 0;
894  }
895 
896  gnc_plugin_page_report_destroy(priv);
897  gnc_report_remove_by_id(priv->reportId);
898 }
899 
900 
903 #define SCHEME_OPTIONS "SchemeOptions"
904 #define SCHEME_OPTIONS_N "SchemeOptions%d"
905 
906 
916 static void
917 gnc_plugin_page_report_save_page (GncPluginPage *plugin_page,
918  GKeyFile *key_file,
919  const gchar *group_name)
920 {
921  GncPluginPageReport *report;
923  SCM gen_save_text, scm_text;
924  SCM get_embedded_list, embedded, item, tmp_report;
925  SCM get_options;
926  gint count, id;
927  gchar *text, *key_name;
928 
929  g_return_if_fail (GNC_IS_PLUGIN_PAGE_REPORT(plugin_page));
930  g_return_if_fail (key_file != nullptr);
931  g_return_if_fail (group_name != nullptr);
932 
933  ENTER("page %p, key_file %p, group_name %s", plugin_page, key_file,
934  group_name);
935 
936  report = GNC_PLUGIN_PAGE_REPORT(plugin_page);
937  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
938 
939  if (!priv || !priv->cur_report || scm_is_null(priv->cur_report) ||
940  SCM_UNBNDP(priv->cur_report) || SCM_BOOL_F == priv->cur_report)
941  {
942  LEAVE("not saving invalid report");
943  return;
944  }
945 
946  gen_save_text = scm_c_eval_string("gnc:report-serialize");
947  get_embedded_list = scm_c_eval_string("gnc:report-embedded-list");
948  get_options = scm_c_eval_string("gnc:report-options");
949  embedded = scm_call_1(get_embedded_list, scm_call_1(get_options, priv->cur_report));
950  count = scm_ilength(embedded);
951  while (count-- > 0)
952  {
953  item = SCM_CAR(embedded);
954  embedded = SCM_CDR(embedded);
955  if (!scm_is_number(item))
956  continue;
957  id = scm_to_int (item);
958  tmp_report = gnc_report_find(id);
959  scm_text = scm_call_1(gen_save_text, tmp_report);
960  if (!scm_is_string (scm_text))
961  {
962  DEBUG("child report %d: nothing to save", id);
963  continue;
964  }
965 
966  key_name = g_strdup_printf(SCHEME_OPTIONS_N, id);
967  text = gnc_scm_strip_comments(scm_text);
968  g_key_file_set_value(key_file, group_name, key_name, text);
969  g_free(text);
970  g_free(key_name);
971  }
972 
973  scm_text = scm_call_1(gen_save_text, priv->cur_report);
974  if (!scm_is_string (scm_text))
975  {
976  LEAVE("nothing to save");
977  return;
978  }
979 
980  text = gnc_scm_strip_comments(scm_text);
981  g_key_file_set_value(key_file, group_name, SCHEME_OPTIONS, text);
982  g_free(text);
983  LEAVE(" ");
984 }
985 
986 
996 static GncPluginPage *
997 gnc_plugin_page_report_recreate_page (GtkWidget *window,
998  GKeyFile *key_file,
999  const gchar *group_name)
1000 {
1001  GncPluginPage *page;
1002  gchar **keys;
1003  gsize i, num_keys;
1004  GError *error = nullptr;
1005  gchar *option_string;
1006  gint report_id;
1007  SCM scm_id, final_id = SCM_BOOL_F;
1008  SCM report;
1009 
1010  g_return_val_if_fail(key_file, nullptr);
1011  g_return_val_if_fail(group_name, nullptr);
1012  ENTER("key_file %p, group_name %s", key_file, group_name);
1013 
1014  keys = g_key_file_get_keys(key_file, group_name, &num_keys, &error);
1015  if (error)
1016  {
1017  g_warning("error reading group %s key list: %s",
1018  group_name, error->message);
1019  g_error_free(error);
1020  LEAVE("no keys");
1021  return nullptr;
1022  }
1023 
1024  for (i = 0; i < num_keys; i++)
1025  {
1026  if (strncmp(keys[i], SCHEME_OPTIONS, strlen(SCHEME_OPTIONS)) != 0)
1027  continue;
1028  option_string = g_key_file_get_value(key_file, group_name,
1029  keys[i], &error);
1030  if (error)
1031  {
1032  g_warning("error reading group %s key %s: %s",
1033  group_name, keys[i], error->message);
1034  g_error_free(error);
1035  g_strfreev (keys);
1036  LEAVE("bad value");
1037  return nullptr;
1038  }
1039  scm_id = scm_eval_string(scm_from_utf8_string(option_string));
1040  g_free(option_string);
1041 
1042  if (!scm_integer_p(scm_id))
1043  {
1044  DEBUG("report id not an integer for key %s", keys[i]);
1045  g_strfreev (keys);
1046  return nullptr;
1047  }
1048 
1049  if (final_id == SCM_BOOL_F)
1050  {
1051  if (g_strcmp0(keys[i], SCHEME_OPTIONS) == 0)
1052  {
1053  final_id = scm_id;
1054  }
1055  }
1056  }
1057  g_strfreev (keys);
1058 
1059  if (final_id == SCM_BOOL_F)
1060  {
1061  LEAVE("report not specified");
1062  return nullptr;
1063  }
1064 
1065  report_id = scm_to_int(final_id);
1066  report = gnc_report_find(report_id);
1067  if (!report)
1068  {
1069  LEAVE("report doesn't exist");
1070  return nullptr;
1071  }
1072 
1073  page = gnc_plugin_page_report_new( report_id );
1074 
1075  LEAVE(" ");
1076  return page;
1077 }
1078 
1079 
1090 static void
1091 gnc_plugin_page_report_name_changed (GncPluginPage *page, const gchar *name)
1092 {
1094 
1095  g_return_if_fail(GNC_IS_PLUGIN_PAGE_REPORT(page));
1096  g_return_if_fail(name != nullptr);
1097 
1098  ENTER("page %p, name %s", page, name);
1099  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(page);
1100 
1101  if (priv->cur_odb)
1102  {
1103 
1104  /* Is this a redundant call? */
1105  auto old_name = priv->cur_odb->lookup_string_option("General",
1106  "Report name");
1107  std::string name_str{name};
1108  DEBUG("Comparing old name '%s' to new name '%s'",
1109  old_name.empty() ? "(null)" : old_name.c_str(), name);
1110  if (old_name == name_str)
1111  {
1112  LEAVE("no change");
1113  return;
1114  }
1115 
1116  /* Store the new name for the report. */
1117  priv->cur_odb->set_string_option("General", "Report name", name_str);
1118 
1119  }
1120 
1121  /* Have to manually call the option change hook. */
1122  gnc_plugin_page_report_option_change_cb(page);
1123  LEAVE(" ");
1124 }
1125 
1126 static void
1127 gnc_plugin_page_report_update_edit_menu (GncPluginPage *page, gboolean hide)
1128 {
1129  GncMainWindow *window = (GncMainWindow*)gnc_plugin_page_get_window (GNC_PLUGIN_PAGE(page));
1130  GAction *action;
1131 
1132  action = gnc_main_window_find_action (window, "EditCopyAction");
1133  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), TRUE);
1134  action = gnc_main_window_find_action (window, "EditCutAction");
1135  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), FALSE);
1136  action = gnc_main_window_find_action (window, "EditPasteAction");
1137  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), FALSE);
1138 }
1139 
1140 static gboolean
1141 gnc_plugin_page_report_finish_pending (GncPluginPage *page)
1142 {
1144  GncPluginPageReport *report;
1145 
1146  report = GNC_PLUGIN_PAGE_REPORT(page);
1147  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1148  return !priv->reloading;
1149 }
1150 
1151 
1152 /********************************************************************
1153  * gnc_report_window_destroy
1154  * free and destroy a window
1155  ********************************************************************/
1156 void
1157 gnc_plugin_page_report_destroy(GncPluginPageReportPrivate * priv)
1158 {
1159  SCM get_editor = scm_c_eval_string("gnc:report-editor-widget");
1160  SCM set_editor = scm_c_eval_string("gnc:report-set-editor-widget!");
1161  SCM edited, editor;
1162 
1163  /* close any open editors */
1164  for (edited = scm_list_copy(priv->edited_reports); !scm_is_null(edited);
1165  edited = SCM_CDR(edited))
1166  {
1167  editor = scm_call_1(get_editor, SCM_CAR(edited));
1168  scm_call_2(set_editor, SCM_CAR(edited), SCM_BOOL_F);
1169  if (editor != SCM_BOOL_F)
1170  {
1171 #define FUNC_NAME "gtk_widget_destroy"
1172  auto w{static_cast<GtkWidget*>(SWIG_MustGetPtr(editor, SWIG_TypeQuery("_p_GtkWidget"), 1, 0))};
1173 #undef FUNC_NAME
1174  gtk_widget_destroy(GTK_WIDGET(w));
1175  }
1176  }
1177 
1178  if (priv->initial_odb)
1179  {
1180 //Remove this if there's a double-free
1181  gnc_option_db_destroy(priv->initial_odb);
1182  priv->initial_odb = nullptr;
1183  }
1184 
1185  gnc_html_destroy(priv->html);
1186 
1187  priv->container = nullptr;
1188  priv->html = nullptr;
1189 
1190  if (priv->cur_report != SCM_BOOL_F)
1191  scm_gc_unprotect_object(priv->cur_report);
1192  if (priv->edited_reports != SCM_EOL)
1193  scm_gc_unprotect_object(priv->edited_reports);
1194 }
1195 
1196 static void
1197 gnc_plugin_page_report_init ( GncPluginPageReport *plugin_page )
1198 {
1199  GncPluginPageReportPrivate *priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(plugin_page);
1200  priv->action_group = NULL;
1201 }
1202 
1203 static GObject*
1204 gnc_plugin_page_report_constructor(GType this_type, guint n_properties, GObjectConstructParam *properties)
1205 {
1206  GObject *obj = G_OBJECT_CLASS (gnc_plugin_page_report_parent_class)->constructor(this_type, n_properties, properties);
1207 
1208  gint reportId = -42;
1209  for (decltype(n_properties) i = 0; i < n_properties; i++)
1210  {
1211  GObjectConstructParam prop = properties[i];
1212  if (strcmp(prop.pspec->name, "report-id") == 0)
1213  {
1214  reportId = g_value_get_int(prop.value);
1215  }
1216  }
1217 
1218  gnc_plugin_page_report_constr_init(GNC_PLUGIN_PAGE_REPORT(obj), reportId);
1219 
1220  return obj;
1221 }
1222 
1223 static void
1224 gnc_plugin_page_report_menu_update (GncPluginPage *plugin_page,
1225  action_toolbar_labels *tooltip_list)
1226 {
1227  GncMainWindow *window = GNC_MAIN_WINDOW(GNC_PLUGIN_PAGE(plugin_page)->window);
1228  GtkWidget *tool_item;
1229 
1230  for (gint i = 0; (tooltip_list[i].action_name != nullptr); i++)
1231  {
1233  tooltip_list[i].action_name,
1234  _(tooltip_list[i].label),
1235  _(tooltip_list[i].tooltip));
1236 
1237  tool_item = gnc_main_window_toolbar_find_tool_item (window,
1238  tooltip_list[i].action_name);
1239  if (tool_item)
1240  { // only need to update the tooltip here
1241  gtk_widget_set_tooltip_text (GTK_WIDGET(tool_item), _(tooltip_list[i].tooltip));
1242  g_object_set (G_OBJECT(tool_item), "has-tooltip", false, nullptr);
1243  }
1244  }
1245  // need to add the accelerator keys for the updated menu items
1247 }
1248 
1249 static void
1250 gnc_plugin_page_report_menu_updates (GncPluginPage *plugin_page)
1251 {
1253  GncPluginPageReport *report;
1254  GncMainWindow *window;
1255  action_toolbar_labels tooltip_list[3];
1256  GAction *action;
1257 
1258  gchar *saved_reports_path = gnc_build_userdata_path (SAVED_REPORTS_FILE);
1259  gchar *report_save_str = g_strdup_printf (
1260  _("Update the current report's saved configuration. "
1261  "The report configuration will be saved in the file %s."), saved_reports_path);
1262  gchar *report_saveas_str = g_strdup_printf (
1263  _("Add the current report's configuration to the 'Reports->Saved Report Configurations' menu. "
1264  "The report configuration will be saved in the file %s."), saved_reports_path);
1265 
1266  report = GNC_PLUGIN_PAGE_REPORT(plugin_page);
1267  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1268 
1269  window = (GncMainWindow*)gnc_plugin_page_get_window (GNC_PLUGIN_PAGE(plugin_page));
1270 
1271  tooltip_list[0] = { "ReportSaveAction", N_("Save _Report Configuration"), report_save_str };
1272  tooltip_list[1] = { "ReportSaveAsAction", N_("Save Report Configuration As…"), report_saveas_str };
1273  tooltip_list[2] = { nullptr, nullptr, nullptr };
1274 
1275  gnc_plugin_page_report_menu_update (plugin_page, tooltip_list);
1276 
1277  /* Enable the FilePrintAction */
1278  action = gnc_main_window_find_action (window, "FilePrintAction");
1279  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), true);
1280 
1281  if (priv->webkit2)
1282  {
1283  GtkWidget *pdf_item = gnc_main_window_menu_find_menu_item (window, "FilePrintPDFAction");
1284  gtk_widget_hide (pdf_item);
1285  }
1286  g_free (saved_reports_path);
1287  g_free (report_save_str);
1288  g_free (report_saveas_str);
1289 }
1290 
1291 static void
1292 gnc_plugin_page_report_constr_init (GncPluginPageReport *plugin_page, gint reportId)
1293 {
1295  GncPluginPage *parent;
1296  gboolean use_new;
1297  gchar *name;
1298 
1299  DEBUG("property reportId=%d", reportId);
1300  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(plugin_page);
1301  priv->reportId = reportId;
1302  priv->webkit2 = FALSE;
1303 
1304  gnc_plugin_page_report_setup( GNC_PLUGIN_PAGE(plugin_page));
1305 
1306  /* Init parent declared variables */
1307  parent = GNC_PLUGIN_PAGE(plugin_page);
1308  use_new = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REPORT, GNC_PREF_USE_NEW);
1309  name = gnc_report_name (priv->initial_report);
1310  g_object_set (G_OBJECT(plugin_page),
1311  "page-name", name,
1312  "ui-description", "gnc-plugin-page-report.ui",
1313  "use-new-window", use_new,
1314  nullptr);
1315  g_free (name);
1316 
1317  /* change me when the system supports multiple books */
1318  gnc_plugin_page_add_book (parent, gnc_get_current_book());
1319 
1320  /* Create menu and toolbar information */
1321  priv->action_group = gnc_plugin_page_create_action_group (parent, "GncPluginPageReportActions");
1322  g_action_map_add_action_entries (G_ACTION_MAP(priv->action_group),
1323  report_actions,
1324  num_report_actions,
1325  plugin_page);
1326 
1327  gnc_plugin_set_actions_enabled (G_ACTION_MAP(priv->action_group), initially_insensitive_actions,
1328  FALSE);
1329  gnc_plugin_set_actions_enabled(G_ACTION_MAP(priv->action_group),
1330  disable_during_load_actions, FALSE);
1331 }
1332 
1335 {
1336  DEBUG( "report id = %d", reportId );
1337  auto plugin_page{g_object_new(GNC_TYPE_PLUGIN_PAGE_REPORT, "report-id",
1338  reportId, nullptr)};
1339  DEBUG( "plugin_page: %p", plugin_page );
1340  DEBUG( "set %d on page %p", reportId, plugin_page );
1341  return GNC_PLUGIN_PAGE( plugin_page );
1342 }
1343 
1344 void
1345 gnc_plugin_page_report_remove_edited_report(GncPluginPageReportPrivate *priv,
1346  SCM report)
1347 {
1348  SCM new_edited = scm_delete(priv->edited_reports, report);
1349  if (priv->edited_reports != SCM_EOL)
1350  scm_gc_unprotect_object(priv->edited_reports);
1351  priv->edited_reports = new_edited;
1352  if (new_edited != SCM_EOL)
1353  scm_gc_protect_object(priv->edited_reports);
1354 }
1355 
1356 void
1357 gnc_plugin_page_report_add_edited_report(GncPluginPageReportPrivate *priv,
1358  SCM report)
1359 {
1360  SCM new_edited = scm_cons(report, priv->edited_reports);
1361  if (priv->edited_reports != SCM_EOL)
1362  scm_gc_unprotect_object(priv->edited_reports);
1363  priv->edited_reports = new_edited;
1364  if (new_edited != SCM_EOL)
1365  scm_gc_protect_object(priv->edited_reports);
1366 }
1367 
1368 void
1369 gnc_plugin_page_report_raise_editor(SCM report)
1370 {
1371  SCM get_editor = scm_c_eval_string("gnc:report-editor-widget");
1372  SCM editor = scm_call_1(get_editor, report);
1373 #define FUNC_NAME "gtk_window_present"
1374  auto w{static_cast<GtkWidget *>(SWIG_MustGetPtr(editor, SWIG_TypeQuery("_p_GtkWidget"), 1, 0))};
1375 #undef FUNC_NAME
1376  gtk_window_present(GTK_WINDOW(w));
1377 }
1378 
1379 static void
1380 close_handler (gpointer user_data)
1381 {
1382  GncPluginPage *plugin_page = GNC_PLUGIN_PAGE(user_data);
1383  DEBUG("in close handler\n");
1384  gnc_main_window_close_page (plugin_page);
1385 }
1386 
1387 static void
1388 gnc_plugin_page_report_set_fwd_button (GncPluginPageReport *report, int enabled)
1389 {
1390  GAction *action = gnc_plugin_page_get_action (GNC_PLUGIN_PAGE(report),
1391  "ReportForwAction");
1392  if (action != NULL)
1393  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), enabled);
1394 }
1395 
1396 static void
1397 gnc_plugin_page_report_set_back_button (GncPluginPageReport *report, int enabled)
1398 {
1399  GAction *action = gnc_plugin_page_get_action (GNC_PLUGIN_PAGE(report),
1400  "ReportBackAction");
1401  if (action != NULL)
1402  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), enabled);
1403 }
1404 
1405 // ------------------------------------------------------------
1406 // GTK ACTION CALLBACKS
1407 
1408 static void
1409 gnc_plugin_page_report_forw_cb (GSimpleAction *simple,
1410  GVariant *parameter,
1411  gpointer user_data)
1412 {
1413  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1415  gnc_html_history_node * node = nullptr;
1416 
1417  DEBUG( "forw" );
1418  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1419  gnc_html_history_forward(gnc_html_get_history(priv->html));
1420  node = gnc_html_history_get_current(gnc_html_get_history(priv->html));
1421  if (node)
1422  {
1423  gnc_html_show_url(priv->html, node->type, node->location,
1424  node->label, 0);
1425  }
1426 }
1427 
1428 static void
1429 gnc_plugin_page_report_back_cb (GSimpleAction *simple,
1430  GVariant *parameter,
1431  gpointer user_data)
1432 {
1433  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1435  gnc_html_history_node * node;
1436 
1437  DEBUG( "back" );
1438  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1439  gnc_html_history_back(gnc_html_get_history(priv->html));
1440  node = gnc_html_history_get_current(gnc_html_get_history(priv->html));
1441  if (node)
1442  {
1443  gnc_html_show_url(priv->html, node->type, node->location,
1444  node->label, 0);
1445  }
1446 }
1447 
1448 void
1449 gnc_plugin_page_report_reload (GncPluginPageReport *report)
1450 {
1451  gnc_plugin_page_report_reload_cb (nullptr, nullptr, report);
1452 }
1453 
1454 static void
1455 gnc_plugin_page_report_reload_cb (GSimpleAction *simple,
1456  GVariant *parameter,
1457  gpointer user_data)
1458 {
1459  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1460  GncPluginPage *page;
1462  SCM dirty_report;
1463 
1464  DEBUG( "reload" );
1465  page = GNC_PLUGIN_PAGE(report);
1466  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1467  if (priv->cur_report == SCM_BOOL_F)
1468  return;
1469 
1470  DEBUG( "reload-redraw" );
1471  dirty_report = scm_c_eval_string("gnc:report-set-dirty?!");
1472  scm_call_2(dirty_report, priv->cur_report, SCM_BOOL_T);
1473 
1474  /* now queue the fact that we need to reload this report */
1475  // Disable some actions reported to crash while loading
1476  gnc_plugin_set_actions_enabled(G_ACTION_MAP(priv->action_group),
1477  disable_during_load_actions, FALSE);
1478  // prevent closing this page while loading...
1479  priv->reloading = TRUE;
1480  // this sets the window for the progressbar
1481  gnc_window_set_progressbar_window( GNC_WINDOW(page->window) );
1482 
1483  // this sets the minimum size of the progressbar to that allocated
1484  gnc_plugin_page_report_set_progressbar( page, TRUE );
1485 
1486  gnc_html_reload( priv->html, TRUE ); //reload by rebuild
1487 
1488  gnc_plugin_page_report_set_progressbar( page, FALSE );
1489 
1490  // this resets the window for the progressbar to nullptr
1491  gnc_window_set_progressbar_window( nullptr );
1492  gnc_plugin_set_actions_enabled(G_ACTION_MAP(priv->action_group),
1493  disable_during_load_actions, TRUE);
1494  priv->reloading = FALSE;
1495 }
1496 
1497 static void
1498 gnc_plugin_page_report_stop_cb (GSimpleAction *simple,
1499  GVariant *parameter,
1500  gpointer user_data)
1501 {
1502  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1504 
1505  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1506  gnc_html_cancel(priv->html);
1507 }
1508 
1509 /* Returns SCM_BOOL_F if cancel. Returns SCM_BOOL_T if html.
1510  * Otherwise returns pair from export_types. */
1511 static SCM
1512 gnc_get_export_type_choice (SCM export_types, GtkWindow *parent)
1513 {
1514  GList * choices = nullptr;
1515  gboolean bad = FALSE;
1516  GList * node;
1517  int choice;
1518  SCM tail;
1519 
1520  if (!scm_is_list (export_types))
1521  return SCM_BOOL_F;
1522 
1523  for (tail = export_types; !scm_is_null (tail); tail = SCM_CDR (tail))
1524  {
1525  SCM pair = SCM_CAR (tail);
1526  char * name;
1527  SCM scm;
1528 
1529  if (!scm_is_pair (pair))
1530  {
1531  g_warning ("unexpected list element");
1532  bad = TRUE;
1533  break;
1534  }
1535 
1536  scm = SCM_CAR (pair);
1537  if (!scm_is_string (scm))
1538  {
1539  g_warning ("unexpected pair element");
1540  bad = TRUE;
1541  break;
1542  }
1543 
1544  name = gnc_scm_to_utf8_string (scm);
1545  choices = g_list_prepend (choices, name);
1546  }
1547 
1548  if (!bad)
1549  {
1550  choices = g_list_reverse (choices);
1551 
1552  choices = g_list_prepend (choices, g_strdup (_("HTML")));
1553 
1554  choice = gnc_choose_radio_option_dialog
1555  (GTK_WIDGET (parent), _("Choose export format"),
1556  _("Choose the export format for this report:"),
1557  nullptr, 0, choices);
1558  }
1559  else
1560  choice = -1;
1561 
1562  for (node = choices; node; node = node->next)
1563  g_free (node->data);
1564  g_list_free (choices);
1565 
1566  if (choice < 0)
1567  return SCM_BOOL_F;
1568 
1569  if (choice == 0)
1570  return SCM_BOOL_T;
1571 
1572  choice--;
1573  if (choice >= scm_ilength (export_types))
1574  return SCM_BOOL_F;
1575 
1576  return scm_list_ref (export_types, scm_from_int (choice));
1577 }
1578 
1579 static char *
1580 gnc_get_export_filename (SCM choice, GtkWindow *parent)
1581 {
1582  char * filepath;
1583  GStatBuf statbuf;
1584  char * title;
1585  const gchar * html_type = _("HTML");
1586  char * type;
1587  int rc;
1588  char * default_dir;
1589 
1590  if (choice == SCM_BOOL_T)
1591  type = g_strdup (html_type);
1592  else
1593  type = gnc_scm_to_utf8_string(SCM_CAR (choice));
1594 
1595  /* %s is the type of what is about to be saved, e.g. "HTML". */
1596  title = g_strdup_printf (_("Save %s To File"), type);
1597  default_dir = gnc_get_default_directory(GNC_PREFS_GROUP_REPORT);
1598 
1599  filepath = gnc_file_dialog (parent, title, nullptr, default_dir,
1600  GNC_FILE_DIALOG_EXPORT);
1601 
1602  if (filepath != nullptr) // test for cancel pressed
1603  {
1604  /* Try to test for extension on file name, add if missing */
1605  if (g_strrstr(filepath, ".") == nullptr)
1606  filepath = g_strconcat(filepath, ".", g_ascii_strdown(type, strlen(type)), nullptr);
1607  }
1608  g_free (type);
1609  g_free (title);
1610  g_free (default_dir);
1611 
1612  if (!filepath)
1613  return nullptr;
1614 
1615  default_dir = g_path_get_dirname(filepath);
1616  gnc_set_default_directory (GNC_PREFS_GROUP_REPORT, default_dir);
1617  g_free(default_dir);
1618 
1619  rc = g_stat (filepath, &statbuf);
1620 
1621  /* Check for an error that isn't a non-existent file. */
1622  if (rc != 0 && errno != ENOENT)
1623  {
1624  /* %s is the strerror(3) string of the error that occurred. */
1625  const char *format = _("You cannot save to that filename.\n\n%s");
1626 
1627  gnc_error_dialog (parent, format, strerror(errno));
1628  g_free(filepath);
1629  return nullptr;
1630  }
1631 
1632  /* Check for a file that isn't a regular file. */
1633  if (rc == 0 && !S_ISREG (statbuf.st_mode))
1634  {
1635  const char *message = _("You cannot save to that file.");
1636 
1637  gnc_error_dialog (parent, "%s", message);
1638  g_free(filepath);
1639  return nullptr;
1640  }
1641 
1642  if (rc == 0)
1643  {
1644  const char *format = _("The file %s already exists. "
1645  "Are you sure you want to overwrite it?");
1646 
1647  if (!gnc_verify_dialog (parent, FALSE, format, filepath))
1648  {
1649  g_free(filepath);
1650  return nullptr;
1651  }
1652  }
1653 
1654  return filepath;
1655 }
1656 
1657 static void
1658 gnc_plugin_page_report_edit_tax_cb (GSimpleAction *simple,
1659  GVariant *parameter,
1660  gpointer user_data)
1661 {
1662  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1663  GtkWidget *window;
1664 
1665  window = GNC_PLUGIN_PAGE(report)->window;
1666  gnc_tax_info_dialog (window, nullptr);
1667 }
1668 
1669 static void
1670 gnc_plugin_page_report_save_as_cb (GSimpleAction *simple,
1671  GVariant *parameter,
1672  gpointer user_data)
1673 {
1674  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1676  SCM save_func;
1677  SCM rpt_id;
1678 
1679  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1680  if (priv->cur_report == SCM_BOOL_F)
1681  return;
1682 
1683  /* Create a new report template based on the current report's settings
1684  * and allow the user to rename the template.
1685  */
1686  save_func = scm_c_eval_string("gnc:report-to-template-new");
1687  rpt_id = scm_call_1(save_func, priv->cur_report);
1688 
1689  /* Open Preconfigured Reports dialog to allow user to change the name */
1690  if (!scm_is_null (rpt_id))
1691  {
1692  GncPluginPage *reportPage = GNC_PLUGIN_PAGE (report);
1693  GtkWidget *window = reportPage->window;
1694 
1695  if (window)
1696  g_return_if_fail(GNC_IS_MAIN_WINDOW(window));
1697 
1698  gnc_ui_custom_report_edit_name (GNC_MAIN_WINDOW (window), rpt_id);
1699  }
1700 
1701 }
1702 
1703 static void
1704 gnc_plugin_page_report_save_cb (GSimpleAction *simple,
1705  GVariant *parameter,
1706  gpointer user_data)
1707 {
1708  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1710  SCM check_func, save_func;
1711  SCM rpt_id;
1712 
1713  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1714  if (priv->cur_report == SCM_BOOL_F)
1715  return;
1716 
1717  check_func = scm_c_eval_string("gnc:is-custom-report-type");
1718  if (scm_is_true (scm_call_1 (check_func, priv->cur_report)))
1719  {
1720  /* The current report is already based on a custom report.
1721  * Replace the existing one instead of adding a new one
1722  */
1723  save_func = scm_c_eval_string("gnc:report-to-template-update");
1724  rpt_id = scm_call_1(save_func, priv->cur_report);
1725  (void)rpt_id;
1726  }
1727  else
1728  {
1729  /* The current report is not based on a custom report.
1730  * So let's create a new report template based on this report
1731  * and allow the user to change the name.
1732  */
1733  gnc_plugin_page_report_save_as_cb (simple, parameter, report);
1734  }
1735 }
1736 
1737 static void
1738 gnc_plugin_page_report_export_cb (GSimpleAction *simple,
1739  GVariant *parameter,
1740  gpointer user_data)
1741 {
1742  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1744  char * filepath;
1745  SCM export_types;
1746  SCM export_thunk;
1747  gboolean result;
1748  SCM choice;
1749  GtkWindow *parent = GTK_WINDOW (gnc_plugin_page_get_window
1750  (GNC_PLUGIN_PAGE (report)));
1751 
1752  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1753  export_types = scm_call_1 (scm_c_eval_string ("gnc:report-export-types"),
1754  priv->cur_report);
1755 
1756  export_thunk = scm_call_1 (scm_c_eval_string ("gnc:report-export-thunk"),
1757  priv->cur_report);
1758 
1759  if (scm_is_list (export_types) && scm_is_procedure (export_thunk))
1760  choice = gnc_get_export_type_choice (export_types, parent);
1761  else
1762  choice = SCM_BOOL_T;
1763 
1764  if (choice == SCM_BOOL_F)
1765  return;
1766 
1767  filepath = gnc_get_export_filename (choice, parent);
1768  if (!filepath)
1769  return;
1770 
1771  if (scm_is_pair (choice))
1772  {
1773  SCM type = scm_cdr (choice);
1774  SCM document = scm_call_2 (export_thunk, priv->cur_report, type);
1775  SCM query_result = scm_c_eval_string ("gnc:html-document?");
1776  SCM get_export_string = scm_c_eval_string ("gnc:html-document-export-string");
1777  SCM get_export_error = scm_c_eval_string ("gnc:html-document-export-error");
1778 
1779  if (scm_is_false (scm_call_1 (query_result, document)))
1780  gnc_error_dialog (parent, "%s",
1781  _("This report must be upgraded to return a "
1782  "document object with export-string or "
1783  "export-error."));
1784  else
1785  {
1786  SCM export_string = scm_call_1 (get_export_string, document);
1787  SCM export_error = scm_call_1 (get_export_error, document);
1788 
1789  if (scm_is_string (export_string))
1790  {
1791  GError *err = nullptr;
1792  gchar *exported = scm_to_utf8_string (export_string);
1793  if (!g_file_set_contents (filepath, exported, -1, &err))
1794  gnc_error_dialog (parent, "Error during export: %s", err->message);
1795  g_free (exported);
1796  if (err)
1797  g_error_free (err);
1798  }
1799  else if (scm_is_string (export_error))
1800  {
1801  gchar *str = scm_to_utf8_string (export_error);
1802  gnc_error_dialog (parent, "error during export: %s", str);
1803  g_free (str);
1804  }
1805  else
1806  gnc_error_dialog (parent, "%s",
1807  _("This report must be upgraded to return a "
1808  "document object with export-string or "
1809  "export-error."));
1810  }
1811  result = TRUE;
1812  }
1813  else
1814  result = gnc_html_export_to_file (priv->html, filepath);
1815 
1816  if (!result)
1817  {
1818  const char *fmt = _("Could not open the file %s. "
1819  "The error is: %s");
1820  gnc_error_dialog (parent, fmt, filepath ? filepath : "(null)",
1821  strerror (errno) ? strerror (errno) : "" );
1822  }
1823 
1824  g_free(filepath);
1825  return;
1826 }
1827 
1828 static void
1829 gnc_plugin_page_report_options_cb (GSimpleAction *simple,
1830  GVariant *parameter,
1831  gpointer user_data)
1832 {
1833  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1835  GtkWindow *parent = GTK_WINDOW (gnc_plugin_page_get_window (GNC_PLUGIN_PAGE (report)));
1836  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1837  if (priv->cur_report == SCM_BOOL_F)
1838  return;
1839 
1840  if (gnc_report_edit_options (priv->cur_report, parent))
1841  gnc_plugin_page_report_add_edited_report(priv, priv->cur_report);
1842 }
1843 
1844 static GncInvoice*
1845 lookup_invoice(GncPluginPageReportPrivate *priv)
1846 {
1847  const QofInstance* opt_val =
1849  "Invoice Number");
1850  return GNC_INVOICE(opt_val);
1851 }
1852 
1853 #define GNC_PREFS_GROUP_REPORT_PDFEXPORT GNC_PREFS_GROUP_GENERAL_REPORT ".pdf-export"
1854 #define GNC_PREF_FILENAME_DATE_FMT "filename-date-format"
1855 #define GNC_PREF_FILENAME_FMT "filename-format"
1856 
1857 static gchar *report_create_jobname(GncPluginPageReportPrivate *priv)
1858 {
1859  gchar *job_name = nullptr;
1860  gchar *report_name = nullptr;
1861  const gchar *report_number = "";
1862  gchar *job_date;
1863  const gchar *default_jobname = N_("GnuCash-Report");
1864 
1865  g_assert(priv);
1866 
1867  {
1868  // Look up the date format that was chosen in the preferences database
1869  QofDateFormat date_format_here = QOF_DATE_FORMAT_ISO;
1870  char *format_code = gnc_prefs_get_string (GNC_PREFS_GROUP_REPORT_PDFEXPORT,
1871  GNC_PREF_FILENAME_DATE_FMT);
1872  const gchar *date_format_string;
1873  if (!(format_code && *format_code))
1874  {
1875  g_free(format_code);
1876  format_code = g_strdup("locale");
1877  }
1878 
1879  if (gnc_date_string_to_dateformat (format_code, &date_format_here))
1880  PERR("Incorrect date format code, using ISO-8601.");
1881 
1882  date_format_string = qof_date_format_get_string (date_format_here);
1883 
1884  job_date = gnc_print_time64 (gnc_time (nullptr), date_format_string);
1885  g_free (format_code);
1886  }
1887 
1888 
1889  if (priv->cur_report == SCM_BOOL_F)
1890  report_name = g_strdup (_(default_jobname));
1891  else
1892  {
1893  /* Gather some information from the report to generate a
1894  * decent print job name.
1895  * FIXME: this is a bit of a hack. It would be better if each
1896  * report had a hidden job name option, because the
1897  * generic reporting code shouldn't know what makes
1898  * a decent job name for each report.
1899  *
1900  * Also, the "Report name" for an invoice report is
1901  * "Printable Invoice", which is not what the user wants to see,
1902  * so I added yet another hack below for this. cstim.
1903  */
1904  GncInvoice *invoice;
1905  auto report_name_str = priv->cur_odb->lookup_string_option("General",
1906  "Report name");
1907  if (!report_name_str.empty())
1908  report_name = g_strdup(report_name_str.c_str());
1909  else
1910  report_name = g_strdup (_(default_jobname));
1911 
1912  if (g_strcmp0(report_name, _("Printable Invoice")) == 0
1913  || g_strcmp0(report_name, _("Tax Invoice")) == 0
1914  || g_strcmp0(report_name, _("Easy Invoice")) == 0
1915  || g_strcmp0(report_name, _("Fancy Invoice")) == 0)
1916  {
1917  /* Again HACK alert: We modify this single known string here into
1918  * something more appropriate. */
1919  g_free(report_name);
1920  report_name = g_strdup(_("Invoice"));
1921  }
1922 
1923  invoice = lookup_invoice(priv);
1924  if (invoice)
1925  {
1926  // Report is for an invoice. Hence, we get a number of the invoice.
1927  report_number = gncInvoiceGetID(invoice);
1928  }
1929  }
1930 
1931  if (report_name && job_date)
1932  {
1933  // Look up the printf format of the output name from the preferences database
1934  char* format = gnc_prefs_get_string(GNC_PREFS_GROUP_REPORT_PDFEXPORT, GNC_PREF_FILENAME_FMT);
1935 
1936  if (format && *format)
1937  {
1938  job_name = g_strdup_printf(format, report_name,
1939  report_number, job_date);
1940  }
1941  else
1942  {
1943  PWARN("No GNC_PREF_FILENAME_FMT!");
1944  job_name = g_strdup_printf ("%s %s %s", report_name,
1945  report_number, job_date);
1946  }
1947  g_free(format);
1948  }
1949  g_free (report_name);
1950  g_free (job_date);
1951 
1952  {
1953  char forbidden_char = '/';
1954  // Now remove the characters that are not allowed in file
1955  // names. FIXME: Check for all disallowed characters here!
1956  while (strchr(job_name, forbidden_char))
1957  {
1958  *strchr(job_name, forbidden_char) = '_';
1959  }
1960  }
1961 
1962  {
1963  /* And one final checking issue: We want to avoid allocating
1964  * the same name twice for a saved PDF. Hence, we keep a
1965  * unordered_map with the usage count of existing output
1966  * names. */
1967 
1968  auto& value = static_report_printnames[job_name];
1969  value++;
1970 
1971  if (value > 1)
1972  {
1973  // The name was already in use, so modify the name again
1974  gchar *tmp = g_strdup_printf("%s_%d", job_name, value);
1975  g_free(job_name);
1976  job_name = tmp;
1977  }
1978  }
1979 
1980  return job_name;
1981 }
1982 
1983 static void
1984 gnc_plugin_page_report_print_cb (GSimpleAction *simple,
1985  GVariant *parameter,
1986  gpointer user_data)
1987 {
1988  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
1989  GncPluginPageReportPrivate *priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
1990  gchar *job_name = report_create_jobname(priv);
1991 
1992  //g_warning("Setting job name=%s", job_name);
1993 
1994 #ifdef WEBKIT1
1995  gnc_html_print (priv->html, job_name, FALSE);
1996 #else
1997  gnc_html_print (priv->html, job_name);
1998 #endif
1999 
2000  g_free (job_name);
2001 }
2002 
2003 static void
2004 gnc_plugin_page_report_exportpdf_cb (GSimpleAction *simple,
2005  GVariant *parameter,
2006  gpointer user_data)
2007 {
2008  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
2009  GncPluginPageReportPrivate *priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
2010  gchar *job_name = report_create_jobname(priv);
2011  GncInvoice *invoice;
2012  GncOwner *owner = nullptr;
2013 
2014  // Do we have an invoice report?
2015  invoice = lookup_invoice(priv);
2016  if (invoice)
2017  {
2018  // Does this invoice also have an owner?
2019  owner = (GncOwner*) gncInvoiceGetOwner(invoice);
2020  if (owner)
2021  {
2022  QofInstance *inst = qofOwnerGetOwner (owner);
2023  gchar *dirname = nullptr;
2024  qof_instance_get (inst, "export-pdf-dir", &dirname, nullptr);
2025  // Yes. In the kvp, look up the key for the Export-PDF output
2026  // directory. If it exists, prepend this to the job name so that
2027  // we can export to PDF.
2028  if (dirname && g_file_test (dirname,
2029  (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
2030  {
2031  gchar *tmp = g_build_filename (dirname, job_name, nullptr);
2032  g_free (job_name);
2033  job_name = tmp;
2034  }
2035  }
2036  }
2037 
2038  //g_warning("Setting job name=%s", job_name);
2039 
2040 #ifdef WEBKIT1
2041  gnc_html_print (priv->html, job_name, TRUE);
2042 #else
2043  gnc_html_print (priv->html, job_name);
2044 #endif
2045 
2046  if (owner)
2047  {
2048  /* As this is an invoice report with some owner, we will try
2049  * to look up the chosen output directory from the print
2050  * settings and store it again in the owner kvp.
2051  */
2052  GtkPrintSettings *print_settings = gnc_print_get_settings();
2053  if (print_settings && gtk_print_settings_has_key (print_settings,
2055  {
2056  const char* dirname = gtk_print_settings_get (print_settings,
2058  // Only store the directory if it exists.
2059  if (g_file_test (dirname,
2060  (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)))
2061  {
2062  QofInstance *inst = qofOwnerGetOwner (owner);
2063  gncOwnerBeginEdit (owner);
2064  qof_instance_set (inst, "export-pdf-dir", dirname);
2065  gncOwnerCommitEdit (owner);
2066  }
2067  }
2068  }
2069  g_free (job_name);
2070 }
2071 
2072 static void
2073 gnc_plugin_page_report_copy_cb (GSimpleAction *simple,
2074  GVariant *parameter,
2075  gpointer user_data)
2076 {
2077  GncPluginPageReport *report = (GncPluginPageReport*)user_data;
2079 
2080  priv = GNC_PLUGIN_PAGE_REPORT_GET_PRIVATE(report);
2081  gnc_html_copy_to_clipboard(priv->html);
2082 }
2083 
2084 /********************************************************************
2085  * gnc_main_window_open_report()
2086  * open an report in a top level window from an ID number
2087  ********************************************************************/
2088 
2089 void
2090 gnc_main_window_open_report(int report_id, GncMainWindow *window)
2091 {
2092  GncPluginPage *reportPage;
2093 
2094  if (window)
2095  g_return_if_fail(GNC_IS_MAIN_WINDOW(window));
2096 
2097  reportPage = gnc_plugin_page_report_new( report_id );
2098  gnc_main_window_open_page( window, reportPage );
2099 }
2100 
2101 void
2102 gnc_main_window_open_report_url(const char * url, GncMainWindow *window)
2103 {
2104  GncPluginPage *reportPage;
2105 
2106  DEBUG( "report url: [%s]\n", url );
2107 
2108  if (window)
2109  g_return_if_fail(GNC_IS_MAIN_WINDOW(window));
2110 
2111  reportPage = gnc_plugin_page_report_new( 42 /* url? */ );
2112  gnc_main_window_open_page( window, reportPage );
2113 }
2114 
Holds all of the options for a book, report, or stylesheet, organized by GncOptionSections.
ISO: yyyy-mm-dd.
Definition: gnc-date.h:127
GncHtml * html
the gnc_html abstraction this PluginPage contains
GtkWidget * gnc_plugin_page_get_window(GncPluginPage *page)
Retrieve a pointer to the GncMainWindow (GtkWindow) containing this page.
const gchar * tab_icon
The relative name of the icon that should be shown on the tab for this page.
GtkContainer * container
the container the above HTML widget is in.
const QofInstance * gnc_option_db_lookup_qofinstance_value(GncOptionDB *odb, const char *section, const char *name)
Retrieve the QofInstance value of an option in the GncOptionDB.
gboolean(* focus_page_function)(GncPluginPage *plugin_page)
This function performs specific actions to set the focus on a specific widget.
void gnc_main_window_update_menu_and_toolbar(GncMainWindow *window, GncPluginPage *page, const gchar **ui_updates)
Update the main window menu with the placeholders listed in ui_updates and load the page specific too...
void qof_instance_get(const QofInstance *inst, const gchar *first_prop,...)
Wrapper for g_object_get.
The instance data structure for a content plugin.
gchar * gnc_prefs_get_string(const gchar *group, const gchar *pref_name)
Get a string value from the preferences backend.
gchar * gnc_build_userdata_path(const gchar *filename)
Make a path to filename in the user&#39;s gnucash data directory.
#define GNC_GTK_PRINT_SETTINGS_EXPORT_DIR
Key for saving the PDF-export directory in the print settings.
Definition: print-session.h:74
GtkWindow * gnc_ui_get_main_window(GtkWidget *widget)
Get a pointer to the final GncMainWindow widget is rooted in.
utility functions for the GnuCash UI
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:256
gtk helper routines.
GncPluginPage *(* recreate_page)(GtkWidget *window, GKeyFile *file, const gchar *group)
Create a new page based on the information saved during a previous instantiation of gnucash...
void gnc_main_window_menu_add_accelerator_keys(GncMainWindow *window)
Scan the main window menu and add accelerator keys to main window accelerator group.
void gnc_main_window_init_short_names(GncMainWindow *window, GncToolBarShortNames *toolbar_labels)
Update the labels of the toolbar items with short names.
#define DEBUG(format, args...)
Print a debugging message.
Definition: qoflog.h:264
const gchar * gnc_plugin_page_get_page_name(GncPluginPage *page)
Retrieve the name of this page.
Functions that are supported by all types of windows.
void qof_instance_set(QofInstance *inst, const gchar *first_prop,...)
Wrapper for g_object_set Group setting multiple parameters in a single begin/commit/rollback.
A structure for defining alternate action names for use in the toolbar.
Definition: gnc-plugin.h:204
GtkWidget * gnc_main_window_menu_find_menu_item(GncMainWindow *window, const gchar *action_name)
Find the menu item with the given action name for the window specified.
void gnc_utf8_strip_invalid_and_controls(gchar *str)
Strip any non-utf8 characters and any control characters (everything < 0x20, , , ...
GtkWidget * window
The window that contains the display widget for this plugin.
gboolean gnc_main_window_is_restoring_pages(GncMainWindow *window)
Check if the main window is restoring the plugin pages.
GSimpleActionGroup * gnc_plugin_page_create_action_group(GncPluginPage *page, const gchar *group_name)
Create the GSimpleActionGroup object associated with this page.
gboolean gnc_main_window_update_menu_for_action(GncMainWindow *window, const gchar *action_name, const gchar *label, const gchar *tooltip)
Find the GMenuModel item given the action name for the window specified.
#define PERR(format, args...)
Log a serious error.
Definition: qoflog.h:244
#define ENTER(format, args...)
Print a function entry debugging message.
Definition: qoflog.h:272
void gncOwnerBeginEdit(GncOwner *owner)
These are convenience wrappers around gnc{Vendor,Customer,Job,Employee}* functions.
Definition: gncOwner.c:72
GncPluginPage * gnc_main_window_get_current_page(GncMainWindow *window)
Retrieve a pointer to the page that is currently at the front of the specified window.
void gnc_main_window_open_page(GncMainWindow *window, GncPluginPage *page)
Display a data plugin page in a window.
QofInstance * qofOwnerGetOwner(const GncOwner *owner)
return the owner itself as an entity.
Definition: gncOwner.c:275
void(* update_edit_menu_actions)(GncPluginPage *plugin_page, gboolean hide)
This function vector allows page specific actions to override the generic code for setting the sensit...
void(* destroy_widget)(GncPluginPage *plugin_page)
Function called to destroy the display widget for a particular type of plugin.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
This file contains the functions to present a GUI to manage custom reports.
The class data structure for a content plugin.
GAction * gnc_main_window_find_action(GncMainWindow *window, const gchar *action_name)
Find the GAction in the main window.
Functions providing the file history menu.
void gnc_plugin_page_disconnect_page_changed(GncPluginPage *page)
Disconnect the page_changed_id signal callback.
void gnc_option_db_destroy(GncOptionDB *odb)
Destruct and release a GncOptionDB.
char * gnc_print_time64(time64 time, const char *format)
print a time64 as a date string per format
Definition: gnc-date.cpp:369
const gchar * plugin_name
The textual name of this plugin.
GtkWidget *(* create_widget)(GncPluginPage *plugin_page)
Function called to create the display widget for a particular type of plugin.
void(* page_name_changed)(GncPluginPage *plugin_page, const gchar *name)
This function vector allows page specific actions to occur when the page name is changed.
void gnc_plugin_set_actions_enabled(GActionMap *action_map, const gchar **action_names, gboolean enable)
This function sets the sensitivity of a GAction in a specific group.
Definition: gnc-plugin.c:250
Gnome specific utility functions.
gboolean(* finish_pending)(GncPluginPage *plugin_page)
This function vector is called to finish any outstanding activities.
All type declarations for the whole Gnucash engine.
void(* save_page)(GncPluginPage *page, GKeyFile *file, const gchar *group)
Save enough information about this page so that it can be recreated next time the user starts gnucash...
GncPluginPage * gnc_plugin_page_report_new(int reportId)
GtkPrintSettings * gnc_print_get_settings()
Returns the pointer to our static GtkPrintSettings object.
GLib helper routines.
Generic api to store and retrieve preferences.
A structure for defining alternate action names for use in the toolbar.
SCM cur_report
The report which this Page is satisfying.
gboolean gnc_prefs_get_bool(const gchar *group, const gchar *pref_name)
Get a boolean value from the preferences backend.
void gnc_plugin_page_inserted_cb(GncPluginPage *page, gpointer user_data)
Set up the page_changed callback for when the current page is changed.
void gnc_main_window_close_page(GncPluginPage *page)
Remove a data plugin page from a window and display the previous page.
Functions for adding plugins to a GnuCash window.
#define LEAVE(format, args...)
Print a function exit debugging message.
Definition: qoflog.h:282
time64 gnc_time(time64 *tbuf)
get the current time
Definition: gnc-date.cpp:261
Implementation details for GncOptionDB.
void gnc_plugin_page_add_book(GncPluginPage *page, QofBook *book)
Add a book reference to the specified page.
The instance data structure for a main window object.
File path resolution utility functions.
gboolean gnc_date_string_to_dateformat(const gchar *format_string, QofDateFormat *format)
Converts the date format to a printable string.
GncOptionDB * cur_odb
The Option DB for this report.
const gchar * qof_date_format_get_string(QofDateFormat df)
This function returns a strftime formatting string for printing an all numeric date (e...
Definition: gnc-date.cpp:501
void main_window_update_page_name(GncPluginPage *page, const gchar *name_in)
Update the name of the page in the main window.
GAction * gnc_plugin_page_get_action(GncPluginPage *page, const gchar *name)
Retrieve a GAction object associated with this page.
QofDateFormat
Enum for determining a date format.
Definition: gnc-date.h:122
GtkWidget * gnc_main_window_toolbar_find_tool_item(GncMainWindow *window, const gchar *action_name)
Find the toolbar item with the given action name for the window specified.
#define SCHEME_OPTIONS
The key name used it the state file for storing the report options.
const char * action_name
The name of the action.
Definition: gnc-plugin.h:207