GnuCash  5.6-150-g038405b370+
gnc-main-window.cpp
1 /*
2  * gnc-main-window.c -- GtkWindow which represents the
3  * GnuCash main window.
4  *
5  * Copyright (C) 2003 Jan Arne Petersen <jpetersen@uni-bonn.de>
6  * Copyright (C) 2003,2005,2006 David Hampton <hampton@employees.org>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, contact:
20  *
21  * Free Software Foundation Voice: +1-617-542-5942
22  * 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652
23  * Boston, MA 02110-1301, USA gnu@gnu.org
24  */
25 
35 #include <glib/gi18n.h>
36 #include <gtk/gtk.h>
37 #include <gdk/gdk.h>
38 #include <gdk/gdkkeysyms.h>
39 #include "dialog-options.hpp"
40 #include <libguile.h>
41 
42 #include <config.h>
43 
44 
45 #include "gnc-plugin.h"
46 #include "gnc-plugin-manager.h"
47 #include "gnc-main-window.h"
48 
49 #include "dialog-preferences.h"
50 #include "dialog-reset-warnings.h"
51 #include "dialog-transfer.h"
52 #include "dialog-utils.h"
53 #include "engine-helpers.h"
54 #include "file-utils.h"
55 #include "gnc-component-manager.h"
56 #include "dialog-doclink-utils.h"
57 #include "gnc-engine.h"
58 #include "gnc-features.h"
59 #include "gnc-file.h"
60 #include "gnc-filepath-utils.h"
61 #include "gnc-gkeyfile-utils.h"
62 #include "gnc-gnome-utils.h"
63 #include "gnc-gobject-utils.h"
64 #include "gnc-gui-query.h"
65 #include "gnc-gtk-utils.h"
66 #include "gnc-hooks.h"
67 #include "gnc-icons.h"
68 #include "gnc-session.h"
69 #include "gnc-state.h"
70 #include "gnc-ui.h"
71 #include "gnc-ui-util.h"
72 #include <gnc-glib-utils.h>
73 #include "gnc-uri-utils.h"
74 #include "gnc-version.h"
75 #include "gnc-warnings.h"
76 #include "gnc-window.h"
77 #include "gnc-prefs.h"
78 #include "gnc-optiondb.h"
79 #include "gnc-autosave.h"
80 #include "print-session.h"
81 #ifdef MAC_INTEGRATION
82 #include <gtkmacintegration/gtkosxapplication.h>
83 #endif
84 #ifdef HAVE_SYS_STAT_H
85 # define __need_system_sys_stat_h //To block Guile-2.0's evil substitute
86 # include <sys/types.h>
87 # include <sys/stat.h> // for stat(2)
88 #endif
89 
91 enum
92 {
93  PAGE_ADDED,
94  PAGE_CHANGED,
95  MENU_CHANGED,
96  LAST_SIGNAL
97 };
98 
101 #define PLUGIN_PAGE_LABEL "plugin-page"
102 
103 #define PLUGIN_PAGE_CLOSE_BUTTON "close-button"
104 #define PLUGIN_PAGE_TAB_LABEL "label"
105 
106 #define GNC_PREF_SHOW_CLOSE_BUTTON "tab-close-buttons"
107 #define GNC_PREF_TAB_NEXT_RECENT "tab-next-recent"
108 #define GNC_PREF_TAB_POSITION_TOP "tab-position-top"
109 #define GNC_PREF_TAB_POSITION_BOTTOM "tab-position-bottom"
110 #define GNC_PREF_TAB_POSITION_LEFT "tab-position-left"
111 #define GNC_PREF_TAB_POSITION_RIGHT "tab-position-right"
112 #define GNC_PREF_TAB_WIDTH "tab-width"
113 #define GNC_PREF_TAB_COLOR "show-account-color-tabs"
114 #define GNC_PREF_SAVE_CLOSE_EXPIRES "save-on-close-expires"
115 #define GNC_PREF_SAVE_CLOSE_WAIT_TIME "save-on-close-wait-time"
116 #define GNC_PREF_TAB_OPEN_ADJACENT "tab-open-adjacent"
117 
118 #define GNC_MAIN_WINDOW_NAME "GncMainWindow"
119 
120 #define DIALOG_BOOK_OPTIONS_CM_CLASS "dialog-book-options"
121 
133 extern gboolean gnc_book_options_dialog_apply_helper(GncOptionDB * options);
134 
136 [[maybe_unused]] constexpr auto gnc_main_window_max_number {10};
137 
138 /* Static Globals *******************************************************/
139 
141 static QofLogModule log_module = GNC_MOD_GUI;
143 static GQuark window_type = 0;
146 static GList *active_windows = nullptr;
149 static guint secs_to_save = 0;
150 #define MSG_AUTO_SAVE _("Changes will be saved automatically in %u seconds")
151 
152 /* Declarations *********************************************************/
153 static void gnc_main_window_constructed (GObject *object);
154 static void gnc_main_window_finalize (GObject *object);
155 static void gnc_main_window_destroy (GtkWidget *widget);
156 
157 static void gnc_main_window_setup_window (GncMainWindow *window);
158 static void gnc_window_main_window_init (GncWindowInterface *iface);
159 #ifndef MAC_INTEGRATION
160 static void gnc_main_window_update_all_menu_items (void);
161 #endif
162 
163 /* Callbacks */
164 static void gnc_main_window_switch_page (GtkNotebook *notebook, gpointer *notebook_page, gint pos, GncMainWindow *window);
165 static void gnc_main_window_page_reordered (GtkNotebook *notebook, GtkWidget *child, guint pos, GncMainWindow *window);
166 static void gnc_main_window_plugin_added (GncPlugin *manager, GncPlugin *plugin, GncMainWindow *window);
167 static void gnc_main_window_plugin_removed (GncPlugin *manager, GncPlugin *plugin, GncMainWindow *window);
168 static void gnc_main_window_engine_commit_error_callback( gpointer data, QofBackendError errcode );
169 
170 /* Command callbacks */
171 static void gnc_main_window_cmd_redirect (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
172 static void gnc_main_window_cmd_page_setup (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
173 static void gnc_main_window_cmd_file_properties (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
174 static void gnc_main_window_cmd_file_close (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
175 static void gnc_main_window_cmd_file_quit (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
176 static void gnc_main_window_cmd_edit_cut (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
177 static void gnc_main_window_cmd_edit_copy (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
178 static void gnc_main_window_cmd_edit_paste (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
179 static void gnc_main_window_cmd_edit_preferences (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
180 static void gnc_main_window_cmd_view_refresh (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
181 static void gnc_main_window_cmd_view_toolbar (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
182 static void gnc_main_window_cmd_view_summary (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
183 static void gnc_main_window_cmd_view_statusbar (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
184 
185 static void gnc_main_window_cmd_view_tab_position (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
186 
187 static void gnc_main_window_cmd_actions_reset_warnings (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
188 static void gnc_main_window_cmd_actions_rename_page (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
189 static void gnc_main_window_cmd_window_new (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
190 static void gnc_main_window_cmd_window_move_page (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
191 #ifndef MAC_INTEGRATION
192 static void gnc_main_window_cmd_window_raise (GSimpleAction *simple, GVariant *parameter, gpointer user_data);
193 #endif
194 static void gnc_main_window_cmd_help_tutorial (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
195 static void gnc_main_window_cmd_help_contents (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
196 static void gnc_main_window_cmd_help_about (GSimpleAction *simple, GVariant *paramter, gpointer user_data);
197 
198 static void do_popup_menu(GncPluginPage *page, GdkEventButton *event);
199 static GtkWidget *gnc_main_window_get_statusbar (GncWindow *window_in);
200 static void statusbar_notification_lastmodified (void);
201 static void gnc_main_window_update_tab_position (gpointer prefs, gchar *pref, gpointer user_data);
202 static void gnc_main_window_remove_prefs (GncMainWindow *window);
203 
204 #ifdef MAC_INTEGRATION
205 static void gnc_quartz_shutdown (GtkosxApplication *theApp, gpointer data);
206 static gboolean gnc_quartz_should_quit (GtkosxApplication *theApp, GncMainWindow *window);
207 static void gnc_quartz_set_menu (GncMainWindow* window);
208 #endif
209 static void gnc_main_window_init_menu_updaters (GncMainWindow *window);
210 
212 {
213  GtkApplicationWindow gtk_application_window;
214  gboolean window_quitting;
215  gboolean just_plugin_prefs;
216 };
217 
220 typedef struct
221 {
226  GtkWidget *menu_dock;
228  GtkWidget *menubar;
230  GMenuModel *menubar_model;
233  GtkWidget *toolbar;
235  GtkWidget *notebook;
237  gboolean show_color_tabs;
241  GtkWidget *statusbar;
245  GtkWidget *progressbar;
249  GList *usage_order;
255  gint pos[2];
257  gboolean restoring_pages;
258 
259  const gchar *previous_plugin_page_name;
260  const gchar *previous_menu_qualifier;
261 
263  GtkAccelGroup *accel_group;
264 
265  GHashTable *display_item_hash;
266 
268 
269 G_DEFINE_TYPE_WITH_CODE(GncMainWindow, gnc_main_window, GTK_TYPE_APPLICATION_WINDOW,
270  G_ADD_PRIVATE (GncMainWindow)
271  G_IMPLEMENT_INTERFACE (GNC_TYPE_WINDOW,
272  gnc_window_main_window_init))
273 
274 #define GNC_MAIN_WINDOW_GET_PRIVATE(o) \
275  ((GncMainWindowPrivate*)gnc_main_window_get_instance_private((GncMainWindow*)o))
276 
279 static guint main_window_signals[LAST_SIGNAL] = { 0 };
280 
285 static GActionEntry gnc_menu_actions [] =
286 {
287  { "FilePageSetupAction", gnc_main_window_cmd_page_setup, nullptr, nullptr, nullptr },
288  { "FilePropertiesAction", gnc_main_window_cmd_file_properties, nullptr, nullptr, nullptr },
289  { "FileCloseAction", gnc_main_window_cmd_file_close, nullptr, nullptr, nullptr },
290  { "FilePrintAction", gnc_main_window_cmd_redirect, nullptr, nullptr, nullptr },
291  { "FileQuitAction", gnc_main_window_cmd_file_quit, nullptr, nullptr, nullptr },
292 
293  { "EditCutAction", gnc_main_window_cmd_edit_cut, nullptr, nullptr, nullptr },
294  { "EditCopyAction", gnc_main_window_cmd_edit_copy, nullptr, nullptr, nullptr },
295  { "EditPasteAction", gnc_main_window_cmd_edit_paste, nullptr, nullptr, nullptr },
296  { "EditPreferencesAction", gnc_main_window_cmd_edit_preferences, nullptr, nullptr, nullptr },
297 
298  { "ActionsForgetWarningsAction", gnc_main_window_cmd_actions_reset_warnings, nullptr, nullptr, nullptr },
299  { "ActionsRenamePageAction", gnc_main_window_cmd_actions_rename_page, nullptr, nullptr, nullptr },
300 
301  { "TransactionAction", nullptr, nullptr, nullptr, nullptr },
302 
303  { "ViewSortByAction", nullptr, nullptr, nullptr, nullptr },
304  { "ViewFilterByAction", nullptr, nullptr, nullptr, nullptr },
305  { "ViewRefreshAction", gnc_main_window_cmd_view_refresh, nullptr, nullptr, nullptr },
306  { "ViewToolbarAction", gnc_main_window_cmd_view_toolbar, nullptr, "true", nullptr },
307  { "ViewSummaryAction", gnc_main_window_cmd_view_summary, nullptr, "true", nullptr },
308  { "ViewStatusbarAction", gnc_main_window_cmd_view_statusbar, nullptr, "true", nullptr },
309  { "ViewTabPositionAction", gnc_main_window_cmd_view_tab_position, "i", "@i 0", nullptr },
310 
311  { "ScheduledAction", nullptr, nullptr, nullptr, nullptr },
312 
313  { "ExtensionsAction", nullptr, nullptr, nullptr, nullptr },
314 
315  { "WindowNewAction", gnc_main_window_cmd_window_new, nullptr, nullptr, nullptr },
316  { "WindowMovePageAction", gnc_main_window_cmd_window_move_page, nullptr, nullptr, nullptr },
317 #ifndef MAC_INTEGRATION
318  { "WindowAction", gnc_main_window_cmd_window_raise, "i", "@i 0", nullptr },
319 #endif
320  { "HelpTutorialAction", gnc_main_window_cmd_help_tutorial, nullptr, nullptr, nullptr },
321  { "HelpContentsAction", gnc_main_window_cmd_help_contents, nullptr, nullptr, nullptr },
322  { "HelpAboutAction", gnc_main_window_cmd_help_about, nullptr, nullptr, nullptr },
323 };
325 static guint gnc_menu_n_actions = G_N_ELEMENTS(gnc_menu_actions);
326 
331 static const gchar *always_insensitive_actions[] =
332 {
333  "FilePrintAction",
334  nullptr
335 };
336 
337 
341 static const gchar *initially_insensitive_actions[] =
342 {
343  "FileCloseAction",
344  nullptr
345 };
346 
347 
352 static const gchar *always_hidden_actions[] =
353 {
354  "ViewSortByAction",
355  "ViewFilterByAction",
356  nullptr
357 };
358 
359 
362 static const gchar *immutable_page_actions[] =
363 {
364  "FileCloseAction",
365  nullptr
366 };
367 
368 
371 static const gchar *multiple_page_actions[] =
372 {
373  "WindowMovePageAction",
374  nullptr
375 };
376 
377 
378 /************************************************************
379  * *
380  ************************************************************/
381 #define WINDOW_COUNT "WindowCount"
382 #define WINDOW_STRING "Window %d"
383 #define WINDOW_GEOMETRY "WindowGeometry"
384 #define WINDOW_POSITION "WindowPosition"
385 #define WINDOW_MAXIMIZED "WindowMaximized"
386 #define TOOLBAR_VISIBLE "ToolbarVisible"
387 #define STATUSBAR_VISIBLE "StatusbarVisible"
388 #define SUMMARYBAR_VISIBLE "SummarybarVisible"
389 #define WINDOW_FIRSTPAGE "FirstPage"
390 #define WINDOW_PAGECOUNT "PageCount"
391 #define WINDOW_PAGEORDER "PageOrder"
392 #define PAGE_TYPE "PageType"
393 #define PAGE_NAME "PageName"
394 #define PAGE_STRING "Page %d"
395 
396 typedef struct
397 {
398  GKeyFile *key_file;
399  const gchar *group_name;
400  gint window_num;
401  gint page_num;
402  gint page_offset;
404 
405 
406 gboolean
407 gnc_main_window_is_restoring_pages (GncMainWindow *window)
408 {
409  GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
410  return priv->restoring_pages;
411 }
412 
413 
414 /* Iterator function to walk all pages in all windows, calling the
415  * specified function for each page. */
416 void
417 gnc_main_window_foreach_page (GncMainWindowPageFunc fn, gpointer user_data)
418 {
419  ENTER(" ");
420  for (auto w = active_windows; w; w = g_list_next(w))
421  {
422  auto window{static_cast<GncMainWindow*>(w->data)};
423  auto priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
424  for (auto p = priv->installed_pages; p; p = g_list_next(p))
425  {
426  auto page{static_cast<GncPluginPage*>(p->data)};
427  fn(page, user_data);
428  }
429  }
430  LEAVE(" ");
431 }
432 
433 
448 static gboolean
449 gnc_main_window_restore_page (GncMainWindow *window,
450  GncMainWindowSaveData *data)
451 {
452  GncMainWindowPrivate *priv;
453  GncPluginPage *page = nullptr;
454  gchar *page_group, *page_type = nullptr, *name = nullptr;
455  const gchar *class_type;
456  GError *error = nullptr;
457 
458  ENTER("window %p, data %p (key file %p, window %d, page start %d, page num %d)",
459  window, data, data->key_file, data->window_num, data->page_offset,
460  data->page_num);
461 
462  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
463  page_group = g_strdup_printf(PAGE_STRING,
464  data->page_offset + data->page_num);
465  page_type = g_key_file_get_string(data->key_file, page_group,
466  PAGE_TYPE, &error);
467  if (error)
468  {
469  g_warning("error reading group %s key %s: %s",
470  page_group, PAGE_TYPE, error->message);
471  goto cleanup;
472  }
473 
474  /* See if the page already exists. */
475  page = static_cast<GncPluginPage*>(g_list_nth_data(priv->installed_pages,
476  data->page_num));
477  if (page)
478  {
479  class_type = GNC_PLUGIN_PAGE_GET_CLASS(page)->plugin_name;
480  if (strcmp(page_type, class_type) != 0)
481  {
482  g_warning("error: page types don't match: state %s, existing page %s",
483  page_type, class_type);
484  goto cleanup;
485  }
486  }
487  else
488  {
489  /* create and install the page */
490  page = gnc_plugin_page_recreate_page(GTK_WIDGET(window), page_type,
491  data->key_file, page_group);
492  if (page)
493  {
494  /* Does the page still need to be installed into the window? */
495  if (page->window == nullptr)
496  {
498  gnc_main_window_open_page(window, page);
499  }
500 
501  /* Restore the page name */
502  name = g_key_file_get_string(data->key_file, page_group,
503  PAGE_NAME, &error);
504  if (error)
505  {
506  g_warning("error reading group %s key %s: %s",
507  page_group, PAGE_NAME, error->message);
508  /* Fall through and still show the page. */
509  }
510  else
511  {
512  DEBUG("updating page name for %p to %s.", page, name);
513  main_window_update_page_name(page, name);
514  g_free(name);
515  }
516  }
517  }
518 
519  LEAVE("ok");
520 cleanup:
521  if (error)
522  g_error_free(error);
523  if (page_type)
524  g_free(page_type);
525  g_free(page_group);
526 
527  return (page ? true : false);
528 }
529 
530 static bool
531 intersects_some_monitor(const GdkRectangle& rect)
532 {
533  auto display = gdk_display_get_default();
534  if (!display)
535  return false;
536 
537  int n = gdk_display_get_n_monitors(display);
538  for (int i = 0; i < n; ++i)
539  {
540  auto monitor = gdk_display_get_monitor(display, i);
541  GdkRectangle monitor_geometry;
542  gdk_monitor_get_geometry(monitor, &monitor_geometry);
543  DEBUG("Monitor %d: position (%d,%d), size %dx%d\n", i,
544  monitor_geometry.x, monitor_geometry.y,
545  monitor_geometry.width, monitor_geometry.height);
546  if (gdk_rectangle_intersect(&rect, &monitor_geometry, nullptr))
547  return true;
548  }
549 
550  return false;
551 }
552 
553 static void
554 set_window_geometry(GncMainWindow *window, GncMainWindowSaveData *data, gchar *window_group)
555 {
556  gsize length;
557  GError *error = nullptr;
558  gint *geom = g_key_file_get_integer_list(data->key_file, window_group,
559  WINDOW_GEOMETRY, &length, &error);
560  if (error)
561  {
562  g_warning("error reading group %s key %s: %s",
563  window_group, WINDOW_GEOMETRY, error->message);
564  g_error_free(error);
565  error = nullptr;
566  }
567  else if (length != 2)
568  {
569  g_warning("invalid number of values for group %s key %s",
570  window_group, WINDOW_GEOMETRY);
571  }
572  else
573  {
574  gtk_window_resize(GTK_WINDOW(window), geom[0], geom[1]);
575  DEBUG("window (%p) size %dx%d", window, geom[0], geom[1]);
576  }
577 
578  /* keep the geometry for a test whether the windows position
579  is offscreen */
580  gint *pos = g_key_file_get_integer_list(data->key_file, window_group,
581  WINDOW_POSITION, &length, &error);
582  if (error)
583  {
584  g_warning("error reading group %s key %s: %s",
585  window_group, WINDOW_POSITION, error->message);
586  g_error_free(error);
587  error = nullptr;
588  }
589  else if (length != 2)
590  {
591  g_warning("invalid number of values for group %s key %s",
592  window_group, WINDOW_POSITION);
593  }
594  else if (pos)
595  {
596  // Prevent restoring coordinates if this would move the window off-screen
597  // If missing geom, use height=width=1 to make the intersection check work
598  GdkRectangle geometry{pos[0], pos[1], geom ? geom[0] : 1, geom ? geom[1] : 1};
599  if (intersects_some_monitor(geometry))
600  {
601  gtk_window_move(GTK_WINDOW(window), geometry.x, geometry.y);
602  auto priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
603  priv->pos[0] = geometry.x;
604  priv->pos[1] = geometry.y;
605  DEBUG("window (%p) position (%d,%d)", window, geometry.x, geometry.y);
606  }
607  else
608  {
609  DEBUG("position (%d,%d), size %dx%d is offscreen; will not move",
610  geometry.x, geometry.y, geometry.width, geometry.height);
611  }
612  }
613  g_free(geom);
614  g_free(pos);
615 
616  gboolean max = g_key_file_get_boolean(data->key_file, window_group,
617  WINDOW_MAXIMIZED, &error);
618  if (error)
619  {
620  g_warning("error reading group %s key %s: %s",
621  window_group, WINDOW_MAXIMIZED, error->message);
622  g_error_free(error);
623  error = nullptr;
624  }
625  else if (max)
626  {
627  gtk_window_maximize(GTK_WINDOW(window));
628  }
629 }
630 
639 static void
640 gnc_main_window_restore_window (GncMainWindow *window, GncMainWindowSaveData *data)
641 {
642  GncMainWindowPrivate *priv;
643  GAction *action;
644  gint *order;
645  gsize length;
646  gsize page_start, page_count, i;
647  GError *error = nullptr;
648  GSList *added_page_offsets = nullptr;
649  gint offset = 0;
650 
651  /* Setup */
652  ENTER("window %p, data %p (key file %p, window %d)",
653  window, data, data->key_file, data->window_num);
654  gchar *window_group = g_strdup_printf(WINDOW_STRING, data->window_num + 1);
655 
656  /* Deal with the uncommon case that the state file defines a window
657  * but no pages. An example to get in such a situation can be found
658  * here: https://bugs.gnucash.org/show_bug.cgi?id=436479#c3
659  * If this happens on the first window, we will open an account hierarchy
660  * to avoid confusing the user by presenting a completely empty window.
661  * If it happens on a later window, we'll just skip restoring that window.
662  */
663  if (!g_key_file_has_group (data->key_file, window_group) ||
664  !g_key_file_has_key (data->key_file, window_group, WINDOW_PAGECOUNT, &error))
665  {
666  if (window)
667  {
669  PINFO ("saved state had an empty first main window\n"
670  "an account hierarchy page was added automatically to avoid confusion");
671  }
672  else
673  PINFO ("saved state had an empty main window, skipping restore");
674 
675  goto cleanup;
676  }
677 
678 
679  /* Get this window's notebook info */
680  page_count = g_key_file_get_integer(data->key_file,
681  window_group, WINDOW_PAGECOUNT, &error);
682  if (error)
683  {
684  g_warning("error reading group %s key %s: %s",
685  window_group, WINDOW_PAGECOUNT, error->message);
686  goto cleanup;
687  }
688  if (page_count == 0)
689  {
690  /* Should never happen, but has during alpha testing. Having this
691  * check doesn't hurt anything. */
692  goto cleanup;
693  }
694  page_start = g_key_file_get_integer(data->key_file,
695  window_group, WINDOW_FIRSTPAGE, &error);
696  if (error)
697  {
698  g_warning("error reading group %s key %s: %s",
699  window_group, WINDOW_FIRSTPAGE, error->message);
700  goto cleanup;
701  }
702 
703  /* Build a window if we don't already have one */
704  if (window == nullptr)
705  {
706  DEBUG("Window %d doesn't exist. Creating new window.", data->window_num);
707  DEBUG("active_windows %p.", active_windows);
708  if (active_windows)
709  DEBUG("first window %p.", active_windows->data);
710  window = gnc_main_window_new();
711  }
712 
713  /* Get the window coordinates, etc. */
714  set_window_geometry(window, data, window_group);
715 
716  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
717 
718  // need to add the accelerator keys
719  gnc_add_accelerator_keys_for_menu (GTK_WIDGET(priv->menubar), priv->menubar_model, priv->accel_group);
720 
721  /* Common view menu items */
722  action = gnc_main_window_find_action (window, "ViewToolbarAction");
723  if (action)
724  {
725  GVariant *state = g_action_get_state (G_ACTION(action));
726  gboolean visible = g_variant_get_boolean (state);
727  gboolean desired_visibility = g_key_file_get_boolean (data->key_file, window_group,
728  TOOLBAR_VISIBLE, &error);
729 
730  if (error)
731  {
732  g_warning ("error reading group %s key %s: %s",
733  window_group, TOOLBAR_VISIBLE, error->message);
734  g_error_free (error);
735  error = nullptr;
736  }
737  else if (visible != desired_visibility)
738  {
739  g_action_activate (action, nullptr);
740  }
741  g_variant_unref (state);
742  }
743 
744  action = gnc_main_window_find_action (window, "ViewSummaryAction");
745  if (action)
746  {
747  GVariant *state = g_action_get_state (G_ACTION(action));
748  gboolean visible = g_variant_get_boolean (state);
749  gboolean desired_visibility = g_key_file_get_boolean (data->key_file, window_group,
750  SUMMARYBAR_VISIBLE, &error);
751 
752  if (error)
753  {
754  g_warning ("error reading group %s key %s: %s",
755  window_group, SUMMARYBAR_VISIBLE, error->message);
756  g_error_free (error);
757  error = nullptr;
758  }
759  else if (visible != desired_visibility)
760  {
761  g_action_activate (action, nullptr);
762  }
763  g_variant_unref (state);
764  }
765 
766  action = gnc_main_window_find_action (window, "ViewStatusbarAction");
767  if (action)
768  {
769  GVariant *state = g_action_get_state (G_ACTION(action));
770  gboolean visible = g_variant_get_boolean (state);
771  gboolean desired_visibility = g_key_file_get_boolean (data->key_file, window_group,
772  STATUSBAR_VISIBLE, &error);
773 
774  if (error)
775  {
776  g_warning ("error reading group %s key %s: %s",
777  window_group, STATUSBAR_VISIBLE, error->message);
778  g_error_free (error);
779  error = nullptr;
780  }
781  else if (visible != desired_visibility)
782  {
783  g_action_activate (action, nullptr);
784  }
785  g_variant_unref (state);
786  }
787  priv->restoring_pages = TRUE;
788  /* Now populate the window with pages. */
789  for (i = 0; i < page_count; i++)
790  {
791  data->page_offset = page_start;
792  data->page_num = i;
793  gboolean page_added = gnc_main_window_restore_page (window, data);
794 
795  if (!page_added) // if page not added, increase offset to compensate
796  {
797  offset ++;
798  added_page_offsets = g_slist_append (added_page_offsets,
799  GINT_TO_POINTER(-1));
800  }
801  else
802  added_page_offsets = g_slist_append (added_page_offsets,
803  GINT_TO_POINTER(offset));
804 
805  /* give the page a chance to display */
806  while (gtk_events_pending ())
807  gtk_main_iteration ();
808  }
809  priv->restoring_pages = FALSE;
810  /* Restore page ordering within the notebook. Use +1 notation so the
811  * numbers in the page order match the page sections, at least for
812  * the one window case. */
813  order = g_key_file_get_integer_list (data->key_file, window_group,
814  WINDOW_PAGEORDER, &length, &error);
815  if (error)
816  {
817  g_warning("error reading group %s key %s: %s",
818  window_group, WINDOW_PAGEORDER, error->message);
819  g_error_free(error);
820  error = nullptr;
821  }
822  else if (length != page_count)
823  {
824  g_warning("%s key %s length %" G_GSIZE_FORMAT " differs from window page count %" G_GSIZE_FORMAT,
825  window_group, WINDOW_PAGEORDER, length, page_count);
826  }
827  else
828  {
829  /* Dump any list that might exist */
830  g_list_free(priv->usage_order);
831  priv->usage_order = nullptr;
832 
833  gint default_page_position = -1;
834 
835  /* Now rebuild the list from the key file, skipping pages not added */
836  for (i = 0; i < length; i++)
837  {
838  gint zero_based_page_number = order[i] - 1;
839 
840  gint offset = GPOINTER_TO_INT(g_slist_nth_data (added_page_offsets,
841  zero_based_page_number));
842 
843  if (offset == -1)
844  continue;
845 
846  gpointer page = g_list_nth_data (priv->installed_pages,
847  zero_based_page_number - offset);
848 
849  if (default_page_position == -1)
850  default_page_position = zero_based_page_number - offset;
851 
852  if (page)
853  priv->usage_order = g_list_append (priv->usage_order, page);
854  }
855  gtk_notebook_set_current_page (GTK_NOTEBOOK(priv->notebook),
856  default_page_position);
857 
858  g_signal_emit_by_name (window, "page_changed",
859  g_list_nth_data (priv->usage_order, 0));
860  }
861  if (order)
862  {
863  g_free(order);
864  }
865 
866  LEAVE("window %p", window);
867 cleanup:
868  g_slist_free (added_page_offsets);
869  if (error)
870  g_error_free(error);
871  g_free(window_group);
872  if (window)
873  gtk_widget_show (GTK_WIDGET(window));
874 }
875 
876 void
877 gnc_main_window_restore_all_windows(const GKeyFile *keyfile)
878 {
879  gint i, window_count;
880  GError *error = nullptr;
882 
883  /* We use the same struct for reading and for writing, so we cast
884  away the const. */
885  data.key_file = (GKeyFile *) keyfile;
886  window_count = g_key_file_get_integer(data.key_file, STATE_FILE_TOP,
887  WINDOW_COUNT, &error);
888  if (error)
889  {
890  g_warning("error reading group %s key %s: %s",
891  STATE_FILE_TOP, WINDOW_COUNT, error->message);
892  g_error_free(error);
893  LEAVE("can't read count");
894  return;
895  }
896 
897  /* Restore all state information on the open windows. Window
898  numbers in state file are 1-based. GList indices are 0-based. */
899  gnc_set_busy_cursor (nullptr, TRUE);
900  for (i = 0; i < window_count; i++)
901  {
902  data.window_num = i;
903  auto window{static_cast<GncMainWindow*>(g_list_nth_data(active_windows,
904  i))};
905  gnc_main_window_restore_window(window, &data);
906  }
907  gnc_unset_busy_cursor (nullptr);
908 
909  statusbar_notification_lastmodified();
910 }
911 
912 void
914 {
915  GAction *action;
916 
917  /* The default state should be to have an Account Tree page open
918  * in the window. */
919  DEBUG("no saved state file");
920  if (!window)
921  window = static_cast<GncMainWindow*>(g_list_nth_data(active_windows, 0));
922  gtk_widget_show (GTK_WIDGET(window));
923  action = gnc_main_window_find_action_in_group (window,
924  "gnc-plugin-account-tree-actions",
925  "ViewAccountTreeAction");
926  g_action_activate (action, nullptr);
927 }
928 
938 static void
939 gnc_main_window_save_page (GncPluginPage *page, GncMainWindowSaveData *data)
940 {
941  gchar *page_group;
942  const gchar *plugin_name, *page_name;
943 
944  ENTER("page %p, data %p (key file %p, window %d, page %d)",
945  page, data, data->key_file, data->window_num, data->page_num);
946  plugin_name = gnc_plugin_page_get_plugin_name(page);
947  page_name = gnc_plugin_page_get_page_name(page);
948  if (!plugin_name || !page_name)
949  {
950  LEAVE("not saving invalid page");
951  return;
952  }
953  page_group = g_strdup_printf(PAGE_STRING, data->page_num++);
954  g_key_file_set_string(data->key_file, page_group, PAGE_TYPE, plugin_name);
955  g_key_file_set_string(data->key_file, page_group, PAGE_NAME, page_name);
956 
957  gnc_plugin_page_save_page(page, data->key_file, page_group);
958  g_free(page_group);
959  LEAVE(" ");
960 }
961 
962 
971 static void
972 gnc_main_window_save_window (GncMainWindow *window, GncMainWindowSaveData *data)
973 {
974  GncMainWindowPrivate *priv;
975  GAction *action;
976  gint i, num_pages, coords[4], *order;
977  gboolean maximized, minimized, visible = true;
978  gchar *window_group;
979 
980  /* Setup */
981  ENTER("window %p, data %p (key file %p, window %d)",
982  window, data, data->key_file, data->window_num);
983  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
984 
985  /* Check for bogus window structures. */
986  num_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook));
987  if (0 == num_pages)
988  {
989  LEAVE("empty window %p", window);
990  return;
991  }
992 
993  /* Save this window's notebook info */
994  window_group = g_strdup_printf(WINDOW_STRING, data->window_num++);
995  g_key_file_set_integer(data->key_file, window_group,
996  WINDOW_PAGECOUNT, num_pages);
997  g_key_file_set_integer(data->key_file, window_group,
998  WINDOW_FIRSTPAGE, data->page_num);
999 
1000  /* Save page ordering within the notebook. Use +1 notation so the
1001  * numbers in the page order match the page sections, at least for
1002  * the one window case. */
1003  order = static_cast<int*>(g_malloc(sizeof(gint) * num_pages));
1004  for (i = 0; i < num_pages; i++)
1005  {
1006  gpointer page = g_list_nth_data(priv->usage_order, i);
1007  order[i] = g_list_index(priv->installed_pages, page) + 1;
1008  }
1009  g_key_file_set_integer_list(data->key_file, window_group,
1010  WINDOW_PAGEORDER, order, num_pages);
1011  g_free(order);
1012 
1013  /* Save the window coordinates, etc. */
1014  gtk_window_get_position(GTK_WINDOW(window), &coords[0], &coords[1]);
1015  gtk_window_get_size(GTK_WINDOW(window), &coords[2], &coords[3]);
1016  maximized = (gdk_window_get_state(gtk_widget_get_window ((GTK_WIDGET(window))))
1017  & GDK_WINDOW_STATE_MAXIMIZED) != 0;
1018  minimized = (gdk_window_get_state(gtk_widget_get_window ((GTK_WIDGET(window))))
1019  & GDK_WINDOW_STATE_ICONIFIED) != 0;
1020 
1021  if (minimized)
1022  {
1023  gint *pos = priv->pos;
1024  g_key_file_set_integer_list(data->key_file, window_group,
1025  WINDOW_POSITION, &pos[0], 2);
1026  DEBUG("window minimized (%p) position (%d,%d)", window, pos[0], pos[1]);
1027  }
1028  else
1029  g_key_file_set_integer_list(data->key_file, window_group,
1030  WINDOW_POSITION, &coords[0], 2);
1031  g_key_file_set_integer_list(data->key_file, window_group,
1032  WINDOW_GEOMETRY, &coords[2], 2);
1033  g_key_file_set_boolean(data->key_file, window_group,
1034  WINDOW_MAXIMIZED, maximized);
1035  DEBUG("window (%p) position (%d,%d), size %dx%d, %s", window, coords[0], coords[1],
1036  coords[2], coords[3],
1037  maximized ? "maximized" : "not maximized");
1038 
1039  /* Common view menu items */
1040  action = gnc_main_window_find_action (window, "ViewToolbarAction");
1041  if (action)
1042  {
1043  GVariant *state = g_action_get_state (G_ACTION(action));
1044  visible = g_variant_get_boolean (state);
1045  g_variant_unref (state);
1046  }
1047  g_key_file_set_boolean (data->key_file, window_group,
1048  TOOLBAR_VISIBLE, visible);
1049  action = gnc_main_window_find_action (window, "ViewSummaryAction");
1050  if (action)
1051  {
1052  GVariant *state = g_action_get_state (G_ACTION(action));
1053  visible = g_variant_get_boolean (state);
1054  g_variant_unref (state);
1055  }
1056  g_key_file_set_boolean (data->key_file, window_group,
1057  SUMMARYBAR_VISIBLE, visible);
1058  action = gnc_main_window_find_action (window, "ViewStatusbarAction");
1059  if (action)
1060  {
1061  GVariant *state = g_action_get_state (G_ACTION(action));
1062  visible = g_variant_get_boolean (state);
1063  g_variant_unref (state);
1064  }
1065  g_key_file_set_boolean (data->key_file, window_group,
1066  STATUSBAR_VISIBLE, visible);
1067 
1068  /* Save individual pages in this window */
1069  g_list_foreach (priv->installed_pages, (GFunc)gnc_main_window_save_page, data);
1070 
1071  g_free(window_group);
1072  LEAVE("window %p", window);
1073 }
1074 
1075 void
1077 {
1078  GncMainWindowSaveData data;
1079 
1080  /* Set up the iterator data structures */
1081  data.key_file = keyfile;
1082  data.window_num = 1;
1083  data.page_num = 1;
1084 
1085  g_key_file_set_integer(data.key_file,
1086  STATE_FILE_TOP, WINDOW_COUNT,
1087  g_list_length(active_windows));
1088  /* Dump all state information on the open windows */
1089  g_list_foreach(active_windows, (GFunc)gnc_main_window_save_window, &data);
1090 }
1091 
1092 
1093 gboolean
1094 gnc_main_window_finish_pending (GncMainWindow *window)
1095 {
1096  GncMainWindowPrivate *priv;
1097  GList *item;
1098 
1099  g_return_val_if_fail(GNC_IS_MAIN_WINDOW(window), TRUE);
1100 
1101  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
1102  for (item = priv->installed_pages; item; item = g_list_next(item))
1103  {
1104  if (!gnc_plugin_page_finish_pending(static_cast<GncPluginPage*>(item->data)))
1105  {
1106  return FALSE;
1107  }
1108  }
1109  return TRUE;
1110 }
1111 
1112 
1113 gboolean
1115 {
1116  const GList *windows, *item;
1117 
1118  windows = gnc_gobject_tracking_get_list(GNC_MAIN_WINDOW_NAME);
1119  for (item = windows; item; item = g_list_next(item))
1120  {
1121  if (!gnc_main_window_finish_pending(static_cast<GncMainWindow*>(item->data)))
1122  {
1123  return FALSE;
1124  }
1125  }
1126  if (gnc_gui_refresh_suspended ())
1127  {
1128  gnc_warning_dialog (nullptr, "%s", "An operation is still running, wait for it to complete before quitting.");
1129  return FALSE;
1130  }
1131  return TRUE;
1132 }
1133 
1134 
1145 static gboolean
1146 gnc_main_window_page_exists (GncPluginPage *page)
1147 {
1148  GncMainWindowPrivate *priv;
1149  GList *walker;
1150 
1151  for (walker = active_windows; walker; walker = g_list_next(walker))
1152  {
1153  auto window{static_cast<GncMainWindow*>(walker->data)};
1154  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
1155  if (g_list_find(priv->installed_pages, page))
1156  {
1157  return TRUE;
1158  }
1159  }
1160  return FALSE;
1161 }
1162 
1163 static gboolean auto_save_countdown (GtkWidget *dialog)
1164 {
1165  GtkWidget *label;
1166  gchar *timeoutstr = nullptr;
1167 
1168  /* Stop count down if user closed the dialog since the last time we were called */
1169  if (!GTK_IS_DIALOG (dialog))
1170  return FALSE; /* remove timer */
1171 
1172  /* Stop count down if count down text can't be updated */
1173  label = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), "count-down-label"));
1174  if (!GTK_IS_LABEL (label))
1175  return FALSE; /* remove timer */
1176 
1177  /* Protect against rolling over to MAXUINT */
1178  if (secs_to_save)
1179  --secs_to_save;
1180  DEBUG ("Counting down: %d seconds", secs_to_save);
1181 
1182  timeoutstr = g_strdup_printf (MSG_AUTO_SAVE, secs_to_save);
1183  gtk_label_set_text (GTK_LABEL (label), timeoutstr);
1184  g_free (timeoutstr);
1185 
1186  /* Count down reached 0. Save and close dialog */
1187  if (!secs_to_save)
1188  {
1189  gtk_dialog_response (GTK_DIALOG(dialog), GTK_RESPONSE_APPLY);
1190  return FALSE; /* remove timer */
1191  }
1192 
1193  /* Run another cycle */
1194  return TRUE;
1195 }
1196 
1197 
1207 static gboolean
1208 gnc_main_window_prompt_for_save (GtkWidget *window)
1209 {
1210  QofSession *session;
1211  QofBook *book;
1212  GtkWidget *dialog, *msg_area, *label;
1213  gint response;
1214  const gchar *filename, *tmp;
1215  const gchar *title = _("Save changes to file %s before closing?");
1216  /* This should be the same message as in gnc-file.c */
1217  const gchar *message_hours =
1218  _("If you don't save, changes from the past %d hours and %d minutes will be discarded.");
1219  const gchar *message_days =
1220  _("If you don't save, changes from the past %d days and %d hours will be discarded.");
1221  time64 oldest_change;
1222  gint minutes, hours, days;
1223  guint timer_source = 0;
1224  if (!gnc_current_session_exist())
1225  return FALSE;
1226  session = gnc_get_current_session();
1227  book = qof_session_get_book(session);
1228  if (!qof_book_session_not_saved(book))
1229  return FALSE;
1230  filename = qof_session_get_url(session);
1231  if (!strlen (filename))
1232  filename = _("<unknown>");
1233  if ((tmp = strrchr(filename, '/')) != nullptr)
1234  filename = tmp + 1;
1235 
1236  /* Remove any pending auto-save timeouts */
1237  gnc_autosave_remove_timer(book);
1238 
1239  dialog = gtk_message_dialog_new(GTK_WINDOW(window),
1240  GTK_DIALOG_MODAL,
1241  GTK_MESSAGE_WARNING,
1242  GTK_BUTTONS_NONE,
1243  title,
1244  filename);
1245  oldest_change = qof_book_get_session_dirty_time(book);
1246  minutes = (gnc_time (nullptr) - oldest_change) / 60 + 1;
1247  hours = minutes / 60;
1248  minutes = minutes % 60;
1249  days = hours / 24;
1250  hours = hours % 24;
1251  if (days > 0)
1252  {
1253  gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
1254  message_days, days, hours);
1255  }
1256  else if (hours > 0)
1257  {
1258  gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
1259  message_hours, hours, minutes);
1260  }
1261  else
1262  {
1263  gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
1264  ngettext("If you don't save, changes from the past %d minute will be discarded.",
1265  "If you don't save, changes from the past %d minutes will be discarded.",
1266  minutes), minutes);
1267  }
1268  gtk_dialog_add_buttons(GTK_DIALOG(dialog),
1269  _("Close _Without Saving"), GTK_RESPONSE_CLOSE,
1270  _("_Cancel"), GTK_RESPONSE_CANCEL,
1271  _("_Save"), GTK_RESPONSE_APPLY,
1272  nullptr);
1273  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_APPLY);
1274 
1275  /* If requested by the user, add a timeout to the question to save automatically
1276  * if the user doesn't answer after a chosen number of seconds.
1277  */
1278  if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_CLOSE_EXPIRES))
1279  {
1280  gchar *timeoutstr = nullptr;
1281 
1282  secs_to_save = gnc_prefs_get_int (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_CLOSE_WAIT_TIME);
1283  timeoutstr = g_strdup_printf (MSG_AUTO_SAVE, secs_to_save);
1284  label = GTK_WIDGET(gtk_label_new (timeoutstr));
1285  g_free (timeoutstr);
1286  gtk_widget_show (label);
1287 
1288  msg_area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG(dialog));
1289  gtk_box_pack_end (GTK_BOX(msg_area), label, TRUE, TRUE, 0);
1290  g_object_set (G_OBJECT (label), "xalign", 0.0, nullptr);
1291 
1292  g_object_set_data (G_OBJECT (dialog), "count-down-label", label);
1293  timer_source = g_timeout_add_seconds (1, (GSourceFunc)auto_save_countdown, dialog);
1294  }
1295 
1296  response = gtk_dialog_run (GTK_DIALOG (dialog));
1297  if (timer_source)
1298  g_source_remove (timer_source);
1299  gtk_widget_destroy(dialog);
1300 
1301  switch (response)
1302  {
1303  case GTK_RESPONSE_APPLY:
1304  gnc_file_save (GTK_WINDOW (window));
1305  return FALSE;
1306 
1307  case GTK_RESPONSE_CLOSE:
1309  return FALSE;
1310 
1311  default:
1312  return TRUE;
1313  }
1314 }
1315 
1316 
1317 static void
1318 gnc_main_window_add_plugin (gpointer plugin,
1319  gpointer window)
1320 {
1321  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
1322  g_return_if_fail (GNC_IS_PLUGIN (plugin));
1323 
1324  ENTER(" ");
1325  gnc_plugin_add_to_window (GNC_PLUGIN (plugin),
1326  GNC_MAIN_WINDOW (window),
1327  window_type);
1328  LEAVE(" ");
1329 }
1330 
1331 static void
1332 gnc_main_window_remove_plugin (gpointer plugin,
1333  gpointer window)
1334 {
1335  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
1336  g_return_if_fail (GNC_IS_PLUGIN (plugin));
1337 
1338  ENTER(" ");
1339  gnc_plugin_remove_from_window (GNC_PLUGIN (plugin),
1340  GNC_MAIN_WINDOW (window),
1341  window_type);
1342  LEAVE(" ");
1343 }
1344 
1345 
1346 static gboolean
1347 gnc_main_window_timed_quit (gpointer dummy)
1348 {
1349  if (gnc_file_save_in_progress())
1350  return TRUE;
1351 
1352  gnc_shutdown (0);
1353  return FALSE;
1354 }
1355 
1356 static gboolean
1357 gnc_main_window_quit(GncMainWindow *window)
1358 {
1359  QofSession *session;
1360  gboolean needs_save, do_shutdown = TRUE;
1361  if (gnc_current_session_exist())
1362  {
1363  session = gnc_get_current_session();
1364  needs_save =
1366  !gnc_file_save_in_progress();
1367  do_shutdown = !needs_save ||
1368  (needs_save &&
1369  !gnc_main_window_prompt_for_save(GTK_WIDGET(window)));
1370  }
1371  if (do_shutdown)
1372  {
1373  GList *w, *next;
1374 
1375  /* This is not a typical list iteration. There is a possibility
1376  * that the window may be removed from the active_windows list so
1377  * we have to cache the 'next' pointer before executing any code
1378  * in the loop. */
1379  for (w = active_windows; w; w = next)
1380  {
1381  GncMainWindowPrivate *priv;
1382  GncMainWindow *window = static_cast<GncMainWindow*>(w->data);
1383 
1384  next = g_list_next (w);
1385 
1386  window->window_quitting = TRUE; //set window_quitting on all windows
1387 
1388  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
1389 
1390  // if there are no pages destroy window
1391  if (priv->installed_pages == NULL)
1392  gtk_widget_destroy (GTK_WIDGET(window));
1393  }
1394  /* remove the preference callbacks from the main window */
1395  gnc_main_window_remove_prefs (window);
1396  g_timeout_add(250, gnc_main_window_timed_quit, nullptr);
1397  return TRUE;
1398  }
1399  return FALSE;
1400 }
1401 
1402 gboolean
1403 gnc_main_window_is_quitting (GncMainWindow *window)
1404 {
1405  g_return_val_if_fail(GNC_IS_MAIN_WINDOW(window), FALSE);
1406  return window->window_quitting;
1407 }
1408 
1409 static gboolean
1410 gnc_main_window_delete_event (GtkWidget *window,
1411  GdkEvent *event,
1412  gpointer user_data)
1413 {
1414  static gboolean already_dead = FALSE;
1415 
1416  if (already_dead)
1417  return TRUE;
1418 
1419  if (gnc_list_length_cmp (active_windows, 1) > 0)
1420  {
1421  gint response;
1422  GtkWidget *dialog;
1423  gchar *message = _("This window is closing and will not be restored.");
1424 
1425  dialog = gtk_message_dialog_new (GTK_WINDOW (window),
1426  GTK_DIALOG_DESTROY_WITH_PARENT,
1427  GTK_MESSAGE_QUESTION,
1428  GTK_BUTTONS_NONE,
1429  "%s", _("Close Window?"));
1430  gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG(dialog),
1431  "%s", message);
1432 
1433  gtk_dialog_add_buttons (GTK_DIALOG(dialog),
1434  _("_Cancel"), GTK_RESPONSE_CANCEL,
1435  _("_OK"), GTK_RESPONSE_YES,
1436  (gchar *)NULL);
1437  gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_YES);
1438  response = gnc_dialog_run (GTK_DIALOG(dialog), GNC_PREF_WARN_CLOSING_WINDOW_QUESTION);
1439  gtk_widget_destroy (dialog);
1440 
1441  if (response == GTK_RESPONSE_CANCEL)
1442  return TRUE;
1443  }
1444 
1445  if (!gnc_main_window_finish_pending(GNC_MAIN_WINDOW(window)))
1446  {
1447  /* Don't close the window. */
1448  return TRUE;
1449  }
1450 
1451  if (gnc_list_length_cmp (active_windows, 1) > 0)
1452  return FALSE;
1453 
1454  already_dead = gnc_main_window_quit(GNC_MAIN_WINDOW(window));
1455  return TRUE;
1456 }
1457 
1458 
1478 static void
1479 gnc_main_window_event_handler (QofInstance *entity, QofEventId event_type,
1480  gpointer user_data, gpointer event_data)
1481 {
1482  GncMainWindow *window;
1483  GncMainWindowPrivate *priv;
1484  GncPluginPage *page;
1485  GList *item, *next;
1486 
1487  /* hard failures */
1488  g_return_if_fail(GNC_IS_MAIN_WINDOW(user_data));
1489 
1490  /* soft failures */
1491  if (!QOF_CHECK_TYPE(entity, QOF_ID_BOOK))
1492  return;
1493  if (event_type != QOF_EVENT_DESTROY)
1494  return;
1495 
1496  ENTER("entity %p, event %d, window %p, event data %p",
1497  entity, event_type, user_data, event_data);
1498  window = GNC_MAIN_WINDOW(user_data);
1499  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
1500 
1501  /* This is not a typical list iteration. We're removing while
1502  * we iterate, so we have to cache the 'next' pointer before
1503  * executing any code in the loop. */
1504  for (item = priv->installed_pages; item; item = next)
1505  {
1506  next = g_list_next(item);
1507  page = GNC_PLUGIN_PAGE(item->data);
1508  if (gnc_plugin_page_has_book (page, (QofBook *)entity))
1510  }
1511 
1512  if (GTK_IS_WIDGET(window) && window->window_quitting)
1513  gtk_widget_destroy (GTK_WIDGET(window));
1514 
1515  LEAVE(" ");
1516 }
1517 
1518 
1535 static gchar *
1536 gnc_main_window_generate_title (GncMainWindow *window)
1537 {
1538  GncMainWindowPrivate *priv;
1539  GncPluginPage *page;
1540  QofBook *book;
1541  gboolean immutable;
1542  gchar *filename = nullptr;
1543  const gchar *uri = nullptr;
1544  const gchar *dirty = "";
1545  const gchar *readonly_text = nullptr;
1546  gchar *readonly;
1547  gchar *title;
1548 
1549  if (gnc_current_session_exist())
1550  {
1551  uri = qof_session_get_url (gnc_get_current_session ());
1552  book = gnc_get_current_book();
1553  if (qof_book_session_not_saved (book))
1554  dirty = "*";
1555  if (qof_book_is_readonly(book))
1556  {
1557  /* Translators: This string is shown in the window title if this
1558  document is, well, read-only. */
1559  readonly_text = _("(read-only)");
1560  }
1561  }
1562  readonly = (readonly_text != nullptr)
1563  ? g_strdup_printf(" %s", readonly_text)
1564  : g_strdup("");
1565 
1566  if (!uri || g_strcmp0 (uri, "") == 0)
1567  filename = g_strdup(_("Unsaved Book"));
1568  else
1569  {
1570  if (gnc_uri_targets_local_fs (uri))
1571  {
1572  /* The filename is a true file.
1573  The Gnome HIG 2.0 recommends only the file name (no path) be used. (p15) */
1574  gchar *path = gnc_uri_get_path ( uri );
1575  filename = g_path_get_basename ( path );
1576  g_free ( path );
1577  }
1578  else
1579  {
1580  /* The filename is composed of database connection parameters.
1581  For this we will show access_method://username@database[:port] */
1582  filename = gnc_uri_normalize_uri (uri, FALSE);
1583  }
1584  }
1585 
1586  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
1587  page = priv->current_page;
1588  if (page)
1589  {
1590  /* The Gnome HIG 2.0 recommends the application name not be used. (p16)
1591  but several developers prefer to use it anyway. */
1592  title = g_strdup_printf("%s%s%s - %s - GnuCash", dirty, filename, readonly,
1594  }
1595  else
1596  {
1597  title = g_strdup_printf("%s%s%s - GnuCash", dirty, filename, readonly);
1598  }
1599  /* Update the menus based upon whether this is an "immutable" page. */
1600  immutable = page &&
1601  g_object_get_data (G_OBJECT (page), PLUGIN_PAGE_IMMUTABLE);
1602  gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
1603  immutable_page_actions,
1604  !immutable);
1605  /* Trigger sensitivity updtates of other actions such as Save/Revert */
1606  g_signal_emit_by_name (window, "page_changed", page);
1607  g_free( filename );
1608  g_free(readonly);
1609 
1610  return title;
1611 }
1612 
1613 
1623 static void
1624 gnc_main_window_update_title (GncMainWindow *window)
1625 {
1626  gchar *title;
1627 
1628  title = gnc_main_window_generate_title(window);
1629  gtk_window_set_title(GTK_WINDOW(window), title);
1630  g_free(title);
1631 }
1632 
1633 static void
1634 gnc_main_window_update_all_titles (void)
1635 {
1636  g_list_foreach(active_windows,
1637  (GFunc)gnc_main_window_update_title,
1638  nullptr);
1639 }
1640 
1641 /* Callback function invoked when the user clicks on a GtkNotebook tab.
1642  *
1643  * This function is needed to make it possible to close a tab
1644  * when it's clicked using the middle mouse button;
1645  * there does not seem to be a way to do this with GtkNotebook natively.
1646  *
1647  * @param widget The event box in the tab, which was clicked.
1648  *
1649  * @param event The event parameter describing where on the screen
1650  * the mouse was pointing when clicked, type of click, modifiers,
1651  * etc.
1652  *
1653  * @param page This is the GncPluginPage corresponding to the tab.
1654  *
1655  * @return Returns TRUE if this was a middle-click, meaning Gnucash
1656  * handled the click.
1657  */
1658 static gboolean
1659 gnc_tab_clicked_cb(GtkWidget *widget, GdkEventButton *event, GncPluginPage *page) {
1660  if (event->type == GDK_BUTTON_PRESS && event->button == 2)
1661  {
1663  return TRUE;
1664  }
1665  return FALSE;
1666 }
1667 
1668 static void
1669 gnc_main_window_book_dirty_cb (QofBook *book,
1670  gboolean dirty,
1671  gpointer user_data)
1672 {
1673  gnc_main_window_update_all_titles();
1674 
1675  /* Auto-save feature */
1676  gnc_autosave_dirty_handler(book, dirty);
1677 }
1678 
1679 static void
1680 gnc_main_window_attach_to_book (QofSession *session)
1681 {
1682  QofBook *book;
1683 
1684  g_return_if_fail(session);
1685 
1686  book = qof_session_get_book(session);
1687  qof_book_set_dirty_cb(book, gnc_main_window_book_dirty_cb, nullptr);
1688  gnc_main_window_update_all_titles();
1689 #ifndef MAC_INTEGRATION
1690  gnc_main_window_update_all_menu_items();
1691 #endif
1692 }
1693 
1694 static guint gnc_statusbar_notification_messageid = 0;
1695 //#define STATUSBAR_NOTIFICATION_AUTOREMOVAL
1696 #ifdef STATUSBAR_NOTIFICATION_AUTOREMOVAL
1697 /* Removes the statusbar notification again that has been pushed to the
1698  * statusbar by generate_statusbar_lastmodified_message. */
1699 static gboolean statusbar_notification_off(gpointer user_data_unused)
1700 {
1701  GncMainWindow *mainwindow = GNC_MAIN_WINDOW (gnc_ui_get_main_window (nullptr));
1702  //g_warning("statusbar_notification_off\n");
1703  if (gnc_statusbar_notification_messageid == 0)
1704  return FALSE;
1705 
1706  if (mainwindow)
1707  {
1708  GtkWidget *statusbar = gnc_main_window_get_statusbar(GNC_WINDOW(mainwindow));
1709  gtk_statusbar_remove(GTK_STATUSBAR(statusbar), 0, gnc_statusbar_notification_messageid);
1710  gnc_statusbar_notification_messageid = 0;
1711  }
1712  else
1713  {
1714  g_warning("oops, no GncMainWindow obtained\n");
1715  }
1716  return FALSE; // should not be called again
1717 }
1718 #endif // STATUSBAR_NOTIFICATION_AUTOREMOVAL
1719 
1720 /* Creates a statusbar message stating the last modification time of the opened
1721  * data file. */
1722 static gchar *generate_statusbar_lastmodified_message()
1723 {
1724  gchar *message = nullptr;
1725  const gchar *uri = nullptr;
1726 
1727  if (gnc_current_session_exist())
1728  {
1729  uri = qof_session_get_url (gnc_get_current_session ());
1730  }
1731 
1732  if (!(uri && strlen (uri)))
1733  return nullptr;
1734  else
1735  {
1736  if (gnc_uri_targets_local_fs (uri))
1737  {
1738  /* The filename is a true file. */
1739  gchar *filepath = gnc_uri_get_path ( uri );
1740  gchar *filename = g_path_get_basename ( filepath );
1741  GFile *file = g_file_new_for_uri (uri);
1742  GFileInfo *info = g_file_query_info (file,
1743  G_FILE_ATTRIBUTE_TIME_MODIFIED,
1744  G_FILE_QUERY_INFO_NONE,
1745  NULL, NULL);
1746 
1747  if (info && g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
1748  {
1749  // Access the mtime information through stat(2)
1750  struct stat statbuf;
1751  int r = stat(filepath, &statbuf);
1752  if (r == 0)
1753  {
1754  /* Translators: This is the date and time that is shown in
1755  the status bar after opening a file: The date and time of
1756  last modification. The string is a format string using
1757  boost::date_time's format flags, see the boost docs for an
1758  explanation of the modifiers. */
1759  char *time_string = gnc_print_time64(statbuf.st_mtime,
1760  _("Last modified on %a, %b %d, %Y at %I:%M %p"));
1761  //g_warning("got time %ld, str=%s\n", mtime, time_string);
1762  /* Translators: This message appears in the status bar after opening the file. */
1763  message = g_strdup_printf(_("File %s opened. %s"),
1764  filename, time_string);
1765  free(time_string);
1766  }
1767  else
1768  {
1769  g_warning("Unable to read mtime for file %s\n", filepath);
1770  // message is still nullptr
1771  }
1772  }
1773  g_free(filename);
1774  g_free(filepath);
1775  g_object_unref (info);
1776  g_object_unref (file);
1777  }
1778  // If the URI is not a file but a database, we can maybe also show
1779  // something useful, but I have no idea how to obtain this information.
1780  }
1781  return message;
1782 }
1783 
1784 static void
1785 statusbar_notification_lastmodified()
1786 {
1787  // First look up the first GncMainWindow to set the statusbar there
1788  GList *iter;
1789  GtkWidget *widget = nullptr;
1790  for (iter = active_windows; iter && !(widget && GNC_IS_MAIN_WINDOW(widget));
1791  iter = g_list_next(iter))
1792  {
1793  widget = static_cast<GtkWidget*>(iter->data);
1794  }
1795  if (widget && GNC_IS_MAIN_WINDOW(widget))
1796  {
1797  // Ok, we found a mainwindow where we can set a statusbar message
1798  GncMainWindow *mainwindow = GNC_MAIN_WINDOW(widget);
1799  GtkWidget *statusbar = gnc_main_window_get_statusbar(GNC_WINDOW(mainwindow));
1800 
1801  gchar *msg = generate_statusbar_lastmodified_message();
1802  if (msg)
1803  {
1804  gnc_statusbar_notification_messageid = gtk_statusbar_push(GTK_STATUSBAR(statusbar), 0, msg);
1805  }
1806  g_free(msg);
1807 
1808 #ifdef STATUSBAR_NOTIFICATION_AUTOREMOVAL
1809  // Also register a timeout callback to remove that statusbar
1810  // notification again after 10 seconds
1811  g_timeout_add(10 * 1000, statusbar_notification_off, nullptr); // maybe not needed anyway?
1812 #endif
1813  }
1814  else
1815  {
1816  g_warning("uh oh, no GNC_IS_MAIN_WINDOW\n");
1817  }
1818 }
1819 
1820 
1824 {
1826  gchar *action_name;
1827 
1829  gchar *label;
1830 
1832  gboolean visible;
1833 
1835  gint index;
1836 };
1837 
1838 #ifndef MAC_INTEGRATION
1839 
1852 static void
1853 gnc_main_window_update_one_menu_action (GncMainWindow *window,
1854  struct menu_update *data)
1855 {
1856  GncMainWindowPrivate *priv;
1857  GncMenuModelSearch *gsm = g_new0 (GncMenuModelSearch, 1);
1858  GMenuItem *item;
1859  gint pos;
1860 
1861  ENTER("window %p, action %s, label %s, index %d, visible %d", window,
1862  data->action_name, data->label, data->index, data->visible);
1863 
1864  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
1865 
1866  gsm->search_action_label = nullptr;
1867  gsm->search_action_name = "WindowsPlaceholder1"; // placeholder
1868  gsm->search_action_target = nullptr;
1869 
1870  if (!gnc_menubar_model_find_item (priv->menubar_model, gsm))
1871  {
1872  LEAVE("Could not find placeholder 'WindowsPlaceholder1' for windows entries");
1873  g_free (gsm);
1874  return;
1875  }
1876 
1877  pos = gsm->index + data->index + 1;
1878 
1879  if (!data->visible)
1880  {
1881  if (pos < g_menu_model_get_n_items (gsm->model))
1882  g_menu_remove (G_MENU(gsm->model), pos);
1883 
1884  g_free (gsm);
1885  LEAVE(" ");
1886  return;
1887  }
1888 
1889  item = g_menu_item_new (data->label, "mainwin.WindowAction");
1890  g_menu_item_set_attribute (item, G_MENU_ATTRIBUTE_TARGET, "i", data->index);
1891 
1892  if (pos < g_menu_model_get_n_items (gsm->model))
1893  g_menu_remove (G_MENU(gsm->model), pos);
1894  g_menu_insert_item (G_MENU(gsm->model), pos, item);
1895  g_object_unref (item);
1896 
1897  g_free (gsm);
1898  LEAVE(" ");
1899 }
1900 
1913 static void
1914 gnc_main_window_update_radio_button (GncMainWindow *window)
1915 {
1916  GAction *action;
1917  gsize index;
1918 
1919  ENTER("window %p", window);
1920 
1921  /* Show the new entry in all windows. */
1922  index = g_list_index (active_windows, window);
1923 
1924  if (index >= gnc_main_window_max_number)
1925  {
1926  LEAVE("window %" G_GSIZE_FORMAT ", only %d actions", index, gnc_main_window_max_number);
1927  return;
1928  }
1929 
1930  action = g_action_map_lookup_action (G_ACTION_MAP(window),
1931  "WindowAction");
1932 
1933  /* Block the signal so as not to affect window ordering (top to
1934  * bottom) on the screen */
1935  g_signal_handlers_block_by_func (G_OBJECT(action),
1936  (gpointer)gnc_main_window_cmd_window_raise,
1937  window);
1938 
1939  DEBUG("blocked signal on action %p, window %p", action, window);
1940  g_action_change_state (G_ACTION(action), g_variant_new_int32 (index));
1941 
1942  g_signal_handlers_unblock_by_func (G_OBJECT(action),
1943  (gpointer)gnc_main_window_cmd_window_raise,
1944  window);
1945  LEAVE(" ");
1946 }
1947 
1960 static void
1961 gnc_main_window_update_menu_item (GncMainWindow *window)
1962 {
1963  struct menu_update data;
1964  gchar **strings, *title, *expanded;
1965  gsize index;
1966 
1967  ENTER("window %p", window);
1968 
1969  index = g_list_index (active_windows, window);
1970 
1972  {
1973  LEAVE("skip window %" G_GSIZE_FORMAT " (only %d entries)", index, gnc_main_window_max_number);
1974  return;
1975  }
1976 
1977  /* Figure out the label name. Add the accelerator if possible. */
1978  title = gnc_main_window_generate_title (window);
1979  strings = g_strsplit (title, "_", 0);
1980  g_free (title);
1981  expanded = g_strjoinv ("__", strings);
1983  {
1984  data.label = g_strdup_printf ("_%" G_GSIZE_FORMAT " %s", (index + 1) % 10, expanded);
1985  g_free (expanded);
1986  }
1987  else
1988  {
1989  data.label = expanded;
1990  }
1991  g_strfreev (strings);
1992 
1993  data.visible = TRUE;
1994  data.action_name = g_strdup_printf ("Window%" G_GSIZE_FORMAT "Action", index);
1995  data.index = index;
1996 
1997  g_list_foreach (active_windows,
1998  (GFunc)gnc_main_window_update_one_menu_action,
1999  &data);
2000 
2001  g_free (data.action_name);
2002  g_free (data.label);
2003 
2004  LEAVE(" ");
2005 }
2006 #endif /* !MAC_INTEGRATION */
2007 
2016 #ifndef MAC_INTEGRATION
2017 static void
2018 gnc_main_window_update_all_menu_items (void)
2019 {
2020  struct menu_update data;
2021 
2022  ENTER("");
2023  /* First update the entries for all existing windows */
2024  g_list_foreach (active_windows,
2025  (GFunc)gnc_main_window_update_menu_item,
2026  nullptr);
2027 
2028  g_list_foreach (active_windows,
2029  (GFunc)gnc_main_window_update_radio_button,
2030  nullptr);
2031 
2032  /* Now hide any entries that aren't being used. */
2033  data.visible = FALSE;
2034  // need i to descend from gnc_main_window_max_number
2035  for (gsize i = gnc_main_window_max_number - 1; i > 0 && i >= g_list_length (active_windows); i--)
2036  {
2037  data.index = i;
2038  data.action_name = g_strdup_printf ("Window%dAction", data.index);
2039  data.label = g_strdup_printf ("mywin%" G_GSIZE_FORMAT, i % 10);
2040 
2041  g_list_foreach (active_windows,
2042  (GFunc)gnc_main_window_update_one_menu_action,
2043  &data);
2044 
2045  g_free (data.action_name);
2046  g_free (data.label);
2047  }
2048  LEAVE(" ");
2049 }
2050 #endif /* !MAC_INTEGRATION */
2051 
2063 static void
2064 gnc_main_window_update_tab_close_one_page (GncPluginPage *page,
2065  gpointer user_data)
2066 {
2067  auto new_value{static_cast<gboolean*>(user_data)};
2068  ENTER("page %p, visible %d", page, *new_value);
2069  auto close_button{static_cast<GtkWidget*>(g_object_get_data(G_OBJECT (page), PLUGIN_PAGE_CLOSE_BUTTON))};
2070  if (!close_button)
2071  {
2072  LEAVE("no close button");
2073  return;
2074  }
2075 
2076  if (*new_value)
2077  gtk_widget_show (close_button);
2078  else
2079  gtk_widget_hide (close_button);
2080  LEAVE(" ");
2081 }
2082 
2083 
2096 static void
2097 gnc_main_window_update_tab_close (gpointer prefs, gchar *pref, gpointer user_data)
2098 {
2099  gboolean new_value;
2100 
2101  ENTER(" ");
2102  new_value = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SHOW_CLOSE_BUTTON);
2104  gnc_main_window_update_tab_close_one_page,
2105  &new_value);
2106  LEAVE(" ");
2107 }
2108 
2109 
2118 static void
2119 gnc_main_window_update_tab_color_one_page (GncPluginPage *page,
2120  gpointer user_data)
2121 {
2122  const gchar *color_string;
2123 
2124  ENTER("page %p", page);
2125  color_string = gnc_plugin_page_get_page_color(page);
2126  main_window_update_page_color (page, color_string);
2127  LEAVE(" ");
2128 }
2129 
2130 
2141 static void
2142 gnc_main_window_update_tab_color (gpointer gsettings, gchar *pref, gpointer user_data)
2143 {
2144  ENTER(" ");
2145  g_return_if_fail(GNC_IS_MAIN_WINDOW(user_data));
2146  auto window{static_cast<GncMainWindow*>(user_data)};
2147  auto priv{GNC_MAIN_WINDOW_GET_PRIVATE(window)};
2148  if (g_strcmp0 (GNC_PREF_TAB_COLOR, pref) == 0)
2149  priv->show_color_tabs = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_COLOR);
2150  gnc_main_window_foreach_page (gnc_main_window_update_tab_color_one_page, window);
2151  LEAVE(" ");
2152 }
2153 
2154 
2158 typedef struct
2159 {
2160  gint tab_width;
2161  gboolean tabs_left_right;
2162 } TabWidth;
2163 
2164 static TabWidth *
2165 populate_tab_width_struct (void)
2166 {
2167  TabWidth *tw;
2168 
2169  tw = g_new0 (TabWidth, 1);
2170  tw->tab_width = gnc_prefs_get_float (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_WIDTH);
2171  tw->tabs_left_right = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT) ||
2172  gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT);
2173 
2174  return tw;
2175 }
2176 
2198 static void
2199 gnc_main_window_set_tab_ellipsize (GtkWidget *label, gint tab_width, gboolean tab_left_right)
2200 {
2201  const gchar *lab_text = gtk_label_get_text (GTK_LABEL(label));
2202 
2203  if (tab_width != 0)
2204  {
2205  gint text_length = g_utf8_strlen (lab_text, -1);
2206  if (text_length < tab_width)
2207  {
2208  if (tab_left_right) // tabs position is left or right
2209  gtk_label_set_width_chars (GTK_LABEL(label), tab_width);
2210  else // tabs position is top or bottom
2211  gtk_label_set_width_chars (GTK_LABEL(label), text_length);
2212 
2213  gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_NONE);
2214  }
2215  else
2216  {
2217  gtk_label_set_width_chars (GTK_LABEL(label), tab_width);
2218  gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
2219  }
2220  }
2221  else
2222  {
2223  gtk_label_set_width_chars (GTK_LABEL(label), 15);
2224  gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_NONE);
2225  }
2226 }
2227 
2228 
2239 static void
2240 gnc_main_window_update_tab_width_one_page (GncPluginPage *page,
2241  gpointer user_data)
2242 {
2243  auto tw{static_cast<TabWidth*>(user_data)};
2244 
2245  ENTER("page %p, tab width %d, tabs on left or right %d",
2246  page, tw->tab_width, tw->tabs_left_right);
2247 
2248  auto label{static_cast<GtkWidget *>(g_object_get_data(G_OBJECT (page), PLUGIN_PAGE_TAB_LABEL))};
2249  if (!label)
2250  {
2251  LEAVE("no label");
2252  return;
2253  }
2254  gnc_main_window_set_tab_ellipsize (label, tw->tab_width, tw->tabs_left_right);
2255  LEAVE(" ");
2256 }
2257 
2258 
2271 static void
2272 gnc_main_window_update_tab_width (gpointer prefs, gchar *pref, gpointer user_data)
2273 {
2274  TabWidth *tw;
2275 
2276  ENTER(" ");
2277 
2278  tw = populate_tab_width_struct ();
2279 
2280  gnc_main_window_foreach_page (gnc_main_window_update_tab_width_one_page, tw);
2281  g_free (tw);
2282 
2283  LEAVE(" ");
2284 }
2285 
2286 
2287 /************************************************************
2288  * Tab Label Implementation *
2289  ************************************************************/
2290 static gboolean
2291 main_window_find_tab_items (GncMainWindow *window,
2292  GncPluginPage *page,
2293  GtkWidget **label_p,
2294  GtkWidget **entry_p)
2295 {
2296  GncMainWindowPrivate *priv;
2297  GtkWidget *tab_hbox, *widget, *tab_widget;
2298  GList *children, *tmp;
2299 
2300  ENTER("window %p, page %p, label_p %p, entry_p %p",
2301  window, page, label_p, entry_p);
2302  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
2303  *label_p = *entry_p = nullptr;
2304 
2305  if (!page->notebook_page)
2306  {
2307  LEAVE("invalid notebook_page");
2308  return FALSE;
2309  }
2310 
2311  tab_widget = gtk_notebook_get_tab_label(GTK_NOTEBOOK(priv->notebook),
2312  page->notebook_page);
2313 
2314  // Walk through children to find the box containing label+entry
2315  tab_hbox = tab_widget;
2316  while (tab_hbox) {
2317  if (g_strcmp0(gtk_widget_get_name(tab_hbox), "tab-content") == 0) {
2318  break;
2319  }
2320  GList* _children = gtk_container_get_children(GTK_CONTAINER(tab_hbox));
2321  tab_hbox = _children ? GTK_WIDGET(_children->data) : nullptr;
2322  g_list_free(_children);
2323  }
2324 
2325  if (!GTK_IS_BOX(tab_hbox))
2326  {
2327  PWARN ("Unknown widget for tab label %p", tab_widget);
2328  return FALSE;
2329  }
2330 
2331  children = gtk_container_get_children(GTK_CONTAINER(tab_hbox));
2332  for (tmp = children; tmp; tmp = g_list_next(tmp))
2333  {
2334  widget = static_cast<GtkWidget*>(tmp->data);
2335  if (GTK_IS_LABEL(widget))
2336  {
2337  *label_p = widget;
2338  }
2339  else if (GTK_IS_ENTRY(widget))
2340  {
2341  *entry_p = widget;
2342  }
2343  }
2344  g_list_free(children);
2345 
2346  LEAVE("label %p, entry %p", *label_p, *entry_p);
2347  return (*label_p && *entry_p);
2348 }
2349 
2350 static gboolean
2351 main_window_find_tab_widget (GncMainWindow *window,
2352  GncPluginPage *page,
2353  GtkWidget **widget_p)
2354 {
2355  GncMainWindowPrivate *priv;
2356 
2357  ENTER("window %p, page %p, widget %p",
2358  window, page, widget_p);
2359  *widget_p = nullptr;
2360 
2361  if (!page->notebook_page)
2362  {
2363  LEAVE("invalid notebook_page");
2364  return FALSE;
2365  }
2366 
2367  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
2368  *widget_p = gtk_notebook_get_tab_label(GTK_NOTEBOOK(priv->notebook),
2369  page->notebook_page);
2370 
2371  LEAVE("widget %p", *widget_p);
2372  return TRUE;
2373 }
2374 
2375 void
2377  const gchar *long_name_in)
2378 {
2379  GtkWidget *tab_widget;
2380 
2381  ENTER(" ");
2382 
2383  if ((long_name_in == nullptr) || (*long_name_in == '\0'))
2384  {
2385  LEAVE("no string");
2386  return;
2387  }
2388  gchar *long_name = g_strstrip (g_strdup (long_name_in));
2389  const gchar *old_long_name = gnc_plugin_page_get_page_long_name (page);
2390 
2391  /* Optimization, if the long_name hasn't changed, don't update X. */
2392  if (*long_name == '\0' || strcmp (long_name, old_long_name) == 0)
2393  {
2394  g_free (long_name);
2395  LEAVE("empty string or name unchanged");
2396  return;
2397  }
2398 
2399  gnc_plugin_page_set_page_long_name (page, long_name);
2400 
2401  GncMainWindow *window = GNC_MAIN_WINDOW(page->window);
2402  if (!window)
2403  {
2404  g_free (long_name);
2405  LEAVE("no window widget available");
2406  return;
2407  }
2408 
2409  /* Update the notebook tab tooltip */
2410  if (main_window_find_tab_widget (window, page, &tab_widget))
2411  gtk_widget_set_tooltip_text (tab_widget, long_name);
2412 
2413  g_free (long_name);
2414  LEAVE("");
2415 }
2416 
2417 void
2419  const gchar *name_in)
2420 {
2421  GncMainWindow *window;
2422  GncMainWindowPrivate *priv;
2423  GtkWidget *label, *entry;
2424  gchar *name;
2425  TabWidth *tw;
2426 
2427  ENTER(" ");
2428 
2429  if ((name_in == nullptr) || (*name_in == '\0'))
2430  {
2431  LEAVE("no string");
2432  return;
2433  }
2434  name = g_strstrip(g_strdup(name_in));
2435 
2436  /* Optimization, if the name hasn't changed, don't update X. */
2437  if (*name == '\0' || 0 == strcmp(name, gnc_plugin_page_get_page_name(page)))
2438  {
2439  g_free(name);
2440  LEAVE("empty string or name unchanged");
2441  return;
2442  }
2443 
2444  /* Update the plugin */
2445  gnc_plugin_page_set_page_name(page, name);
2446 
2447  /* Update the notebook tab */
2448  window = GNC_MAIN_WINDOW(page->window);
2449  if (!window)
2450  {
2451  g_free(name);
2452  LEAVE("no window widget available");
2453  return;
2454  }
2455 
2456  if (main_window_find_tab_items(window, page, &label, &entry))
2457  gtk_label_set_text(GTK_LABEL(label), name);
2458 
2459  /* Adjust the label width for new text */
2460  tw = populate_tab_width_struct ();
2461  gnc_main_window_update_tab_width_one_page (page, tw);
2462  g_free (tw);
2463 
2464  /* Update the notebook menu */
2465  if (page->notebook_page)
2466  {
2467  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
2468  label = gtk_notebook_get_menu_label (GTK_NOTEBOOK(priv->notebook),
2469  page->notebook_page);
2470  gtk_label_set_text(GTK_LABEL(label), name);
2471  }
2472 
2473  /* Force an update of the window title */
2474  gnc_main_window_update_title(window);
2475  g_free(name);
2476  LEAVE("done");
2477 }
2478 
2479 
2480 void
2482  const gchar *color_in)
2483 {
2484  GncMainWindow *window;
2485  GncMainWindowPrivate *priv;
2486  GtkWidget *tab_widget;
2487  GdkRGBA tab_color;
2488  gchar *color_string = nullptr;
2489  gboolean want_color = FALSE;
2490 
2491  ENTER(" ");
2492  if (color_in)
2493  color_string = g_strstrip(g_strdup(color_in));
2494 
2495  if (color_string && *color_string != '\0')
2496  want_color = TRUE;
2497 
2498  /* Update the plugin */
2499  window = GNC_MAIN_WINDOW(page->window);
2500  if (want_color)
2501  gnc_plugin_page_set_page_color(page, color_string);
2502  else
2503  gnc_plugin_page_set_page_color(page, nullptr);
2504 
2505  /* Update the notebook tab */
2506  main_window_find_tab_widget (window, page, &tab_widget);
2507  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
2508 
2509  GtkStyleContext *stylectxt = gtk_widget_get_style_context (GTK_WIDGET(tab_widget));
2510  const gchar *tab_css_class = "tab-bg-color";
2511 
2512  if (want_color && gdk_rgba_parse(&tab_color, color_string) && priv->show_color_tabs)
2513  {
2514  GtkCssProvider *provider = gtk_css_provider_new();
2515  gchar *col_str = gdk_rgba_to_string (&tab_color);
2516  gchar *widget_css = g_strconcat (".", tab_css_class, " {\n background-color:", col_str, ";\n}\n", nullptr);
2517 
2518  gtk_css_provider_load_from_data (provider, widget_css, -1, nullptr);
2519  gtk_style_context_add_provider (stylectxt, GTK_STYLE_PROVIDER (provider),
2520  GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
2521  gtk_style_context_add_class (stylectxt, tab_css_class);
2522  g_object_unref (provider);
2523  g_free (col_str);
2524  g_free (widget_css);
2525  }
2526  else
2527  gtk_style_context_remove_class (stylectxt, tab_css_class);
2528 
2529  g_free(color_string);
2530  LEAVE("done");
2531 }
2532 
2533 
2534 void
2536  gboolean read_only)
2537 {
2538  GncMainWindow *window;
2539  GtkWidget *tab_widget;
2540  GtkWidget *image = NULL;
2541  GList *children;
2542  gchar *image_name = NULL;
2543  const gchar *icon_name;
2544 
2545  ENTER(" ");
2546 
2547  g_return_if_fail (page && page->window);
2548 
2549  if (!GNC_IS_MAIN_WINDOW (page->window))
2550  return;
2551 
2552  window = GNC_MAIN_WINDOW(page->window);
2553 
2554  /* Get the notebook tab widget */
2555  main_window_find_tab_widget (window, page, &tab_widget);
2556 
2557  if (!tab_widget)
2558  {
2559  LEAVE("no tab widget");
2560  return;
2561  }
2562 
2563  if (GTK_IS_EVENT_BOX(tab_widget))
2564  tab_widget = gtk_bin_get_child (GTK_BIN(tab_widget));
2565 
2566  children = gtk_container_get_children (GTK_CONTAINER(tab_widget));
2567  /* For each, walk the list of container children to get image widget */
2568  for (GList *child = children; child; child = g_list_next (child))
2569  {
2570  GtkWidget *widget = static_cast<GtkWidget*>(child->data);
2571  if (GTK_IS_IMAGE(widget))
2572  image = widget;
2573  }
2574  g_list_free (children);
2575 
2576  if (!image)
2577  {
2578  LEAVE("no image to replace");
2579  return;
2580  }
2581 
2582  g_object_get (image, "icon-name", &image_name, NULL);
2583 
2584  if (read_only)
2585  icon_name = "changes-prevent-symbolic";
2586  else
2587  icon_name = GNC_PLUGIN_PAGE_GET_CLASS(page)->tab_icon;
2588 
2589  if (g_strcmp0 (icon_name, image_name) == 0)
2590  {
2591  LEAVE("page icon the same, no need to replace");
2592  g_free (image_name);
2593  return;
2594  }
2595  gtk_container_remove (GTK_CONTAINER(tab_widget), image);
2596  image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
2597  gtk_widget_show (image);
2598 
2599  gtk_container_add (GTK_CONTAINER(tab_widget), image);
2600  gtk_widget_set_margin_start (GTK_WIDGET(image), 5);
2601  gtk_box_reorder_child (GTK_BOX(tab_widget), image, 0);
2602 
2603  g_free (image_name);
2604  LEAVE("done");
2605 }
2606 
2607 
2608 static void
2609 gnc_main_window_tab_entry_activate (GtkWidget *entry,
2610  GncPluginPage *page)
2611 {
2612  GtkWidget *label, *entry2;
2613 
2614  g_return_if_fail(GTK_IS_ENTRY(entry));
2615  g_return_if_fail(GNC_IS_PLUGIN_PAGE(page));
2616 
2617  ENTER("");
2618  if (!main_window_find_tab_items(GNC_MAIN_WINDOW(page->window),
2619  page, &label, &entry2))
2620  {
2621  LEAVE("can't find required widgets");
2622  return;
2623  }
2624 
2625  main_window_update_page_name(page, gtk_entry_get_text(GTK_ENTRY(entry)));
2626 
2627  gtk_widget_hide(entry);
2628  gtk_widget_show(label);
2629  LEAVE("");
2630 }
2631 
2632 
2633 static gboolean
2634 gnc_main_window_tab_entry_editing_done (GtkWidget *entry,
2635  GncPluginPage *page)
2636 {
2637  ENTER("");
2638  gnc_main_window_tab_entry_activate(entry, page);
2639  LEAVE("");
2640  return FALSE;
2641 }
2642 
2643 static gboolean
2644 gnc_main_window_tab_entry_focus_out_event (GtkWidget *entry,
2645  GdkEvent *event,
2646  GncPluginPage *page)
2647 {
2648  ENTER("");
2649  gtk_cell_editable_editing_done(GTK_CELL_EDITABLE(entry));
2650  LEAVE("");
2651  return FALSE;
2652 }
2653 
2654 static gboolean
2655 gnc_main_window_tab_entry_key_press_event (GtkWidget *entry,
2656  GdkEventKey *event,
2657  GncPluginPage *page)
2658 {
2659  if (event->keyval == GDK_KEY_Escape)
2660  {
2661  GtkWidget *label, *entry2;
2662 
2663  g_return_val_if_fail(GTK_IS_ENTRY(entry), FALSE);
2664  g_return_val_if_fail(GNC_IS_PLUGIN_PAGE(page), FALSE);
2665 
2666  ENTER("");
2667  if (!main_window_find_tab_items(GNC_MAIN_WINDOW(page->window),
2668  page, &label, &entry2))
2669  {
2670  LEAVE("can't find required widgets");
2671  return FALSE;
2672  }
2673 
2674  gtk_entry_set_text(GTK_ENTRY(entry), gtk_label_get_text(GTK_LABEL(label)));
2675  gtk_widget_hide(entry);
2676  gtk_widget_show(label);
2677  LEAVE("");
2678  }
2679  return FALSE;
2680 }
2681 
2682 /************************************************************
2683  * Widget Implementation *
2684  ************************************************************/
2685 
2686 
2687 
2695 static void
2696 gnc_main_window_class_init (GncMainWindowClass *klass)
2697 {
2698  GObjectClass *object_class = G_OBJECT_CLASS (klass);
2699  GtkWidgetClass *gtkwidget_class = GTK_WIDGET_CLASS(klass);
2700 
2701  window_type = g_quark_from_static_string ("gnc-main-window");
2702 
2703  object_class->constructed = gnc_main_window_constructed;
2704  object_class->finalize = gnc_main_window_finalize;
2705 
2706  /* GtkWidget signals */
2707  gtkwidget_class->destroy = gnc_main_window_destroy;
2708 
2720  main_window_signals[PAGE_ADDED] =
2721  g_signal_new ("page_added",
2722  G_OBJECT_CLASS_TYPE (object_class),
2723  G_SIGNAL_RUN_FIRST,
2724  G_STRUCT_OFFSET (GncMainWindowClass, page_added),
2725  nullptr, nullptr,
2726  g_cclosure_marshal_VOID__OBJECT,
2727  G_TYPE_NONE, 1,
2728  G_TYPE_OBJECT);
2729 
2740  main_window_signals[PAGE_CHANGED] =
2741  g_signal_new ("page_changed",
2742  G_OBJECT_CLASS_TYPE (object_class),
2743  G_SIGNAL_RUN_FIRST,
2744  G_STRUCT_OFFSET (GncMainWindowClass, page_changed),
2745  nullptr, nullptr,
2746  g_cclosure_marshal_VOID__OBJECT,
2747  G_TYPE_NONE, 1,
2748  G_TYPE_OBJECT);
2749 
2758  main_window_signals[MENU_CHANGED] =
2759  g_signal_new ("menu_changed",
2760  G_OBJECT_CLASS_TYPE (object_class),
2761  G_SIGNAL_RUN_FIRST,
2762  G_STRUCT_OFFSET (GncMainWindowClass, menu_changed),
2763  nullptr, nullptr,
2764  g_cclosure_marshal_VOID__OBJECT,
2765  G_TYPE_NONE, 1,
2766  G_TYPE_OBJECT);
2767 
2768  gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
2769  GNC_PREF_SHOW_CLOSE_BUTTON,
2770  (gpointer)gnc_main_window_update_tab_close,
2771  nullptr);
2772  gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
2773  GNC_PREF_TAB_WIDTH,
2774  (gpointer)gnc_main_window_update_tab_width,
2775  nullptr);
2776 
2777  gnc_hook_add_dangler(HOOK_BOOK_SAVED,
2778  (GFunc)gnc_main_window_update_all_titles, nullptr, nullptr);
2779  gnc_hook_add_dangler(HOOK_BOOK_OPENED,
2780  (GFunc)gnc_main_window_attach_to_book, nullptr, nullptr);
2781 
2782 }
2783 
2784 
2790 static void
2791 gnc_main_window_init (GncMainWindow *window)
2792 {
2793  GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
2794 
2795  // Set the name for this dialog so it can be easily manipulated with css
2796  gtk_widget_set_name (GTK_WIDGET(window), "gnc-id-main-window");
2797 
2798  priv->event_handler_id =
2799  qof_event_register_handler(gnc_main_window_event_handler, window);
2800 
2801  priv->restoring_pages = FALSE;
2802 
2803  priv->display_item_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, nullptr);
2804 
2805  priv->previous_plugin_page_name = nullptr;
2806  priv->previous_menu_qualifier = nullptr;
2807 
2808  priv->accel_group = gtk_accel_group_new ();
2809  gtk_window_add_accel_group (GTK_WINDOW(window), priv->accel_group);
2810 
2811  /* Get the show_color_tabs value preference */
2812  priv->show_color_tabs = gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_COLOR);
2813 
2814  gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
2815  GNC_PREF_TAB_COLOR,
2816  (gpointer)gnc_main_window_update_tab_color,
2817  window);
2818 
2819  gnc_main_window_setup_window (window);
2820 }
2821 
2828 static void
2829 gnc_main_window_constructed (GObject *obj)
2830 {
2832 
2833  G_OBJECT_CLASS (gnc_main_window_parent_class)->constructed (obj);
2834 }
2835 
2846 static void
2847 gnc_main_window_finalize (GObject *object)
2848 {
2849  g_return_if_fail (object != nullptr);
2850  g_return_if_fail (GNC_IS_MAIN_WINDOW (object));
2851 
2852  if (active_windows == nullptr)
2853  {
2854  /* Oops. User killed last window and we didn't catch it. */
2855  g_idle_add((GSourceFunc)gnc_shutdown, 0);
2856  }
2857 
2859  G_OBJECT_CLASS (gnc_main_window_parent_class)->finalize (object);
2860 }
2861 
2862 
2863 static void
2864 gnc_main_window_remove_prefs (GncMainWindow *window)
2865 {
2866  // remove the registered preference callbacks setup in this file.
2867  gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
2868  GNC_PREF_TAB_COLOR,
2869  (gpointer)gnc_main_window_update_tab_color,
2870  window);
2871 
2872  gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
2873  GNC_PREF_SHOW_CLOSE_BUTTON,
2874  (gpointer)gnc_main_window_update_tab_close,
2875  nullptr);
2876 
2877  gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
2878  GNC_PREF_TAB_WIDTH,
2879  (gpointer)gnc_main_window_update_tab_width,
2880  nullptr);
2881 
2882  gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
2883  GNC_PREF_TAB_POSITION_TOP,
2884  (gpointer)gnc_main_window_update_tab_position,
2885  window);
2886 
2887  gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
2888  GNC_PREF_TAB_POSITION_BOTTOM,
2889  (gpointer)gnc_main_window_update_tab_position,
2890  window);
2891 
2892  gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
2893  GNC_PREF_TAB_POSITION_LEFT,
2894  (gpointer)gnc_main_window_update_tab_position,
2895  window);
2896 
2897  gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
2898  GNC_PREF_TAB_POSITION_RIGHT,
2899  (gpointer)gnc_main_window_update_tab_position,
2900  window);
2901 
2902  // remove the registered negative color preference callback.
2903  if (gnc_prefs_get_reg_negative_color_pref_id() > 0 && window->window_quitting)
2904  {
2905  gnc_prefs_remove_cb_by_id (GNC_PREFS_GROUP_GENERAL,
2907  gnc_prefs_set_reg_negative_color_pref_id (0);
2908  }
2909 
2910  // remove the registered auto_raise_lists preference callback.
2911  if (gnc_prefs_get_reg_auto_raise_lists_id() > 0 && window->window_quitting)
2912  {
2913  gnc_prefs_remove_cb_by_id (GNC_PREFS_GROUP_GENERAL_REGISTER,
2915  gnc_prefs_set_reg_auto_raise_lists_id (0);
2916  }
2917 }
2918 
2919 
2920 static void
2921 gnc_main_window_destroy (GtkWidget *widget)
2922 {
2923  GncMainWindow *window;
2924  GncMainWindowPrivate *priv;
2925  GncPluginManager *manager;
2926  GList *plugins;
2927 
2928  g_return_if_fail (widget != nullptr);
2929  g_return_if_fail (GNC_IS_MAIN_WINDOW (widget));
2930 
2931  window = GNC_MAIN_WINDOW (widget);
2932 #ifdef MAC_INTEGRATION
2933  auto entry = g_list_find (active_windows, window);
2934  if (entry && (entry->next || entry->prev))
2935  gnc_quartz_set_menu (GNC_MAIN_WINDOW (entry->next ? entry->next->data : entry->prev->data));
2936 #endif
2937  active_windows = g_list_remove (active_windows, window);
2938 
2939  /* Do these things once */
2940  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
2941  if (priv->event_handler_id > 0)
2942  {
2943 
2944  /* Close any pages in this window */
2945  while (priv->current_page)
2947 
2948  if (gnc_window_get_progressbar_window() == GNC_WINDOW(window))
2949  gnc_window_set_progressbar_window(nullptr);
2950 #ifndef MAC_INTEGRATION
2951  /* Update the "Windows" menu in all other windows */
2952  gnc_main_window_update_all_menu_items();
2953 #endif
2954  /* remove the preference callbacks from the main window */
2955  gnc_main_window_remove_prefs (window);
2956 
2958  priv->event_handler_id = 0;
2959 
2960  g_hash_table_destroy (priv->display_item_hash);
2961 
2962  /* GncPluginManager stuff */
2963  manager = gnc_plugin_manager_get ();
2964  plugins = gnc_plugin_manager_get_plugins (manager);
2965  g_list_foreach (plugins, gnc_main_window_remove_plugin, window);
2966  g_list_free (plugins);
2967  }
2968 
2969  GTK_WIDGET_CLASS (gnc_main_window_parent_class)->destroy (widget);
2970 }
2971 
2972 
2973 static gboolean
2974 gnc_main_window_key_press_event (GtkWidget *widget, GdkEventKey *event, gpointer user_data)
2975 {
2976  GncMainWindowPrivate *priv;
2977  GdkModifierType modifiers;
2978 
2979  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(widget), FALSE);
2980 
2981  priv = GNC_MAIN_WINDOW_GET_PRIVATE(widget);
2982 
2983  modifiers = gtk_accelerator_get_default_mod_mask ();
2984 
2985  if ((event->state & modifiers) == (GDK_CONTROL_MASK | GDK_MOD1_MASK)) // Ctrl+Alt+
2986  {
2987  const gchar *account_key = C_ ("lower case key for short cut to 'Accounts'", "a");
2988  guint account_keyval = gdk_keyval_from_name (account_key);
2989 
2990  if ((account_keyval == event->keyval) || (account_keyval == gdk_keyval_to_lower (event->keyval)))
2991  {
2992  gint page = 0;
2993 
2994  for (GList *item = priv->installed_pages; item; item = g_list_next (item))
2995  {
2996  const gchar *pname = gnc_plugin_page_get_plugin_name (GNC_PLUGIN_PAGE(item->data));
2997 
2998  if (g_strcmp0 (pname, "GncPluginPageAccountTree") == 0)
2999  {
3000  gtk_notebook_set_current_page (GTK_NOTEBOOK(priv->notebook), page);
3001  return TRUE;
3002  }
3003  page++;
3004  }
3005  }
3006  else if ((GDK_KEY_Menu == event->keyval) || (GDK_KEY_space == event->keyval))
3007  {
3008  GList *menu = gtk_menu_get_for_attach_widget (GTK_WIDGET(priv->notebook));
3009 
3010  if (menu)
3011  {
3012  gtk_menu_popup_at_widget (GTK_MENU(menu->data),
3013  GTK_WIDGET(priv->notebook),
3014  GDK_GRAVITY_SOUTH,
3015  GDK_GRAVITY_SOUTH,
3016  NULL);
3017  return TRUE;
3018  }
3019  }
3020  }
3021  return FALSE;
3022 }
3023 
3024 
3025 /* Create a new gnc main window plugin.
3026  */
3027 GncMainWindow *
3029 {
3030  auto window{static_cast<GncMainWindow*>(g_object_new (GNC_TYPE_MAIN_WINDOW, nullptr))};
3031  gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
3032 
3033  auto old_window = gnc_ui_get_main_window (nullptr);
3034  if (old_window)
3035  {
3036  gint width, height;
3037  gtk_window_get_size (old_window, &width, &height);
3038  gtk_window_resize (GTK_WINDOW (window), width, height);
3039  if ((gdk_window_get_state((gtk_widget_get_window (GTK_WIDGET(old_window))))
3040  & GDK_WINDOW_STATE_MAXIMIZED) != 0)
3041  {
3042  gtk_window_maximize (GTK_WINDOW (window));
3043  }
3044  }
3045  active_windows = g_list_append (active_windows, window);
3046  gnc_main_window_update_title(window);
3047  window->window_quitting = FALSE;
3048  window->just_plugin_prefs = FALSE;
3049 #ifdef MAC_INTEGRATION
3050  gnc_quartz_set_menu(window);
3051 #else
3052  gnc_main_window_update_all_menu_items();
3053 #endif
3054  gnc_engine_add_commit_error_callback( gnc_main_window_engine_commit_error_callback, window );
3055 
3056  // set up a callback for notebook navigation
3057  g_signal_connect (G_OBJECT(window), "key-press-event",
3058  G_CALLBACK(gnc_main_window_key_press_event),
3059  NULL);
3060 
3061  return window;
3062 }
3063 
3064 /************************************************************
3065  * Utility Functions *
3066  ************************************************************/
3067 
3068 static void
3069 gnc_main_window_engine_commit_error_callback( gpointer data,
3070  QofBackendError errcode )
3071 {
3072  GncMainWindow* window = GNC_MAIN_WINDOW(data);
3073  GtkWidget* dialog;
3074  const gchar *reason = _("Unable to save to database.");
3075  if ( errcode == ERR_BACKEND_READONLY )
3076  reason = _("Unable to save to database: Book is marked read-only.");
3077  dialog = gtk_message_dialog_new( GTK_WINDOW(window),
3078  GTK_DIALOG_DESTROY_WITH_PARENT,
3079  GTK_MESSAGE_ERROR,
3080  GTK_BUTTONS_CLOSE,
3081  "%s",
3082  reason );
3083  gtk_dialog_run(GTK_DIALOG (dialog));
3084  gtk_widget_destroy(dialog);
3085 
3086 }
3087 
3105 static void
3106 gnc_main_window_connect (GncMainWindow *window,
3107  GncPluginPage *page,
3108  GtkWidget *tab_hbox,
3109  GtkWidget *menu_label)
3110 {
3111  GncMainWindowPrivate *priv;
3112  GtkNotebook *notebook;
3113  gint current_position = -1;
3114 
3115  page->window = GTK_WIDGET(window);
3116  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3117  notebook = GTK_NOTEBOOK (priv->notebook);
3118 
3119  if (!priv->restoring_pages
3120  && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_OPEN_ADJACENT))
3121  current_position = g_list_index (priv->installed_pages, priv->current_page) + 1;
3122 
3123  priv->installed_pages = g_list_insert (priv->installed_pages, page, current_position);
3124  priv->usage_order = g_list_prepend (priv->usage_order, page);
3125  gtk_notebook_insert_page_menu (notebook, page->notebook_page,
3126  tab_hbox, menu_label, current_position);
3127  gtk_notebook_set_tab_reorderable (notebook, page->notebook_page, TRUE);
3128  gnc_plugin_page_inserted (page);
3129  if (!priv->restoring_pages)
3130  gtk_notebook_set_current_page (notebook, current_position);
3131 
3132  if (GNC_PLUGIN_PAGE_GET_CLASS(page)->window_changed)
3133  (GNC_PLUGIN_PAGE_GET_CLASS(page)->window_changed)(page, GTK_WIDGET(window));
3134  g_signal_emit (window, main_window_signals[PAGE_ADDED], 0, page);
3135 
3136  g_signal_connect(G_OBJECT(page->notebook_page), "popup-menu",
3137  G_CALLBACK(gnc_main_window_popup_menu_cb), page);
3138  g_signal_connect_after(G_OBJECT(page->notebook_page), "button-press-event",
3139  G_CALLBACK(gnc_main_window_button_press_cb), page);
3140 }
3141 
3142 
3156 static void
3157 gnc_main_window_disconnect (GncMainWindow *window,
3158  GncPluginPage *page)
3159 {
3160  GncMainWindowPrivate *priv;
3161  GtkNotebook *notebook;
3162  GncPluginPage *new_page;
3163  gint page_num;
3164 
3165  /* Disconnect the callbacks */
3166  g_signal_handlers_disconnect_by_func(G_OBJECT(page->notebook_page),
3167  (gpointer)gnc_main_window_popup_menu_cb, page);
3168  g_signal_handlers_disconnect_by_func(G_OBJECT(page->notebook_page),
3169  (gpointer)gnc_main_window_button_press_cb, page);
3170 
3171  // Remove the page_changed signal callback
3172  gnc_plugin_page_disconnect_page_changed (GNC_PLUGIN_PAGE(page));
3173 
3174  /* Disconnect the page and summarybar from the window */
3175  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3176  if (priv->current_page == page)
3177  {
3178  gnc_plugin_page_unselected (page);
3179  priv->current_page = nullptr;
3180  }
3181 
3182  /* Remove it from the list of pages in the window */
3183  priv->installed_pages = g_list_remove (priv->installed_pages, page);
3184  priv->usage_order = g_list_remove (priv->usage_order, page);
3185 
3186  /* Switch to the last recently used page */
3187  notebook = GTK_NOTEBOOK (priv->notebook);
3188  if (gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_NEXT_RECENT))
3189  {
3190  new_page = static_cast<GncPluginPage*>(g_list_nth_data (priv->usage_order, 0));
3191  if (new_page)
3192  {
3193  page_num = gtk_notebook_page_num(notebook, new_page->notebook_page);
3194  gtk_notebook_set_current_page(notebook, page_num);
3195  /* This may have caused WebKit to schedule a timer interrupt which it
3196  sometimes forgets to cancel before deleting the object. See
3197  <https://bugs.webkit.org/show_bug.cgi?id=119003>. Get around this
3198  by flushing all events to get rid of the timer interrupt. */
3199  while (gtk_events_pending())
3200  gtk_main_iteration();
3201  }
3202  }
3203 
3204  /* Remove the page from the notebook */
3205  page_num = gtk_notebook_page_num(notebook, page->notebook_page);
3206  gtk_notebook_remove_page (notebook, page_num);
3207 
3208  if ( gtk_notebook_get_current_page(notebook) == -1)
3209  {
3210  /* Need to synthesize a page changed signal when the last
3211  * page is removed. The notebook doesn't generate a signal
3212  * for this, therefore the switch_page code in this file
3213  * never gets called to generate this signal. */
3214  gnc_main_window_switch_page(notebook, nullptr, -1, window);
3215  //g_signal_emit (window, main_window_signals[PAGE_CHANGED], 0, nullptr);
3216  }
3217 
3218  gnc_plugin_page_removed (page);
3219 
3220  gnc_window_set_status (GNC_WINDOW(window), page, nullptr);
3221 }
3222 
3223 
3224 /************************************************************
3225  * *
3226  ************************************************************/
3227 
3228 
3229 void
3231 {
3232  GncMainWindow *window;
3233  GncMainWindowPrivate *priv;
3234  GtkNotebook *notebook;
3235  gint page_num;
3236 
3237  window = GNC_MAIN_WINDOW (page->window);
3238  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3239  notebook = GTK_NOTEBOOK (priv->notebook);
3240  page_num = gtk_notebook_page_num(notebook, page->notebook_page);
3241  gtk_notebook_set_current_page (notebook, page_num);
3242  gtk_window_present(GTK_WINDOW(window));
3243 }
3244 
3245 
3246 /* Display a data plugin page in a window. If the page already
3247  * exists in any window, then that window will be brought to the
3248  * front and the notebook switch to display the specified page. If
3249  * the page is new then it will be added to the specified window. If
3250  * the window is nullptr, the new page will be added to the first
3251  * window.
3252  */
3253 void
3254 gnc_main_window_open_page (GncMainWindow *window,
3255  GncPluginPage *page)
3256 {
3257  GncMainWindowPrivate *priv;
3258  GtkWidget *tab_container, *tab_clickable_area;
3259  GtkWidget *label, *entry;
3260  const gchar *icon, *text, *color_string, *lab_text;
3261  GtkWidget *image;
3262  GList *tmp;
3263  TabWidth *tw;
3264 
3265  ENTER("window %p, page %p", window, page);
3266  if (window)
3267  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
3268  g_return_if_fail (GNC_IS_PLUGIN_PAGE (page));
3269  g_return_if_fail (gnc_plugin_page_has_books(page));
3270 
3271  if (gnc_main_window_page_exists(page))
3272  {
3274  return;
3275  }
3276 
3277  /* Does the page want to be in a new window? */
3279  {
3280  /* See if there's a blank window. If so, use that. */
3281  for (tmp = active_windows; tmp; tmp = g_list_next(tmp))
3282  {
3283  window = GNC_MAIN_WINDOW(tmp->data);
3284  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3285  if (priv->installed_pages == nullptr)
3286  {
3287  break;
3288  }
3289  }
3290  if (tmp == nullptr)
3291  window = gnc_main_window_new ();
3292  gtk_widget_show(GTK_WIDGET(window));
3293  }
3294  else if ((window == nullptr) && active_windows)
3295  {
3296  window = static_cast<GncMainWindow*>(active_windows->data);
3297  }
3298 
3299  page->window = GTK_WIDGET(window);
3301  g_object_set_data (G_OBJECT (page->notebook_page),
3302  PLUGIN_PAGE_LABEL, page);
3303 
3304  /*
3305  * The page tab.
3306  * Component structure:
3307  *
3308  * tab_container (GtkBox)
3309  * ├── tab_clickable_area (GtkEventBox)
3310  * │ └── tab_content (GtkBox)
3311  * │ ├── image (GtkImage, optional)
3312  * │ ├── label (GtkLabel)
3313  * │ └── entry (GtkEntry, hidden)
3314  * └── close_button (GtkButton, if not immutable)
3315  */
3316  icon = GNC_PLUGIN_PAGE_GET_CLASS(page)->tab_icon;
3317  lab_text = gnc_plugin_page_get_page_name(page);
3318  label = gtk_label_new (lab_text);
3319  g_object_set_data (G_OBJECT (page), PLUGIN_PAGE_TAB_LABEL, label);
3320 
3321  tw = populate_tab_width_struct ();
3322  gnc_main_window_update_tab_width_one_page (page, tw);
3323  g_free (tw);
3324 
3325  gtk_widget_show (label);
3326 
3327  tab_container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
3328 
3330  if (text)
3331  {
3332  gtk_widget_set_tooltip_text(tab_container, text);
3333  }
3334 
3335  if (g_strcmp0 (gnc_plugin_page_get_plugin_name (page), "GncPluginPageAccountTree") == 0)
3336  gtk_widget_set_name (GTK_WIDGET(tab_container), "gnc-id-account-page-tab-box");
3337 
3338  gtk_box_set_homogeneous (GTK_BOX (tab_container), FALSE);
3339  gtk_widget_show (tab_container);
3340 
3341  // Create a custom clickable area for the tab to support middle-clicking
3342  tab_clickable_area = gtk_event_box_new();
3343  gtk_widget_show(tab_clickable_area);
3344  gtk_box_pack_start (GTK_BOX (tab_container), tab_clickable_area, TRUE, TRUE, 0);
3345 
3346  // Create a box for the tab's content
3347  // Give it a name so we can find it later (see main_window_find_tab_items)
3348  GtkWidget *tab_content = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
3349  gtk_widget_set_name(tab_content, "tab-content");
3350  gtk_container_add(GTK_CONTAINER(tab_clickable_area), tab_content);
3351  gtk_widget_show(tab_content);
3352 
3353  if (icon != nullptr)
3354  {
3355  image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU);
3356  gtk_widget_show (image);
3357  gtk_box_pack_start (GTK_BOX (tab_content), image, FALSE, FALSE, 0);
3358  gtk_widget_set_margin_start (GTK_WIDGET(image), 5);
3359  gtk_box_pack_start (GTK_BOX (tab_content), label, TRUE, TRUE, 0);
3360  }
3361  else
3362  gtk_box_pack_start (GTK_BOX (tab_content), label, TRUE, TRUE, 0);
3363 
3364  entry = gtk_entry_new();
3365  gtk_widget_hide (entry);
3366  gtk_box_pack_start (GTK_BOX (tab_content), entry, TRUE, TRUE, 0);
3367  g_signal_connect(G_OBJECT(entry), "activate",
3368  G_CALLBACK(gnc_main_window_tab_entry_activate), page);
3369  g_signal_connect(G_OBJECT(entry), "focus-out-event",
3370  G_CALLBACK(gnc_main_window_tab_entry_focus_out_event),
3371  page);
3372  g_signal_connect(G_OBJECT(entry), "key-press-event",
3373  G_CALLBACK(gnc_main_window_tab_entry_key_press_event),
3374  page);
3375  g_signal_connect(G_OBJECT(entry), "editing-done",
3376  G_CALLBACK(gnc_main_window_tab_entry_editing_done),
3377  page);
3378 
3379  /* Add close button - Not for immutable pages */
3380  if (!g_object_get_data (G_OBJECT (page), PLUGIN_PAGE_IMMUTABLE))
3381  {
3382  GtkWidget *close_image, *close_button;
3383  GtkRequisition requisition;
3384 
3385  close_button = gtk_button_new();
3386  gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
3387  close_image = gtk_image_new_from_icon_name ("window-close", GTK_ICON_SIZE_MENU);
3388  gtk_widget_show(close_image);
3389  gtk_widget_get_preferred_size (close_image, &requisition, nullptr);
3390  gtk_widget_set_size_request(close_button, requisition.width + 4,
3391  requisition.height + 2);
3392  gtk_container_add(GTK_CONTAINER(close_button), close_image);
3393  if (gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SHOW_CLOSE_BUTTON))
3394  gtk_widget_show (close_button);
3395  else
3396  gtk_widget_hide (close_button);
3397 
3398  // Custom handler to close on middle-clicks
3399  g_signal_connect(G_OBJECT(tab_clickable_area), "button-press-event",
3400  G_CALLBACK(gnc_tab_clicked_cb), page);
3401 
3402  g_signal_connect_swapped (G_OBJECT (close_button), "clicked",
3403  G_CALLBACK(gnc_main_window_close_page), page);
3404 
3405  gtk_box_pack_start (GTK_BOX (tab_container), close_button, FALSE, FALSE, 0);
3406  gtk_widget_set_margin_end (GTK_WIDGET(close_button), 5);
3407  g_object_set_data (G_OBJECT (page), PLUGIN_PAGE_CLOSE_BUTTON, close_button);
3408  }
3409 
3410  /*
3411  * The popup menu
3412  */
3413  label = gtk_label_new (gnc_plugin_page_get_page_name(page));
3414 
3415  /*
3416  * Now install it all in the window.
3417  */
3418  gnc_main_window_connect(window, page, tab_container, label);
3419 
3420  color_string = gnc_plugin_page_get_page_color(page);
3421  main_window_update_page_color (page, color_string);
3422  LEAVE("");
3423 }
3424 
3425 
3426 /* Remove a data plugin page from a window and display the previous
3427  * page. If the page removed was the last page in the window, and
3428  * there is more than one window open, then the entire window will be
3429  * destroyed.
3430  */
3431 void
3433 {
3434  GncMainWindow *window;
3435  GncMainWindowPrivate *priv;
3436 
3437  if (!page || !page->notebook_page)
3438  return;
3439 
3440  if (!gnc_plugin_page_finish_pending(page))
3441  return;
3442 
3443  if (!GNC_IS_MAIN_WINDOW (page->window))
3444  return;
3445 
3446  window = GNC_MAIN_WINDOW (page->window);
3447  if (!window)
3448  {
3449  g_warning("Page is not in a window.");
3450  return;
3451  }
3452 
3453  gnc_main_window_disconnect(window, page);
3455  g_object_unref(page);
3456 
3457  /* If this isn't the last window, go ahead and destroy the window. */
3458  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3459  if (priv->installed_pages == nullptr)
3460  {
3461  if (window->window_quitting)
3462  {
3463  GncPluginManager *manager = gnc_plugin_manager_get ();
3464  GList *plugins = gnc_plugin_manager_get_plugins (manager);
3465 
3466  /* remove only the preference callbacks from the window plugins */
3467  window->just_plugin_prefs = TRUE;
3468  g_list_foreach (plugins, gnc_main_window_remove_plugin, window);
3469  window->just_plugin_prefs = FALSE;
3470  g_list_free (plugins);
3471 
3472  /* remove the preference callbacks from the main window */
3473  gnc_main_window_remove_prefs (window);
3474  }
3475  if (window && (gnc_list_length_cmp (active_windows, 1) > 0))
3476  gtk_widget_destroy (GTK_WIDGET(window));
3477  }
3478 }
3479 
3480 
3481 /* Retrieve a pointer to the page that is currently at the front of
3482  * the specified window. Any plugin that needs to manipulate its
3483  * menus based upon the currently selected menu page should connect
3484  * to the "page_changed" signal on a window. The callback function
3485  * from that signal can then call this function to obtain a pointer
3486  * to the current page.
3487  */
3488 GncPluginPage *
3489 gnc_main_window_get_current_page (GncMainWindow *window)
3490 {
3491  GncMainWindowPrivate *priv;
3492 
3493  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3494  return priv->current_page;
3495 }
3496 
3497 
3498 /* Manually add a set of actions to the specified window. Plugins
3499  * whose user interface is not hard coded (e.g. the menu-additions
3500  * plugin) must create their actions at run time, then use this
3501  * function to install them into the window.
3502  */
3503 void
3505  const gchar *group_name,
3506  GSimpleActionGroup *group)
3507 {
3508  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
3509  g_return_if_fail (group_name != nullptr);
3510  g_return_if_fail (G_IS_SIMPLE_ACTION_GROUP(group));
3511 
3512  gtk_widget_insert_action_group (GTK_WIDGET(window), group_name,
3513  G_ACTION_GROUP(group));
3514 }
3515 
3516 
3517 static void
3518 update_menu_model (GncMainWindow *window, const gchar *ui_filename,
3519  const gchar **ui_updates)
3520 {
3521  GncMainWindowPrivate *priv;
3522  GError *error = nullptr;
3523  gchar *res_name;
3524  GtkBuilder *builder = gtk_builder_new ();
3525  GMenuModel *menu_model_part;
3526  GncMenuModelSearch *gsm = g_new0 (GncMenuModelSearch, 1);
3527 
3528  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
3529  g_return_if_fail (ui_filename != nullptr);
3530  g_return_if_fail (ui_updates != nullptr);
3531 
3532  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3533 
3534  gtk_builder_set_translation_domain (builder, PROJECT_NAME);
3535  res_name = g_strconcat (GNUCASH_RESOURCE_PREFIX "/", ui_filename, NULL);
3536 
3537  gtk_builder_add_from_resource (builder, res_name, &error);
3538  g_free (res_name);
3539 
3540  if (error)
3541  {
3542  g_critical ("Failed to load, Error %s", error->message);
3543  g_error_free (error);
3544  return;
3545  }
3546 
3547  for (gint i = 0; ui_updates[i]; i++)
3548  {
3549  menu_model_part = (GMenuModel *)gtk_builder_get_object (builder, ui_updates[i]);
3550 
3551  gsm->search_action_label = nullptr;
3552  gsm->search_action_name = ui_updates[i];
3553  gsm->search_action_target = nullptr;
3554 
3555  if (gnc_menubar_model_find_item (priv->menubar_model, gsm))
3556  g_menu_insert_section (G_MENU(gsm->model), gsm->index, NULL, G_MENU_MODEL(menu_model_part));
3557  else
3558  PERR("Could not find '%s' in menu model", ui_updates[i]);
3559  }
3560  g_free (gsm);
3561  g_object_unref (builder);
3562 }
3563 
3564 
3565 /* Add a set of actions to the specified window. This function
3566  * should not need to be called directly by plugin implementors.
3567  * Correctly assigning values to the GncPluginClass fields during
3568  * plugin initialization will cause this routine to be automatically
3569  * called.
3570  */
3571 void
3572 gnc_main_window_merge_actions (GncMainWindow *window,
3573  const gchar *group_name,
3574  GActionEntry *actions,
3575  guint n_actions,
3576  const gchar **ui_updates,
3577  const gchar *ui_filename,
3578  gpointer user_data)
3579 {
3581  GSimpleActionGroup *simple_action_group;
3582 
3583  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
3584  g_return_if_fail (group_name != nullptr);
3585  g_return_if_fail (actions != nullptr);
3586  g_return_if_fail (n_actions > 0);
3587 
3588  data = g_new0 (GncMainWindowActionData, 1);
3589  data->window = window;
3590  data->data = user_data;
3591 
3592  simple_action_group = g_simple_action_group_new ();
3593 
3594  g_action_map_add_action_entries (G_ACTION_MAP(simple_action_group),
3595  actions,
3596  n_actions,
3597  data);
3598 
3599  gtk_widget_insert_action_group (GTK_WIDGET(window), group_name,
3600  G_ACTION_GROUP(simple_action_group));
3601 
3602  if (ui_filename)
3603  update_menu_model (window, ui_filename, ui_updates);
3604 }
3605 
3606 
3607 /* Remove a set of actions from the specified window. This function
3608  * should not need to be called directly by plugin implementors. It
3609  * will automatically be called when a plugin is removed from a
3610  * window.
3611  */
3612 void
3613 gnc_main_window_unmerge_actions (GncMainWindow *window,
3614  const gchar *group_name)
3615 {
3616  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
3617  g_return_if_fail (group_name != nullptr);
3618 
3619  gtk_widget_insert_action_group (GTK_WIDGET(window), group_name, nullptr);
3620 }
3621 
3622 GAction *
3623 gnc_main_window_find_action (GncMainWindow *window, const gchar *action_name)
3624 {
3625  GAction *action = nullptr;
3626 
3627  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
3628  g_return_val_if_fail (action_name != nullptr, nullptr);
3629 
3630  action = g_action_map_lookup_action (G_ACTION_MAP(window),
3631  action_name);
3632 
3633  return action;
3634 }
3635 
3636 GAction *
3638  const gchar *group_name,
3639  const gchar *action_name)
3640 {
3641  GAction *action = nullptr;
3642 
3643  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
3644  g_return_val_if_fail (group_name != nullptr, nullptr);
3645  g_return_val_if_fail (action_name != nullptr, nullptr);
3646 
3647  auto action_group = gtk_widget_get_action_group (GTK_WIDGET(window), group_name);
3648 
3649  if (action_group)
3650  action = g_action_map_lookup_action (G_ACTION_MAP(action_group), action_name);
3651 
3652  return action;
3653 }
3654 
3655 
3656 /* Retrieve a specific set of user interface actions from a window.
3657  * This function can be used to get an group of action to be
3658  * manipulated when the front page of a window has changed.
3659  */
3660 GSimpleActionGroup *
3661 gnc_main_window_get_action_group (GncMainWindow *window,
3662  const gchar *group_name)
3663 {
3664  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
3665  g_return_val_if_fail (group_name != nullptr, nullptr);
3666 
3667  auto action_group = gtk_widget_get_action_group (GTK_WIDGET(window), group_name);
3668  return (GSimpleActionGroup*)action_group;
3669 }
3670 
3671 GtkWidget *
3672 gnc_main_window_toolbar_find_tool_item (GncMainWindow *window, const gchar *action_name)
3673 {
3674  GncMainWindowPrivate *priv;
3675 
3676  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
3677  g_return_val_if_fail (action_name != nullptr, nullptr);
3678 
3679  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3680 
3681  return gnc_find_toolbar_item (priv->toolbar, action_name);
3682 }
3683 
3684 GtkWidget *
3685 gnc_main_window_menu_find_menu_item (GncMainWindow *window, const gchar *action_name)
3686 {
3687  GncMainWindowPrivate *priv;
3688  GtkWidget *menu_item;
3689 
3690  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
3691  g_return_val_if_fail (action_name != nullptr, nullptr);
3692 
3693  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3694 
3695  menu_item = GTK_WIDGET(g_hash_table_lookup (priv->display_item_hash, action_name));
3696 
3697  if (!menu_item)
3698  {
3700 
3701  g_hash_table_insert (priv->display_item_hash, g_strdup (action_name), menu_item);
3702  }
3703  return menu_item;
3704 }
3705 
3706 
3707 void
3709 {
3710  GncMainWindowPrivate *priv;
3711 
3712  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
3713 
3714  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3715 
3717 }
3718 
3719 
3720 gboolean
3722  const gchar *action_name,
3723  const gchar *label,
3724  const gchar *tooltip)
3725 {
3726  GncMainWindowPrivate *priv;
3727  gboolean found = false;
3728 
3729  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), false);
3730  g_return_val_if_fail (action_name != nullptr, false);
3731  g_return_val_if_fail (label != nullptr, false);
3732 
3733  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3734 
3736  nullptr, _(label), nullptr, _(tooltip));
3737 
3738  // add tooltip redirect call backs
3740  priv->menubar_model,
3741  priv->statusbar);
3742 
3743  return found;
3744 }
3745 
3746 void
3748  const gchar **action_names,
3749  gboolean vis)
3750 {
3751  GncMainWindowPrivate *priv;
3752 
3753  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
3754 
3755  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3756 
3757  for (gint i = 0; action_names[i]; i++)
3758  {
3759  GtkWidget *tool_item = gnc_find_toolbar_item (priv->toolbar, action_names[i]);
3760  GtkWidget *menu_item = gnc_main_window_menu_find_menu_item (window, action_names[i]);
3761 
3762  if (menu_item)
3763  {
3764  PINFO("Found menu_item %p with action name '%s', seting vis to '%s'",
3765  menu_item, action_names[i], vis ? "true" : "false");
3766  gtk_widget_set_visible (menu_item, vis);
3767  }
3768  else
3769  PINFO("Did not find menu_item with action name '%s' to set vis '%s'",
3770  action_names[i], vis ? "true" : "false");
3771 
3772  if (tool_item)
3773  {
3774  PINFO("Found tool_item %p with action name '%s', seting vis to '%s'",
3775  tool_item, action_names[i], vis ? "true" : "false");
3776  gtk_widget_set_visible (tool_item, vis);
3777  }
3778  else
3779  PINFO("Did not find tool_item with action name '%s' to set vis '%s'",
3780  action_names[i], vis ? "true" : "false");
3781  }
3782 }
3783 
3784 
3785 void
3786 gnc_main_window_init_short_names (GncMainWindow *window,
3787  GncToolBarShortNames *toolbar_labels)
3788 {
3789  GncMainWindowPrivate *priv;
3790 
3791  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
3792  g_return_if_fail (toolbar_labels != nullptr);
3793 
3794  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3795 
3796  gnc_plugin_init_short_names (priv->toolbar, toolbar_labels);
3797 }
3798 
3799 
3800 static void
3801 gnc_main_window_update_toolbar (GncMainWindow *window, GncPluginPage *page,
3802  const gchar *toolbar_qualifier)
3803 {
3804  GncMainWindowPrivate *priv;
3805  GtkBuilder *builder;
3806  GAction *action;
3807 
3808  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
3809  g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
3810 
3811  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3812 
3813  builder = gnc_plugin_page_get_builder (page);
3814 
3815  if (builder)
3816  {
3817  gchar *toolbar_name;
3818  gtk_container_remove (GTK_CONTAINER(priv->menu_dock), priv->toolbar);
3819 
3820  if (toolbar_qualifier)
3821  toolbar_name = g_strconcat ("mainwin-toolbar-", toolbar_qualifier, nullptr);
3822  else
3823  toolbar_name = g_strdup ("mainwin-toolbar");
3824 
3825  priv->toolbar = (GtkWidget *)gtk_builder_get_object (builder, toolbar_name);
3826 
3827  if (!priv->toolbar)
3828  priv->toolbar = (GtkWidget *)gtk_builder_get_object (builder, "mainwin-toolbar");
3829 
3830  g_object_set (priv->toolbar, "toolbar-style", GTK_TOOLBAR_BOTH, NULL);
3831  gtk_container_add (GTK_CONTAINER(priv->menu_dock), priv->toolbar);
3832  g_free (toolbar_name);
3833  }
3834 
3835  action = gnc_main_window_find_action (window, "ViewToolbarAction");
3836 
3837  // set visibility of toolbar
3838  if (action)
3839  {
3840  GVariant *state = g_action_get_state (G_ACTION(action));
3841  gtk_widget_set_visible (priv->toolbar, g_variant_get_boolean (state));
3842  g_variant_unref (state);
3843  }
3844  // add tooltip redirect call backs
3846 }
3847 
3848 
3849 void
3851  GncPluginPage *page,
3852  const gchar **ui_updates)
3853 {
3854  GncMainWindowPrivate *priv;
3855  const gchar *plugin_page_actions_group_name;
3856  GtkBuilder *builder;
3857  const gchar *menu_qualifier;
3858 
3859  GMenuModel *menu_model_part;
3860 #ifdef MAC_INTEGRATION
3861  auto theApp{static_cast<GtkosxApplication *>(g_object_new(GTKOSX_TYPE_APPLICATION, nullptr))};
3862 #endif
3863  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
3864  g_return_if_fail (page != nullptr);
3865  g_return_if_fail (ui_updates != nullptr);
3866 
3867  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3868 
3869  builder = gnc_plugin_page_get_builder (page);
3870 
3871  if (!builder)
3872  return;
3873 
3874  menu_qualifier = gnc_plugin_page_get_menu_qualifier (page);
3875 
3876  plugin_page_actions_group_name = gnc_plugin_page_get_simple_action_group_name (page);
3877 
3878  if (!plugin_page_actions_group_name)
3879  return;
3880 
3881  gtk_widget_insert_action_group (GTK_WIDGET(window), gnc_plugin_page_get_simple_action_group_name (page),
3882  G_ACTION_GROUP(gnc_plugin_page_get_action_group (page)));
3883 
3884  if ((g_strcmp0 (priv->previous_plugin_page_name,
3885  plugin_page_actions_group_name) == 0) &&
3886  (g_strcmp0 (priv->previous_menu_qualifier,
3887  menu_qualifier) == 0))
3888  return;
3889 
3890  priv->previous_plugin_page_name = plugin_page_actions_group_name;
3891  priv->previous_menu_qualifier = menu_qualifier;
3892 
3893  gnc_main_window_update_toolbar (window, page, menu_qualifier);
3894 
3895  // reset hash table and remove added menu items
3896  g_hash_table_remove_all (priv->display_item_hash);
3898  GNC_MENU_ATTRIBUTE_TEMPORARY);
3899 
3900  GncMenuModelSearch *gsm = g_new0 (GncMenuModelSearch, 1);
3901  for (gint i = 0; ui_updates[i]; i++)
3902  {
3903  gchar *menu_name;
3904 
3905  if (menu_qualifier)
3906  menu_name = g_strconcat (ui_updates[i], "-", menu_qualifier, nullptr);
3907  else
3908  menu_name = g_strdup (ui_updates[i]);
3909 
3910  menu_model_part = (GMenuModel *)gtk_builder_get_object (builder, menu_name);
3911 
3912  if (!menu_model_part)
3913  menu_model_part = (GMenuModel *)gtk_builder_get_object (builder, ui_updates[i]);
3914 
3915  gsm->search_action_label = nullptr;
3916  gsm->search_action_name = ui_updates[i];
3917  gsm->search_action_target = nullptr;
3918 
3919  if (gnc_menubar_model_find_item (priv->menubar_model, gsm))
3920  g_menu_insert_section (G_MENU(gsm->model), gsm->index,
3921  nullptr, G_MENU_MODEL(menu_model_part));
3922  else
3923  PERR("Could not find '%s' in menu model", ui_updates[i]);
3924 
3925  g_free (menu_name);
3926  }
3927 
3928  // add tooltip redirect call backs
3930 
3931  // need to add the accelerator keys
3933 #ifdef MAC_INTEGRATION
3934  gtkosx_application_sync_menubar (theApp);
3935  g_object_unref (theApp);
3936 #endif
3937  // need to signal menu has been changed
3938  g_signal_emit_by_name (window, "menu_changed", page);
3939 
3940  g_free (gsm);
3941 }
3942 
3943 
3944 static void
3945 gnc_main_window_update_tab_position (gpointer prefs, gchar *pref, gpointer user_data)
3946 {
3947  GncMainWindow *window;
3948  GtkPositionType position = GTK_POS_TOP;
3949  gint item = 0;
3950  GncMainWindowPrivate *priv;
3951  GAction *action;
3952 
3953  g_return_if_fail (GNC_IS_MAIN_WINDOW(user_data));
3954 
3955  window = GNC_MAIN_WINDOW(user_data);
3956 
3957  ENTER ("window %p", window);
3958 
3959  /* Ignore notification of the preference that is being set to false when
3960  * the choice of tab position changes. */
3961  if (pref && !gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, pref))
3962  return;
3963 
3964  if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM))
3965  {
3966  position = GTK_POS_BOTTOM;
3967  item = 1;
3968  }
3969  else if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT))
3970  {
3971  position = GTK_POS_LEFT;
3972  item = 2;
3973  }
3974  else if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT))
3975  {
3976  position = GTK_POS_RIGHT;
3977  item = 3;
3978  }
3979 
3980  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
3981  gtk_notebook_set_tab_pos (GTK_NOTEBOOK(priv->notebook), position);
3982 
3983  action = g_action_map_lookup_action (G_ACTION_MAP(window),
3984  "ViewTabPositionAction");
3985 
3986  g_signal_handlers_block_by_func (G_OBJECT(action),
3987  (gpointer)gnc_main_window_cmd_view_tab_position,
3988  window);
3989  g_action_change_state (G_ACTION(action), g_variant_new_int32 (item));
3990  g_signal_handlers_unblock_by_func (G_OBJECT(action),
3991  (gpointer)gnc_main_window_cmd_view_tab_position,
3992  window);
3993 
3994  gnc_main_window_update_tab_width (nullptr, (char*)GNC_PREF_TAB_WIDTH, nullptr);
3995 
3996  LEAVE ("");
3997 }
3998 
3999 /*
4000  * Based on code from Epiphany (src/ephy-window.c)
4001  */
4002 static void
4003 gnc_main_window_update_edit_actions_sensitivity (GncMainWindow *window, gboolean hide)
4004 {
4005  GncMainWindowPrivate *priv;
4006  GncPluginPage *page;
4007  GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW (window));
4008  GAction *action;
4009  gboolean can_copy = false, can_cut = false, can_paste = false;
4010 
4011  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4012  page = priv->current_page;
4013 
4014  if (page && GNC_PLUGIN_PAGE_GET_CLASS(page)->update_edit_menu_actions)
4015  {
4016  (GNC_PLUGIN_PAGE_GET_CLASS(page)->update_edit_menu_actions)(page, hide);
4017  return;
4018  }
4019 
4020  if (GTK_IS_EDITABLE (widget))
4021  {
4022  gboolean has_selection;
4023 
4024  has_selection = gtk_editable_get_selection_bounds
4025  (GTK_EDITABLE (widget), nullptr, nullptr);
4026 
4027  can_copy = has_selection;
4028  can_cut = has_selection;
4029  can_paste = TRUE;
4030  }
4031  else if (GTK_IS_TEXT_VIEW (widget))
4032  {
4033  gboolean has_selection;
4034  GtkTextBuffer *text_buffer;
4035 
4036  text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
4037  has_selection = gtk_text_buffer_get_selection_bounds
4038  (text_buffer, nullptr, nullptr);
4039 
4040  can_copy = has_selection;
4041  can_cut = has_selection;
4042  can_paste = TRUE;
4043  }
4044  else
4045  {
4046 #ifdef ORIGINAL_EPIPHANY_CODE
4047  /* For now we assume all actions are possible */
4048  can_copy = can_cut = can_paste = true;
4049 #else
4050  /* If its not a GtkEditable, we don't know what to do
4051  * with it. */
4052  can_copy = can_cut = can_paste = false;
4053 #endif
4054  }
4055  action = gnc_main_window_find_action (window, "EditCopyAction");
4056  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), can_copy);
4057 
4058  action = gnc_main_window_find_action (window, "EditCutAction");
4059  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), can_cut);
4060 
4061  action = gnc_main_window_find_action (window, "EditPasteAction");
4062  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), can_paste);
4063 }
4064 
4065 static void
4066 gnc_main_window_enable_edit_actions_sensitivity (GncMainWindow *window)
4067 {
4068  GAction *action;
4069 
4070  action = gnc_main_window_find_action (window, "EditCopyAction");
4071  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), true);
4072 
4073  action = gnc_main_window_find_action (window, "EditCutAction");
4074  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), true);
4075 
4076  action = gnc_main_window_find_action (window, "EditPasteAction");
4077  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), true);
4078 
4079 }
4080 
4081 static void
4082 gnc_main_window_edit_menu_show_cb (GtkWidget *menu,
4083  GncMainWindow *window)
4084 {
4085  gnc_main_window_update_edit_actions_sensitivity (window, FALSE);
4086 }
4087 
4088 static void
4089 gnc_main_window_edit_menu_hide_cb (GtkWidget *menu,
4090  GncMainWindow *window)
4091 {
4092  gnc_main_window_enable_edit_actions_sensitivity (window);
4093 }
4094 
4095 static void
4096 gnc_main_window_init_menu_updaters (GncMainWindow *window)
4097 {
4098  GtkWidget *edit_menu_item, *edit_menu;
4099 
4100  edit_menu_item = gnc_main_window_menu_find_menu_item (window, "EditAction");
4101 
4102  edit_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM(edit_menu_item));
4103 
4104  g_signal_connect (edit_menu, "show",
4105  G_CALLBACK(gnc_main_window_edit_menu_show_cb), window);
4106  g_signal_connect (edit_menu, "hide",
4107  G_CALLBACK(gnc_main_window_edit_menu_hide_cb), window);
4108 }
4109 
4110 /* This is used to prevent the tab having focus */
4111 static gboolean
4112 gnc_main_window_page_focus_in (GtkWidget *widget, GdkEvent *event,
4113  gpointer user_data)
4114 {
4115  auto window{static_cast<GncMainWindow *>(user_data)};
4117 
4118  g_signal_emit (window, main_window_signals[PAGE_CHANGED], 0, page);
4119  return FALSE;
4120 }
4121 
4122 static GAction *
4123 gnc_main_window_get_redirect (GncMainWindow *window, const gchar *action_name)
4124 {
4125  GncMainWindowPrivate *priv;
4126  GAction *action = nullptr;
4127  const gchar *group_name;
4128 
4129  g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window), nullptr);
4130  g_return_val_if_fail (action_name != nullptr, nullptr);
4131 
4132  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4133 
4135 
4136  PINFO("action anme is '%s', group_name is '%s'", action_name, group_name);
4137 
4138  if (group_name)
4139  {
4140  action = gnc_main_window_find_action_in_group (window, group_name, action_name);
4141 
4142  if (!action)
4144  }
4145 
4146  PINFO("Redirect action is %p for action anme '%s' and group_name '%s'",
4147  action, action_name, group_name);
4148  return action;
4149 }
4150 
4151 static void
4152 main_window_realize_cb (GtkWidget *widget, gpointer user_data)
4153 {
4154  GncMainWindow *window = (GncMainWindow*)user_data;
4155  GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4156 
4157  gnc_add_accelerator_keys_for_menu (GTK_WIDGET(priv->menubar), priv->menubar_model, priv->accel_group);
4158 
4159  /* need to signal menu has been changed, this will call the
4160  business function 'bind_extra_toolbuttons_visibility' */
4161  g_signal_emit_by_name (window, "menu_changed", nullptr);
4162 }
4163 
4164 static void
4165 gnc_main_window_setup_window (GncMainWindow *window)
4166 {
4167  GncMainWindowPrivate *priv;
4168  GtkWidget *main_vbox;
4169  GtkBuilder *builder;
4170  GncPluginManager *manager;
4171  GList *plugins;
4172  GError *error = nullptr;
4173  GAction *action;
4174 
4175  ENTER(" ");
4176 
4177  /* Catch window manager delete signal */
4178  g_signal_connect (G_OBJECT (window), "delete-event",
4179  G_CALLBACK (gnc_main_window_delete_event), window);
4180 
4181  /* Create widgets and add them to the window */
4182  main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4183  gtk_box_set_homogeneous (GTK_BOX (main_vbox), FALSE);
4184  gtk_widget_show (main_vbox);
4185  gtk_container_add (GTK_CONTAINER (window), main_vbox);
4186 
4187  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4188  priv->menu_dock = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4189  gtk_box_set_homogeneous (GTK_BOX (priv->menu_dock), FALSE);
4190  gtk_widget_show (priv->menu_dock);
4191  gtk_box_pack_start (GTK_BOX (main_vbox), priv->menu_dock,
4192  FALSE, TRUE, 0);
4193 
4194  priv->notebook = gtk_notebook_new ();
4195  g_object_set(G_OBJECT(priv->notebook),
4196  "scrollable", TRUE,
4197  "enable-popup", TRUE,
4198  (char *)nullptr);
4199  gtk_widget_show (priv->notebook);
4200  g_signal_connect (G_OBJECT (priv->notebook), "switch-page",
4201  G_CALLBACK (gnc_main_window_switch_page), window);
4202  g_signal_connect (G_OBJECT (priv->notebook), "page-reordered",
4203  G_CALLBACK (gnc_main_window_page_reordered), window);
4204  g_signal_connect (G_OBJECT (priv->notebook), "focus-in-event",
4205  G_CALLBACK (gnc_main_window_page_focus_in), window);
4206  gtk_box_pack_start (GTK_BOX (main_vbox), priv->notebook,
4207  TRUE, TRUE, 0);
4208 
4209  priv->statusbar = gtk_statusbar_new ();
4210  gtk_widget_show (priv->statusbar);
4211  gtk_box_pack_start (GTK_BOX (main_vbox), priv->statusbar,
4212  FALSE, TRUE, 0);
4213 
4214  priv->progressbar = gtk_progress_bar_new ();
4215  gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR(priv->progressbar), TRUE);
4216  gtk_progress_bar_set_text(GTK_PROGRESS_BAR(priv->progressbar), " ");
4217  gtk_widget_show (priv->progressbar);
4218  gtk_box_pack_start (GTK_BOX (priv->statusbar), priv->progressbar,
4219  FALSE, TRUE, 0);
4220  gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR(priv->progressbar),
4221  0.01);
4222 
4223  builder = gtk_builder_new ();
4224  gtk_builder_set_translation_domain (builder, PROJECT_NAME);
4225  gtk_builder_add_from_resource (builder, GNUCASH_RESOURCE_PREFIX "/gnc-main-window.ui", &error);
4226 
4227  if (error)
4228  {
4229  g_critical ("Failed to load, Error %s", error->message);
4230  g_error_free (error);
4231  return;
4232  }
4233 
4234  g_action_map_add_action_entries (G_ACTION_MAP(window),
4235  gnc_menu_actions,
4236  gnc_menu_n_actions,
4237  window);
4238 
4239  priv->menubar_model = (GMenuModel *)gtk_builder_get_object (builder, "mainwin-menu");
4240  priv->menubar = gtk_menu_bar_new_from_model (priv->menubar_model);
4241  gtk_container_add (GTK_CONTAINER(priv->menu_dock), priv->menubar);
4242  gtk_widget_show (GTK_WIDGET(priv->menubar));
4243 
4244  priv->toolbar = (GtkWidget *)gtk_builder_get_object (builder, "mainwin-toolbar");
4245  g_object_set (priv->toolbar, "toolbar-style", GTK_TOOLBAR_BOTH, NULL);
4246  gtk_container_add (GTK_CONTAINER(priv->menu_dock), GTK_WIDGET(priv->toolbar));
4247  gtk_widget_show (GTK_WIDGET(priv->toolbar));
4248 
4249  g_object_unref (builder);
4250 
4251  gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
4252  initially_insensitive_actions,
4253  FALSE);
4254  gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
4255  always_insensitive_actions,
4256  FALSE);
4257 
4258  gnc_main_window_set_vis_of_items_by_action (window, always_hidden_actions,
4259  false);
4260 
4261  gtk_widget_insert_action_group (GTK_WIDGET(window), "mainwin",
4262  G_ACTION_GROUP(window));
4263 
4264  gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
4265  GNC_PREF_TAB_POSITION_TOP,
4266  (gpointer)gnc_main_window_update_tab_position,
4267  window);
4268  gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
4269  GNC_PREF_TAB_POSITION_BOTTOM,
4270  (gpointer)gnc_main_window_update_tab_position,
4271  window);
4272  gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
4273  GNC_PREF_TAB_POSITION_LEFT,
4274  (gpointer)gnc_main_window_update_tab_position,
4275  window);
4276  gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
4277  GNC_PREF_TAB_POSITION_RIGHT,
4278  (gpointer)gnc_main_window_update_tab_position,
4279  window);
4280  gnc_main_window_update_tab_position (nullptr, nullptr, window);
4281 
4282  gnc_main_window_init_menu_updaters (window);
4283 
4284  /* Disable the Transaction menu */
4285  action = gnc_main_window_find_action (window, "TransactionAction");
4286  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), false);
4287  /* Disable the Schedule menu */
4288  action = gnc_main_window_find_action (window, "ScheduledAction");
4289  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), false);
4290 
4291  /* Now update the "eXtensions" menu */
4292  if (!gnc_prefs_is_extra_enabled())
4293  {
4294  action = gnc_main_window_find_action (window, "ExtensionsAction");
4295  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), false);
4296  }
4297 
4298  /* GncPluginManager stuff */
4299  manager = gnc_plugin_manager_get ();
4300  plugins = gnc_plugin_manager_get_plugins (manager);
4301  g_list_foreach (plugins, gnc_main_window_add_plugin, window);
4302  g_list_free (plugins);
4303 
4304  g_signal_connect (G_OBJECT (manager), "plugin-added",
4305  G_CALLBACK (gnc_main_window_plugin_added), window);
4306  g_signal_connect (G_OBJECT (manager), "plugin-removed",
4307  G_CALLBACK (gnc_main_window_plugin_removed), window);
4308 
4309  // need to add the accelerator keys this way, mainly for --nofile
4310  g_signal_connect (G_OBJECT(window), "realize",
4311  G_CALLBACK(main_window_realize_cb), window);
4312 
4313  LEAVE(" ");
4314 }
4315 
4316 #ifdef MAC_INTEGRATION
4317 /* Event handlers for the shutdown process. Gnc_quartz_shutdown is
4318  * connected to NSApplicationWillTerminate, the last chance to do
4319  * anything before quitting. The problem is that it's launched from a
4320  * CFRunLoop, not a g_main_loop, and if we call anything that would
4321  * affect the main_loop we get an assert that we're in a subidiary
4322  * loop.
4323  */
4324 static void
4325 gnc_quartz_shutdown (GtkosxApplication *theApp, gpointer data)
4326 {
4327  /* Do Nothing. It's too late. */
4328 }
4329 /* Should quit responds to NSApplicationBlockTermination; returning TRUE means
4330  * "don't terminate", FALSE means "do terminate". gnc_main_window_quit() queues
4331  * a timer that starts an orderly shutdown in 250ms and if we tell macOS it's OK
4332  * to quit GnuCash gets terminated instead of doing its orderly shutdown,
4333  * leaving the book locked.
4334  */
4335 static gboolean
4336 gnc_quartz_should_quit (GtkosxApplication *theApp, GncMainWindow *window)
4337 {
4339  gnc_main_window_quit (window);
4340  return TRUE;
4341 }
4342 /* Enable GtkMenuItem accelerators */
4343 static gboolean
4344 can_activate_cb(GtkWidget *widget, guint signal_id, gpointer data)
4345 {
4346  //return gtk_widget_is_sensitive (widget);
4347  return TRUE;
4348 }
4349 
4350 static void
4351 gnc_quartz_set_menu (GncMainWindow* window)
4352 {
4353  GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4354  auto theApp{static_cast<GtkosxApplication *>(g_object_new(GTKOSX_TYPE_APPLICATION, nullptr))};
4355  GtkWidget *item = nullptr;
4356  GClosure *quit_closure;
4357 
4358  gtk_widget_hide (priv->menubar);
4359  gtk_widget_set_no_show_all (priv->menubar, true);
4360 
4361  gtkosx_application_set_menu_bar (theApp, GTK_MENU_SHELL(priv->menubar));
4362 
4363  // File Quit
4364  item = gnc_main_window_menu_find_menu_item (window, "FileQuitAction");
4365  if (item)
4366  gtk_widget_hide (GTK_WIDGET(item));
4367 
4368  quit_closure = g_cclosure_new (G_CALLBACK (gnc_quartz_should_quit),
4369  window, NULL);
4370  gtk_accel_group_connect (priv->accel_group, 'q', GDK_META_MASK,
4371  GTK_ACCEL_MASK, quit_closure);
4372 
4373 
4374  // Help About
4375  item = gnc_main_window_menu_find_menu_item (window, "HelpAboutAction");
4376  if (item)
4377  {
4378  gtk_widget_hide (item);
4379  gtkosx_application_insert_app_menu_item (theApp, GTK_WIDGET(item), 0);
4380  }
4381 
4382  // Edit Preferences
4383  item = gnc_main_window_menu_find_menu_item (window, "EditPreferencesAction");
4384  if (item)
4385  {
4386  gtk_widget_hide (GTK_WIDGET(item));
4387  gtkosx_application_insert_app_menu_item (theApp, GTK_WIDGET(item), 2);
4388  }
4389 
4390  // Help Menu
4391  item = gnc_main_window_menu_find_menu_item (window, "HelpAction");
4392  if (item)
4393  gtkosx_application_set_help_menu (theApp, GTK_MENU_ITEM(item));
4394  // Windows Menu
4395  item = gnc_main_window_menu_find_menu_item (window, "WindowsAction");
4396  if (item)
4397  gtkosx_application_set_window_menu (theApp, GTK_MENU_ITEM(item));
4398 
4399  g_signal_connect (theApp, "NSApplicationBlockTermination",
4400  G_CALLBACK(gnc_quartz_should_quit), window);
4401 
4402  g_signal_connect (priv->menubar, "can-activate-accel",
4403  G_CALLBACK (can_activate_cb), nullptr);
4404 
4405  gtkosx_application_set_use_quartz_accelerators (theApp, FALSE);
4406  g_object_unref (theApp);
4407 }
4408 #endif //MAC_INTEGRATION
4409 
4410 /* Callbacks */
4411 
4424 static gboolean
4425 gnc_main_window_show_summarybar (GncMainWindow *window, GAction *action)
4426 {
4427  GVariant *state;
4428  gboolean visible;
4429 
4430  if (action == nullptr)
4431  action = g_action_map_lookup_action (G_ACTION_MAP(window),
4432  "ViewSummaryAction");
4433  if (action == nullptr)
4434  return TRUE;
4435 
4436  state = g_action_get_state (G_ACTION(action));
4437 
4438  visible = g_variant_get_boolean (state);
4439 
4440  g_variant_unref (state);
4441 
4442  return visible;
4443 }
4444 
4454 static void
4455 gnc_main_window_switch_page (GtkNotebook *notebook,
4456  gpointer *notebook_page,
4457  gint pos,
4458  GncMainWindow *window)
4459 {
4460  GncMainWindowPrivate *priv;
4461  GtkWidget *child;
4462  GncPluginPage *page;
4463  gboolean visible;
4464 
4465  ENTER("Notebook %p, page, %p, index %d, window %p",
4466  notebook, notebook_page, pos, window);
4467  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
4468 
4469  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4470  if (priv->current_page != nullptr)
4471  {
4472  page = priv->current_page;
4473  gnc_plugin_page_unselected (page);
4474  }
4475 
4476  child = gtk_notebook_get_nth_page (notebook, pos);
4477  if (child)
4478  {
4479  page = static_cast<GncPluginPage*>(g_object_get_data (G_OBJECT (child), PLUGIN_PAGE_LABEL));
4480  }
4481  else
4482  {
4483  page = nullptr;
4484  }
4485 
4486  priv->current_page = page;
4487 
4488  if (page != nullptr)
4489  {
4490  /* Update the user interface (e.g. menus and toolbars */
4492  visible = gnc_main_window_show_summarybar (window, nullptr);
4494 
4495  /* Allow page specific actions */
4496  gnc_plugin_page_selected (page);
4497  gnc_window_update_status (GNC_WINDOW(window), page);
4498 
4499  /* Update the page reference info */
4500  priv->usage_order = g_list_remove (priv->usage_order, page);
4501  priv->usage_order = g_list_prepend (priv->usage_order, page);
4502  }
4503 
4504  gnc_plugin_set_actions_enabled (G_ACTION_MAP(window),
4505  multiple_page_actions,
4506  g_list_length (priv->installed_pages) > 1);
4507 
4508  gnc_main_window_update_title(window);
4509 #ifndef MAC_INTEGRATION
4510  gnc_main_window_update_menu_item(window);
4511 #endif
4512  g_signal_emit (window, main_window_signals[PAGE_CHANGED], 0, page);
4513  LEAVE(" ");
4514 }
4515 
4522 static void
4523 gnc_main_window_page_reordered (GtkNotebook *notebook,
4524  GtkWidget *child,
4525  guint pos,
4526  GncMainWindow *window)
4527 {
4528  GncMainWindowPrivate *priv;
4529  GncPluginPage *page;
4530  GList *old_link;
4531 
4532  ENTER("Notebook %p, child %p, index %d, window %p",
4533  notebook, child, pos, window);
4534  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
4535 
4536  if (!child) return;
4537 
4538  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4539 
4540  page = static_cast<GncPluginPage*>(g_object_get_data (G_OBJECT (child), PLUGIN_PAGE_LABEL));
4541  if (!page) return;
4542 
4543  old_link = g_list_find (priv->installed_pages, page);
4544  if (!old_link) return;
4545 
4546  priv->installed_pages = g_list_delete_link (priv->installed_pages,
4547  old_link);
4548  priv->installed_pages = g_list_insert (priv->installed_pages,
4549  page, pos);
4550 
4551  LEAVE(" ");
4552 }
4553 
4554 static void
4555 gnc_main_window_plugin_added (GncPlugin *manager,
4556  GncPlugin *plugin,
4557  GncMainWindow *window)
4558 {
4559  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
4560  g_return_if_fail (GNC_IS_PLUGIN (plugin));
4561 
4562  gnc_plugin_add_to_window (plugin, window, window_type);
4563 }
4564 
4565 static void
4566 gnc_main_window_plugin_removed (GncPlugin *manager,
4567  GncPlugin *plugin,
4568  GncMainWindow *window)
4569 {
4570  g_return_if_fail (GNC_IS_MAIN_WINDOW (window));
4571  g_return_if_fail (GNC_IS_PLUGIN (plugin));
4572 
4573  gnc_plugin_remove_from_window (plugin, window, window_type);
4574 }
4575 
4576 
4577 /* Command callbacks */
4578 static void
4579 gnc_main_window_cmd_redirect (GSimpleAction *simple,
4580  GVariant *parameter,
4581  gpointer user_data)
4582 {
4583  GncMainWindow *window = (GncMainWindow*)user_data;
4584  GAction *redirect_action;
4585 
4586  PINFO("Redirect action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));
4587 
4588  redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));
4589 
4590  if (redirect_action)
4591  {
4592  PINFO("Found action %p", redirect_action);
4593  g_action_activate (redirect_action, nullptr);
4594  return;
4595  }
4596 }
4597 
4598 static void
4599 gnc_main_window_cmd_page_setup (GSimpleAction *simple,
4600  GVariant *parameter,
4601  gpointer user_data)
4602 {
4603  GncMainWindow *window = (GncMainWindow*)user_data;
4604  GtkWindow *gtk_window;
4605 
4606  g_return_if_fail(GNC_IS_MAIN_WINDOW(window));
4607 
4608  gtk_window = gnc_window_get_gtk_window(GNC_WINDOW(window));
4609  gnc_ui_page_setup(gtk_window);
4610 }
4611 
4612 gboolean
4614 {
4615  QofBook *book = gnc_get_current_book ();
4616  gboolean use_split_action_for_num_before =
4618  gint use_read_only_threshold_before =
4620  gboolean use_split_action_for_num_after;
4621  gint use_read_only_threshold_after;
4622  gboolean return_val = FALSE;
4623  GList *results = nullptr, *iter;
4624 
4625  if (!options) return return_val;
4626 
4627  results = gnc_option_db_commit (options);
4628  for (iter = results; iter; iter = iter->next)
4629  {
4630  GtkWidget *dialog = gtk_message_dialog_new(gnc_ui_get_main_window (nullptr),
4631  (GtkDialogFlags)0,
4632  GTK_MESSAGE_ERROR,
4633  GTK_BUTTONS_OK,
4634  "%s",
4635  (char*)iter->data);
4636  gtk_dialog_run(GTK_DIALOG(dialog));
4637  gtk_widget_destroy(dialog);
4638  g_free (iter->data);
4639  }
4640  g_list_free (results);
4641  qof_book_begin_edit (book);
4642  qof_book_save_options (book, gnc_option_db_save, options, TRUE);
4643  use_split_action_for_num_after =
4645 
4646  // mark cached value as invalid so we get new value
4647  qof_book_reset_num_days_autoreadonly_cache (book);
4648  use_read_only_threshold_after = qof_book_get_num_days_autoreadonly (book);
4649 
4650  if (use_split_action_for_num_before != use_split_action_for_num_after)
4651  {
4653  use_split_action_for_num_after);
4654  return_val = TRUE;
4655  }
4656  if (use_read_only_threshold_before != use_read_only_threshold_after)
4657  return_val = TRUE;
4658 
4659  qof_book_commit_edit (book);
4660  return return_val;
4661 }
4662 
4663 static void
4664 gnc_book_options_dialog_apply_cb(GncOptionsDialog * optionwin,
4665  gpointer user_data)
4666 {
4667  auto options{static_cast<GncOptionDB *>(user_data)};
4668 
4669  if (!options) return;
4670 
4672  gnc_gui_refresh_all ();
4673 }
4674 
4675 static void
4676 gnc_book_options_dialog_close_cb(GncOptionsDialog * optionwin,
4677  gpointer user_data)
4678 {
4679  auto options{static_cast<GncOptionDB *>(user_data)};
4680 
4681  delete optionwin;
4682  gnc_option_db_destroy(options);
4683 }
4684 
4688 void
4690 {
4691  gnc_suspend_gui_refresh ();
4692  if (num_action)
4693  {
4694  /* Set a feature flag in the book for use of the split action field as number.
4695  * This will prevent older GnuCash versions that don't support this feature
4696  * from opening this file. */
4697  gnc_features_set_used (gnc_get_current_book(),
4698  GNC_FEATURE_NUM_FIELD_SOURCE);
4699  }
4700  gnc_book_option_num_field_source_change (num_action);
4701  gnc_resume_gui_refresh ();
4702 }
4703 
4704 static gboolean
4705 show_handler (const char *class_name, gint component_id,
4706  gpointer user_data, gpointer iter_data)
4707 {
4708  auto optwin{static_cast<GncOptionsDialog*>(user_data)};
4709 
4710  if (!optwin)
4711  return(FALSE);
4712 
4713  auto widget = optwin->get_widget();
4714  gtk_window_present(GTK_WINDOW(widget));
4715  return(TRUE);
4716 }
4717 
4718 GtkWidget *
4719 gnc_book_options_dialog_cb (gboolean modal, gchar *title, GtkWindow* parent)
4720 {
4721  auto book = gnc_get_current_book ();
4722 
4723  auto options = gnc_option_db_new();
4724  gnc_option_db_book_options(options);
4725  qof_book_load_options (book, gnc_option_db_load, options);
4726  gnc_option_db_clean (options);
4727 
4728  /* Only allow one Book Options dialog if called from file->properties
4729  menu */
4730  if (gnc_forall_gui_components(DIALOG_BOOK_OPTIONS_CM_CLASS,
4731  show_handler, nullptr))
4732  {
4733  return nullptr;
4734  }
4735  auto optionwin = new GncOptionsDialog (modal,
4736  (title ? title : _( "Book Options")),
4737  DIALOG_BOOK_OPTIONS_CM_CLASS, parent);
4738  optionwin->build_contents(options);
4739  optionwin->set_book_help_cb();
4740  optionwin->set_apply_cb(gnc_book_options_dialog_apply_cb,
4741  (gpointer)options);
4742  optionwin->set_close_cb ( gnc_book_options_dialog_close_cb,
4743  (gpointer)options);
4744  if (modal)
4746  return optionwin->get_widget();
4747 }
4748 
4749 static void
4750 gnc_main_window_cmd_file_properties (GSimpleAction *simple,
4751  GVariant *parameter,
4752  gpointer user_data)
4753 {
4754  GncMainWindow *window = (GncMainWindow*)user_data;
4755  gnc_book_options_dialog_cb (FALSE, nullptr, GTK_WINDOW (window));
4756 }
4757 
4758 static void
4759 gnc_main_window_cmd_file_close (GSimpleAction *simple,
4760  GVariant *parameter,
4761  gpointer user_data)
4762 {
4763  GncMainWindow *window = (GncMainWindow*)user_data;
4764  GncMainWindowPrivate *priv;
4765  GncPluginPage *page;
4766 
4767  g_return_if_fail(GNC_IS_MAIN_WINDOW(window));
4768 
4769  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4770  page = priv->current_page;
4772 }
4773 
4774 static void
4775 gnc_main_window_cmd_file_quit (GSimpleAction *simple,
4776  GVariant *parameter,
4777  gpointer user_data)
4778 {
4779  GncMainWindow *window = (GncMainWindow*)user_data;
4781  return;
4782 
4783  gnc_main_window_quit(window);
4784 }
4785 
4786 static void
4787 gnc_main_window_cmd_edit_cut (GSimpleAction *simple,
4788  GVariant *parameter,
4789  gpointer user_data)
4790 {
4791  GncMainWindow *window = (GncMainWindow*)user_data;
4792  GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW(window));
4793  GAction *redirect_action;
4794 
4795  PINFO("Copy action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));
4796 
4797  redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));
4798 
4799  if (redirect_action)
4800  {
4801  PINFO("Found action %p", redirect_action);
4802  g_action_activate (redirect_action, nullptr);
4803  return;
4804  }
4805 
4806  if (GTK_IS_EDITABLE(widget))
4807  {
4808  gtk_editable_cut_clipboard (GTK_EDITABLE(widget));
4809  }
4810  else if (GTK_IS_TEXT_VIEW(widget))
4811  {
4812  GtkTextBuffer *text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
4813  GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET(widget),
4814  GDK_SELECTION_CLIPBOARD);
4815  gboolean editable = gtk_text_view_get_editable (GTK_TEXT_VIEW(widget));
4816 
4817  if (clipboard)
4818  gtk_text_buffer_cut_clipboard (text_buffer, clipboard, editable);
4819  }
4820 }
4821 
4822 static void
4823 gnc_main_window_cmd_edit_copy (GSimpleAction *simple,
4824  GVariant *parameter,
4825  gpointer user_data)
4826 {
4827  GncMainWindow *window = (GncMainWindow*)user_data;
4828  GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW(window));
4829  GAction *redirect_action;
4830 
4831  PINFO("Copy action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));
4832 
4833  redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));
4834 
4835  if (redirect_action)
4836  {
4837  PINFO("Found action %p", redirect_action);
4838  g_action_activate (redirect_action, nullptr);
4839  return;
4840  }
4841 
4842  if (GTK_IS_EDITABLE(widget))
4843  {
4844  gtk_editable_copy_clipboard (GTK_EDITABLE(widget));
4845  }
4846  else if (GTK_IS_TEXT_VIEW(widget))
4847  {
4848  GtkTextBuffer *text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
4849  GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET(widget),
4850  GDK_SELECTION_CLIPBOARD);
4851  if (clipboard)
4852  gtk_text_buffer_copy_clipboard (text_buffer, clipboard);
4853  }
4854 }
4855 
4856 static void
4857 gnc_main_window_cmd_edit_paste (GSimpleAction *simple,
4858  GVariant *parameter,
4859  gpointer user_data)
4860 {
4861  GncMainWindow *window = (GncMainWindow*)user_data;
4862  GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW(window));
4863  GAction *redirect_action;
4864 
4865  PINFO("Paste action_is %p, name is '%s'", simple, g_action_get_name (G_ACTION(simple)));
4866 
4867  redirect_action = gnc_main_window_get_redirect (window, g_action_get_name (G_ACTION(simple)));
4868 
4869  if (redirect_action)
4870  {
4871  PINFO("Found action %p", redirect_action);
4872  g_action_activate (redirect_action, nullptr);
4873  return;
4874  }
4875 
4876  if (GTK_IS_EDITABLE(widget))
4877  {
4878  gtk_editable_paste_clipboard (GTK_EDITABLE(widget));
4879  }
4880  else if (GTK_IS_TEXT_VIEW(widget))
4881  {
4882  auto clipboard = gtk_widget_get_clipboard (widget, GDK_SELECTION_CLIPBOARD);
4883 
4884  if (clipboard)
4885  {
4886  auto text_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(widget));
4887  auto editable = gtk_text_view_get_editable (GTK_TEXT_VIEW(widget));
4888  gtk_text_buffer_paste_clipboard (text_buffer, clipboard, nullptr,
4889  editable);
4890  }
4891  }
4892 }
4893 
4894 static void
4895 gnc_main_window_cmd_edit_preferences (GSimpleAction *simple,
4896  GVariant *parameter,
4897  gpointer user_data)
4898 {
4899  GncMainWindow *window = (GncMainWindow*)user_data;
4900  gnc_preferences_dialog (GTK_WINDOW(window));
4901 }
4902 
4903 static void
4904 gnc_main_window_cmd_view_refresh (GSimpleAction *simple,
4905  GVariant *parameter,
4906  gpointer user_data)
4907 {
4908 }
4909 
4910 static void
4911 gnc_main_window_cmd_actions_reset_warnings (GSimpleAction *simple,
4912  GVariant *parameter,
4913  gpointer user_data)
4914 {
4915  GncMainWindow *window = (GncMainWindow*)user_data;
4916  gnc_reset_warnings_dialog(GTK_WINDOW(window));
4917 }
4918 
4919 static void
4920 gnc_main_window_cmd_actions_rename_page (GSimpleAction *simple,
4921  GVariant *parameter,
4922  gpointer user_data)
4923 {
4924  GncMainWindow *window = (GncMainWindow*)user_data;
4925  GncMainWindowPrivate *priv;
4926  GncPluginPage *page;
4927  GtkWidget *label, *entry;
4928 
4929  ENTER(" ");
4930  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4931  page = priv->current_page;
4932  if (!page)
4933  {
4934  LEAVE("No current page");
4935  return;
4936  }
4937 
4938  if (!main_window_find_tab_items(window, page, &label, &entry))
4939  {
4940  LEAVE("can't find required widgets");
4941  return;
4942  }
4943 
4944  gtk_entry_set_text(GTK_ENTRY(entry), gtk_label_get_text(GTK_LABEL(label)));
4945  gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
4946  gtk_widget_hide(label);
4947  gtk_widget_show(entry);
4948  gtk_widget_grab_focus(entry);
4949  LEAVE("opened for editing");
4950 }
4951 
4952 static void
4953 gnc_main_window_cmd_view_toolbar (GSimpleAction *simple,
4954  GVariant *parameter,
4955  gpointer user_data)
4956 {
4957  GncMainWindow *window = (GncMainWindow*)user_data;
4958  GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4959  GVariant *state = g_action_get_state (G_ACTION(simple));
4960 
4961  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4962 
4963  g_action_change_state (G_ACTION(simple), g_variant_new_boolean (!g_variant_get_boolean (state)));
4964 
4965  if (!g_variant_get_boolean (state))
4966  gtk_widget_show (priv->toolbar);
4967  else
4968  gtk_widget_hide (priv->toolbar);
4969 
4970  g_variant_unref (state);
4971 }
4972 
4973 static void
4974 gnc_main_window_cmd_view_summary (GSimpleAction *simple,
4975  GVariant *parameter,
4976  gpointer user_data)
4977 {
4978  GncMainWindow *window = (GncMainWindow*)user_data;
4979  GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
4980  GList *item;
4981  gboolean visible;
4982 
4983  visible = gnc_main_window_show_summarybar (window, G_ACTION(simple));
4984 
4985  g_action_change_state (G_ACTION(simple), g_variant_new_boolean (!visible));
4986 
4987  for (item = priv->installed_pages; item; item = g_list_next (item))
4988  {
4989  gnc_plugin_page_show_summarybar (static_cast<GncPluginPage*>(item->data),
4990  !visible);
4991  }
4992 }
4993 
4994 static void
4995 gnc_main_window_cmd_view_statusbar (GSimpleAction *simple,
4996  GVariant *parameter,
4997  gpointer user_data)
4998 {
4999  GncMainWindow *window = (GncMainWindow*)user_data;
5000  GncMainWindowPrivate *priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5001  GVariant *state = g_action_get_state (G_ACTION(simple));
5002 
5003  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5004 
5005  g_action_change_state (G_ACTION(simple), g_variant_new_boolean (!g_variant_get_boolean (state)));
5006 
5007  if (!g_variant_get_boolean (state))
5008  gtk_widget_show (priv->statusbar);
5009  else
5010  gtk_widget_hide (priv->statusbar);
5011 
5012  g_variant_unref (state);
5013 }
5014 
5015 static void
5016 gnc_main_window_cmd_window_new (GSimpleAction *simple,
5017  GVariant *paramter,
5018  gpointer user_data)
5019 {
5020  GncMainWindow *new_window;
5021 
5022  /* Create the new window */
5023  ENTER(" ");
5024  new_window = gnc_main_window_new ();
5025  gtk_widget_show(GTK_WIDGET(new_window));
5026  LEAVE(" ");
5027 }
5028 
5029 static void
5030 gnc_main_window_cmd_window_move_page (GSimpleAction *simple,
5031  GVariant *paramter,
5032  gpointer user_data)
5033 {
5034  GncMainWindow *window = (GncMainWindow*)user_data;
5035  GncMainWindowPrivate *priv;
5036  GncMainWindow *new_window;
5037  GncPluginPage *page;
5038  GtkNotebook *notebook;
5039  GtkWidget *tab_widget, *menu_widget;
5040 
5041  ENTER("action %p, window %p", simple, window);
5042 
5043  /* Setup */
5044  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5045  page = priv->current_page;
5046  if (!page)
5047  {
5048  LEAVE("invalid page");
5049  return;
5050  }
5051  if (!page->notebook_page)
5052  {
5053  LEAVE("invalid notebook_page");
5054  return;
5055  }
5056 
5057 #ifndef MAC_INTEGRATION
5058  if (gnc_list_length_cmp (active_windows, gnc_main_window_max_number) == 0)
5059  gnc_info_dialog (GTK_WINDOW(window), "%s",
5060  _("The maximum number of window menu entries reached, no more entries will be added."));
5061 #endif /* !MAC_INTEGRATION */
5062 
5063  notebook = GTK_NOTEBOOK (priv->notebook);
5064  tab_widget = gtk_notebook_get_tab_label (notebook, page->notebook_page);
5065  menu_widget = gtk_notebook_get_menu_label (notebook, page->notebook_page);
5066 
5067  // Remove the page_changed signal callback
5068  gnc_plugin_page_disconnect_page_changed (GNC_PLUGIN_PAGE(page));
5069 
5070  /* Ref the page components, then remove it from its old window */
5071  g_object_ref(page);
5072  g_object_ref(tab_widget);
5073  g_object_ref(menu_widget);
5074  g_object_ref(page->notebook_page);
5075  gnc_main_window_disconnect(window, page);
5076 
5077  /* Create the new window */
5078  new_window = gnc_main_window_new ();
5079  gtk_widget_show(GTK_WIDGET(new_window));
5080 
5081  /* Now add the page to the new window */
5082  gnc_main_window_connect (new_window, page, tab_widget, menu_widget);
5083 
5084  /* Unref the page components now that we're done */
5085  g_object_unref(page->notebook_page);
5086  g_object_unref(menu_widget);
5087  g_object_unref(tab_widget);
5088  g_object_unref(page);
5089 
5090  /* just a little debugging. :-) */
5091  DEBUG("Moved page %p from window %p to new window %p",
5092  page, window, new_window);
5093  DEBUG("Old window current is %p, new window current is %p",
5094  priv->current_page, priv->current_page);
5095 
5096  LEAVE("page moved");
5097 }
5098 
5099 static void
5100 gnc_main_window_cmd_view_tab_position (GSimpleAction *simple,
5101  GVariant *parameter,
5102  gpointer user_data)
5103 {
5104  gint item = g_variant_get_int32 (parameter);
5105 
5106  g_action_change_state (G_ACTION(simple), parameter);
5107 
5108  if (item < 0 || item > 3)
5109  return;
5110 
5111  if (item != 0 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_TOP))
5112  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_TOP, FALSE);
5113 
5114  if (item != 1 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM))
5115  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM, FALSE);
5116 
5117  if (item != 2 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT))
5118  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT, FALSE);
5119 
5120  if (item != 3 && gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT))
5121  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT, FALSE);
5122 
5123  switch (item)
5124  {
5125  case 0:
5126  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_TOP, TRUE);
5127  break;
5128 
5129  case 1:
5130  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_BOTTOM, TRUE);
5131  break;
5132 
5133  case 2:
5134  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_LEFT, TRUE);
5135  break;
5136 
5137  case 3:
5138  gnc_prefs_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_TAB_POSITION_RIGHT, TRUE);
5139  break;
5140  }
5141 
5142 }
5143 
5144 #ifndef MAC_INTEGRATION
5145 static void
5146 gnc_main_window_cmd_window_raise (GSimpleAction *simple,
5147  GVariant *parameter,
5148  gpointer user_data)
5149 {
5150  GncMainWindow *window = (GncMainWindow*)user_data;
5151  GncMainWindow *new_window;
5152  gint item;
5153 
5154  g_return_if_fail (G_IS_SIMPLE_ACTION(simple));
5155  g_return_if_fail (GNC_IS_MAIN_WINDOW(window));
5156 
5157  item = g_variant_get_int32 (parameter);
5158 
5159  ENTER("action %p, window %p, item %d", simple, window, item);
5160 
5161  g_action_change_state (G_ACTION(simple), parameter);
5162 
5163  new_window = static_cast<GncMainWindow*>(g_list_nth_data (active_windows, item));
5164  gtk_window_present (GTK_WINDOW(new_window));
5165 
5166  /* revert the change in the radio group
5167  * impossible while handling "changed" (G_SIGNAL_NO_RECURSE) */
5168  g_idle_add ((GSourceFunc)gnc_main_window_update_radio_button, window);
5169  LEAVE(" ");
5170 }
5171 #endif /* !MAC_INTEGRATION */
5172 
5173 static void
5174 gnc_main_window_cmd_help_tutorial (GSimpleAction *simple,
5175  GVariant *paramter,
5176  gpointer user_data)
5177 {
5178  GncMainWindow *window = (GncMainWindow*)user_data;
5179  gnc_gnome_help (GTK_WINDOW(window), DF_GUIDE, NULL);
5180 }
5181 
5182 static void
5183 gnc_main_window_cmd_help_contents (GSimpleAction *simple,
5184  GVariant *paramter,
5185  gpointer user_data)
5186 {
5187  GncMainWindow *window = (GncMainWindow*)user_data;
5188  gnc_gnome_help (GTK_WINDOW(window), DF_MANUAL, NULL);
5189 }
5190 
5200 static gchar *
5201 get_file (const gchar *partial)
5202 {
5203  gchar *filename, *text = nullptr;
5204  gsize length;
5205 
5206  filename = gnc_filepath_locate_doc_file(partial);
5207  if (filename && g_file_get_contents(filename, &text, &length, nullptr))
5208  {
5209  if (length)
5210  {
5211  g_free(filename);
5212  return text;
5213  }
5214  g_free(text);
5215  }
5216  g_free (filename);
5217  return nullptr;
5218 }
5219 
5220 
5230 static gchar **
5231 get_file_strsplit (const gchar *partial)
5232 {
5233  gchar *text, **lines;
5234 
5235  text = get_file(partial);
5236  if (!text)
5237  return nullptr;
5238 
5239  lines = g_strsplit_set(text, "\r\n", -1);
5240  g_free(text);
5241  return lines;
5242 }
5249 static gboolean
5250 url_signal_cb (GtkAboutDialog *dialog, gchar *uri, gpointer data)
5251 {
5252  gnc_launch_doclink (GTK_WINDOW(dialog), uri);
5253  return TRUE;
5254 }
5255 
5256 #define DEFAULT_MARGIN 5
5257 
5258 static void
5259 set_text_cursor (GdkWindow *win, GdkCursorType type)
5260 {
5261  if (!win && !type)
5262  return;
5263 
5264  GdkCursor *current = gdk_window_get_cursor (win);
5265  if (type == gdk_cursor_get_cursor_type (current))
5266  return;
5267 
5268  GdkCursor *cur = gdk_cursor_new_for_display (gdk_window_get_display (win), type);
5269  gdk_window_set_cursor (win, cur);
5270 }
5271 
5272 static gboolean
5273 textview_motion_notify_cb (GtkWidget *textview,
5274  GdkEventMotion *event,
5275  gpointer user_data)
5276 {
5277  if ((event->state & GDK_BUTTON1_MASK) ||
5278  gtk_text_buffer_get_has_selection (gtk_text_view_get_buffer
5279  (GTK_TEXT_VIEW(textview))))
5280  return false;
5281 
5282  GtkTextIter iter;
5283  gboolean valid = gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW(textview),
5284  &iter, event->x, event->y);
5285 
5286  if (valid && (event->y > DEFAULT_MARGIN))
5287  {
5288  GSList *tt_list = gtk_text_iter_get_tags (&iter);
5289 
5290  if (tt_list)
5291  {
5292  GtkTextTag *tt = (GtkTextTag*)g_slist_nth_data (tt_list, 0);
5293 
5294  if (g_object_get_data (G_OBJECT(tt), "link"))
5295  set_text_cursor (event->window, GDK_HAND1);
5296  else
5297  set_text_cursor (event->window, GDK_XTERM);
5298 
5299  g_slist_free (tt_list);
5300  }
5301  else
5302  set_text_cursor (event->window, GDK_XTERM);
5303  }
5304  else
5305  set_text_cursor (event->window, GDK_XTERM);
5306 
5307  return true;
5308 }
5309 
5310 static gboolean
5311 textview_url_activate (GtkTextTag *tag,
5312  GObject *object,
5313  GdkEvent *event,
5314  GtkTextIter *iter,
5315  gpointer user_data)
5316 {
5317  GdkEventButton *event_button = (GdkEventButton*)event;
5318 
5319  if ((event->type == GDK_BUTTON_RELEASE) &&
5320  (event_button->button == 1) &&
5321  !gtk_text_buffer_get_has_selection (gtk_text_view_get_buffer
5322  (GTK_TEXT_VIEW (object))) &&
5323  (event_button->y > DEFAULT_MARGIN))
5324  {
5325  gchar *link = (gchar*)g_object_get_data (G_OBJECT(tag), "link");
5326  PINFO("Link is '%s'", link);
5327  gchar *escaped_uri = g_uri_escape_string (link, ":/.\\", true);
5328  PINFO("Escaped Link is '%s'", escaped_uri);
5329  gnc_launch_doclink (GTK_WINDOW(user_data), escaped_uri);
5330  g_free (escaped_uri);
5331 
5332  return true;
5333  }
5334  return false;
5335 }
5336 
5337 static gint
5338 get_max_text_width (GtkTextView *textview, std::vector<EnvPaths> ep_vec)
5339 {
5340  gint max_text_width = 0;
5341  for (const auto& ep : ep_vec)
5342  {
5343  gint text_width;
5344  gchar *env_name = g_strconcat (ep.env_name, ":", nullptr);
5345 
5346  PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET(textview),
5347  env_name);
5348 
5349  pango_layout_get_pixel_size (layout, &text_width, nullptr);
5350  g_object_unref (layout);
5351  g_free (env_name);
5352 
5353  max_text_width = MAX(max_text_width, text_width);
5354  }
5355  return max_text_width;
5356 }
5357 
5358 static GtkTextTag *
5359 create_left_margin_text_tag (GtkTextView *textview,
5360  gchar *lmargin_tag,
5361  const gchar *text,
5362  gint max_width)
5363 {
5364  if (!lmargin_tag)
5365  return nullptr;
5366 
5367  GtkTextTag *lmargin_tt = gtk_text_tag_new (lmargin_tag);
5368  int text_width;
5369 
5370  PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET(textview), text);
5371  pango_layout_get_pixel_size (layout, &text_width, nullptr);
5372  g_object_unref (layout);
5373 
5374  g_object_set (G_OBJECT(lmargin_tt), "left_margin",
5375  DEFAULT_MARGIN + max_width - text_width, nullptr);
5376 
5377  return lmargin_tt;
5378 }
5379 
5380 static GdkRGBA
5381 get_link_color (void)
5382 {
5383  GdkRGBA link_color;
5384  GtkWidget *dummy_link_button = gtk_link_button_new_with_label ("https://www.gnucash.org", "Dummy");
5385  GtkStyleContext *context = gtk_widget_get_style_context (GTK_WIDGET(dummy_link_button));
5386  gtk_style_context_get_color (context, GTK_STATE_FLAG_LINK, &link_color);
5387 
5388  return link_color;
5389 }
5390 
5391 static GtkTextTag *
5392 create_url_text_tag (GtkDialog *dialog,
5393  GdkRGBA link_color,
5394  gchar *url_tag,
5395  const gchar *uri)
5396 {
5397  if (!url_tag)
5398  return nullptr;
5399 
5400  GtkTextTag *url_tt = gtk_text_tag_new (url_tag);
5401  g_object_set (G_OBJECT(url_tt), "underline", PANGO_UNDERLINE_SINGLE,
5402  "underline-set", true, nullptr);
5403  g_object_set (G_OBJECT(url_tt), "foreground-rgba", &link_color, nullptr);
5404 
5405  g_object_set_data_full (G_OBJECT(url_tt), "link", g_strdup (uri), g_free);
5406 
5407  g_signal_connect (G_OBJECT(url_tt), "event",
5408  G_CALLBACK(textview_url_activate), dialog);
5409  return url_tt;
5410 }
5411 
5412 static void
5413 add_textview_css_class (GtkTextView *textview)
5414 {
5415  GdkRGBA color;
5416  GtkStyleContext *stylectxt = gtk_widget_get_style_context (GTK_WIDGET(textview));
5417  gtk_style_context_get_color (stylectxt, GTK_STATE_FLAG_NORMAL, &color);
5418 
5419  if (gnc_is_dark_theme (&color))
5420  gtk_style_context_add_class (stylectxt, "gnc-class-textview-dark");
5421  else
5422  gtk_style_context_add_class (stylectxt, "gnc-class-textview");
5423 }
5424 
5425 static void
5426 add_about_paths (GtkDialog *dialog)
5427 {
5428  GtkWidget *page_vbox = gnc_get_dialog_widget_from_id (dialog, "page_vbox");
5429 
5430  if (!page_vbox)
5431  {
5432  PWARN("Unable to find AboutDialog 'page_vbox' Widget");
5433  return;
5434  }
5435 
5436  GtkWidget *textview = gtk_text_view_new ();
5437  GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(textview));
5438  GtkTextTagTable *ttt = gtk_text_buffer_get_tag_table (buffer);
5439  GtkTextIter iter;
5440 
5441  std::vector<EnvPaths> ep_vec = gnc_list_all_paths ();
5442  int ep_size = (int)ep_vec.size();
5443  int row = 1;
5444 
5445  GdkRGBA link_color = get_link_color ();
5446  gint max_text_width = get_max_text_width (GTK_TEXT_VIEW(textview), ep_vec);
5447 
5448  add_textview_css_class (GTK_TEXT_VIEW(textview));
5449 
5450  gtk_text_view_set_left_margin (GTK_TEXT_VIEW(textview), DEFAULT_MARGIN);
5451  gtk_text_view_set_right_margin (GTK_TEXT_VIEW(textview), DEFAULT_MARGIN);
5452  gtk_text_view_set_top_margin (GTK_TEXT_VIEW(textview), DEFAULT_MARGIN);
5453  gtk_text_view_set_bottom_margin (GTK_TEXT_VIEW(textview), DEFAULT_MARGIN);
5454  gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(textview), GTK_WRAP_NONE);
5455 
5456  gtk_text_buffer_create_tag (buffer, "italic", "style", PANGO_STYLE_ITALIC, nullptr);
5457 
5458  gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
5459 
5460  for (const auto& ep : ep_vec)
5461  {
5462  gchar *env_name = g_strconcat (ep.env_name, ":", nullptr);
5463  const gchar *uri = gnc_uri_create_uri ("file", nullptr, 0, nullptr, nullptr, ep.env_path);
5464  gchar *display_uri = gnc_doclink_get_unescaped_just_uri (uri);
5465 
5466  gchar *url_tag = g_strdup_printf ("%s%d", "url_tag", row);
5467  gchar *lmargin_tag = g_strdup_printf ("%s%d", "lmargin_tag", row);
5468 
5469  gtk_text_tag_table_add (ttt, create_left_margin_text_tag (GTK_TEXT_VIEW(textview),
5470  lmargin_tag,
5471  env_name,
5472  max_text_width));
5473  gtk_text_tag_table_add (ttt, create_url_text_tag (dialog,
5474  link_color,
5475  url_tag,
5476  uri));
5477 
5478  gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, env_name, -1, lmargin_tag, nullptr);
5479  gtk_text_buffer_insert (buffer, &iter, " ", -1);
5480  gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, display_uri, -1, url_tag, nullptr);
5481 
5482  g_free (url_tag);
5483  g_free (lmargin_tag);
5484  g_free (display_uri);
5485  g_free (env_name);
5486 
5487  if (ep.modifiable)
5488  {
5489  gtk_text_buffer_insert (buffer, &iter, " ", -1);
5490  gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, _("(User modifiable)"), -1, "italic", nullptr);
5491  }
5492 
5493  if (row != ep_size)
5494  gtk_text_buffer_insert (buffer, &iter, "\n", -1);
5495 
5496  row++;
5497  }
5498  gtk_text_view_set_editable (GTK_TEXT_VIEW(textview), false);
5499 
5500  g_signal_connect (G_OBJECT(textview), "motion-notify-event",
5501  G_CALLBACK(textview_motion_notify_cb), nullptr);
5502 
5503  gtk_container_add_with_properties (GTK_CONTAINER(page_vbox), textview,
5504  "position", 1, nullptr);
5505  gtk_widget_show_all (page_vbox);
5506 }
5507 
5510 static void
5511 gnc_main_window_cmd_help_about (GSimpleAction *simple,
5512  GVariant *paramter,
5513  gpointer user_data)
5514 {
5515  GncMainWindow *window = (GncMainWindow*)user_data;
5516  /* Translators: %s will be replaced with the current year */
5517  gchar *copyright = g_strdup_printf(_("Copyright © 1997-%s The GnuCash contributors."),
5518  GNC_VCS_REV_YEAR);
5519  gchar **authors = get_file_strsplit("AUTHORS");
5520  gchar **documenters = get_file_strsplit("DOCUMENTERS");
5521  gchar *license = get_file("LICENSE");
5522  GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
5523  GdkPixbuf *logo = gtk_icon_theme_load_icon (icon_theme,
5524  GNC_ICON_APP,
5525  128,
5526  GTK_ICON_LOOKUP_USE_BUILTIN,
5527  nullptr);
5528  gchar *version = g_strdup_printf ("%s: %s\n%s: %s\nFinance::Quote: %s",
5529  _("Version"), gnc_version(),
5530  _("Build ID"), gnc_build_id(),
5533  : "-");
5534  GtkDialog *dialog = GTK_DIALOG (gtk_about_dialog_new ());
5535  g_object_set(G_OBJECT(dialog), "authors", authors, "documenters",
5536  documenters, "comments",
5537  _("Accounting for personal and small business finance."),
5538  "copyright", copyright, "license", license, "logo", logo,
5539  "name", "GnuCash",
5540  /* Translators: the following string will be shown in
5541  * Help->About->Credits It's intended to be generated
5542  * automatically before each release so there's
5543  * usually no need to modify it, but if you do be
5544  * sure to include a newline (\\n) after each credit
5545  * so that it displays one per line.
5546  */
5547  "translator-credits", _("translator-credits\n"),
5548  "version", version,
5549  "website", PACKAGE_URL,
5550  "website-label", _("Visit the GnuCash website."),
5551  nullptr);
5552 
5553  g_free(version);
5554  g_free(copyright);
5555  if (license)
5556  g_free(license);
5557  if (documenters)
5558  g_strfreev(documenters);
5559  if (authors)
5560  g_strfreev(authors);
5561  g_object_unref (logo);
5562  g_signal_connect (dialog, "activate-link",
5563  G_CALLBACK (url_signal_cb), nullptr);
5564 
5565  // Add environment paths
5566  add_about_paths (dialog);
5567 
5568  /* Set dialog to resize. */
5569  gtk_window_set_resizable(GTK_WINDOW (dialog), TRUE);
5570 
5571  gtk_window_set_transient_for (GTK_WINDOW (dialog),
5572  GTK_WINDOW (window));
5573  gtk_dialog_run (dialog);
5574  gtk_widget_destroy (GTK_WIDGET (dialog));
5575 }
5576 
5577 
5578 /************************************************************
5579  * *
5580  ************************************************************/
5581 
5582 void
5584 {
5585  GList *window_iter;
5586 #ifdef MAC_INTEGRATION
5587  auto theApp{static_cast<GtkosxApplication *>(g_object_new(GTKOSX_TYPE_APPLICATION, nullptr))};
5588 #endif
5589  for (window_iter = active_windows; window_iter != nullptr; window_iter = window_iter->next)
5590  {
5591  gtk_widget_show(GTK_WIDGET(window_iter->data));
5592  }
5593 #ifdef MAC_INTEGRATION
5594  g_signal_connect(theApp, "NSApplicationWillTerminate",
5595  G_CALLBACK(gnc_quartz_shutdown), nullptr);
5596  gtkosx_application_ready(theApp);
5597  g_object_unref (theApp);
5598 #endif
5599 }
5600 
5601 GtkWindow *
5602 gnc_ui_get_gtk_window (GtkWidget *widget)
5603 {
5604  GtkWidget *toplevel;
5605 
5606  if (!widget)
5607  return nullptr;
5608 
5609  toplevel = gtk_widget_get_toplevel (widget);
5610  if (toplevel && GTK_IS_WINDOW (toplevel))
5611  return GTK_WINDOW (toplevel);
5612  else
5613  return nullptr;
5614 }
5615 
5616 GtkWindow *
5617 gnc_ui_get_main_window (GtkWidget *widget)
5618 {
5619  GList *window;
5620 
5621  GtkWindow *toplevel = gnc_ui_get_gtk_window (widget);
5622  while (toplevel && !GNC_IS_MAIN_WINDOW (toplevel))
5623  toplevel = gtk_window_get_transient_for(toplevel);
5624 
5625  if (toplevel)
5626  return toplevel;
5627 
5628  for (window = active_windows; window; window = window->next)
5629  if (gtk_window_is_active (GTK_WINDOW (window->data)))
5630  return static_cast<GtkWindow*>(window->data);
5631 
5632  for (window = active_windows; window; window = window->next)
5633  if (gtk_widget_get_mapped (GTK_WIDGET(window->data)))
5634  return static_cast<GtkWindow*>(window->data);
5635 
5636  return nullptr;
5637 }
5638 
5639 
5645 static GtkWindow *
5646 gnc_main_window_get_gtk_window (GncWindow *window)
5647 {
5648  g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window), nullptr);
5649  return GTK_WINDOW(window);
5650 }
5651 
5652 
5658 static GtkWidget *
5659 gnc_main_window_get_statusbar (GncWindow *window_in)
5660 {
5661  GncMainWindowPrivate *priv;
5662  GncMainWindow *window;
5663 
5664  g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window_in), nullptr);
5665 
5666  window = GNC_MAIN_WINDOW(window_in);
5667  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5668  return priv->statusbar;
5669 }
5670 
5671 
5677 static GtkWidget *
5678 gnc_main_window_get_progressbar (GncWindow *window_in)
5679 {
5680  GncMainWindowPrivate *priv;
5681  GncMainWindow *window;
5682 
5683  g_return_val_if_fail (GNC_IS_MAIN_WINDOW (window_in), nullptr);
5684 
5685  window = GNC_MAIN_WINDOW(window_in);
5686  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5687  return priv->progressbar;
5688 }
5689 
5690 
5696 static GtkWidget *
5697 gnc_main_window_get_menubar (GncWindow *window)
5698 {
5699  GncMainWindowPrivate *priv;
5700 
5701  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
5702 
5703  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5704 
5705  return priv->menubar;
5706 }
5707 
5713 static GtkWidget *
5714 gnc_main_window_get_toolbar (GncWindow *window)
5715 {
5716  GncMainWindowPrivate *priv;
5717 
5718  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
5719 
5720  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5721 
5722  return priv->toolbar;
5723 }
5724 
5730 static GMenuModel *
5731 gnc_main_window_get_menubar_model (GncWindow *window)
5732 {
5733  GncMainWindowPrivate *priv;
5734 
5735  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
5736 
5737  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5738 
5739  return priv->menubar_model;
5740 }
5741 
5747 static GtkAccelGroup *
5748 gnc_main_window_get_accel_group (GncWindow *window)
5749 {
5750  GncMainWindowPrivate *priv;
5751 
5752  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
5753 
5754  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5755 
5756  return priv->accel_group;
5757 }
5758 
5763 static void
5764 gnc_window_main_window_init (GncWindowInterface *iface)
5765 {
5766  iface->get_gtk_window = gnc_main_window_get_gtk_window;
5767  iface->get_statusbar = gnc_main_window_get_statusbar;
5768  iface->get_progressbar = gnc_main_window_get_progressbar;
5769  iface->get_menubar = gnc_main_window_get_menubar;
5770  iface->get_toolbar = gnc_main_window_get_toolbar;
5771  iface->get_menubar_model = gnc_main_window_get_menubar_model;
5772  iface->get_accel_group = gnc_main_window_get_accel_group;
5773 }
5774 
5775 
5776 /* Set the window where all progressbar updates should occur. This
5777  * is a wrapper around the gnc_window_set_progressbar_window()
5778  * function.
5779  */
5780 void
5782 {
5783  GncWindow *gncwin;
5784  gncwin = GNC_WINDOW(window);
5785  gnc_window_set_progressbar_window(gncwin);
5786 }
5787 
5788 
5801 static void
5802 do_popup_menu (GncPluginPage *page, GdkEventButton *event)
5803 {
5804  GtkBuilder *builder;
5805  GMenuModel *menu_model;
5806  GtkWidget *menu;
5807  const gchar *menu_qualifier;
5808  gchar *popup_menu_name;
5809  GncWindow* gnc_window;
5810  GtkWidget *statusbar;
5811 
5812  g_return_if_fail (GNC_IS_PLUGIN_PAGE(page));
5813 
5814  ENTER("page %p, event %p", page, event);
5815 
5816  gnc_window = GNC_WINDOW(GNC_PLUGIN_PAGE(page)->window);
5817 
5818  statusbar = gnc_window_get_statusbar (gnc_window);
5819 
5820  builder = gnc_plugin_page_get_builder (page);
5821 
5822  menu_qualifier = gnc_plugin_page_get_menu_popup_qualifier (page);
5823 
5824  if (!menu_qualifier)
5825  menu_qualifier = gnc_plugin_page_get_menu_qualifier (page);
5826 
5827  if (builder == nullptr)
5828  {
5829  LEAVE("no builder");
5830  return;
5831  }
5832 
5833  if (menu_qualifier)
5834  popup_menu_name = g_strconcat ("mainwin-popup-", menu_qualifier, nullptr);
5835  else
5836  popup_menu_name = g_strdup ("mainwin-popup");
5837 
5838  menu_model = (GMenuModel *)gtk_builder_get_object (builder, popup_menu_name);
5839 
5840  if (!menu_model)
5841  menu_model = (GMenuModel *)gtk_builder_get_object (builder, "mainwin-popup");
5842 
5843  menu = gtk_menu_new_from_model (menu_model);
5844 
5845  if (!menu)
5846  {
5847  LEAVE("no menu");
5848  return;
5849  }
5850 
5851  // add tooltip redirect call backs
5852  gnc_plugin_add_menu_tooltip_callbacks (menu, menu_model, statusbar);
5853 
5854  gtk_menu_attach_to_widget (GTK_MENU(menu), GTK_WIDGET(page->window), nullptr);
5855  gtk_menu_popup_at_pointer (GTK_MENU(menu), (GdkEvent *) event);
5856 
5857  g_free (popup_menu_name);
5858 
5859  LEAVE(" ");
5860 }
5861 
5862 
5876 gboolean
5878  GncPluginPage *page)
5879 {
5880  ENTER("widget %p, page %p", widget, page);
5881  do_popup_menu(page, nullptr);
5882  LEAVE(" ");
5883  return TRUE;
5884 }
5885 
5886 
5887 /* Callback function invoked when the user clicks in the content of
5888  * any Gnucash window. If this was a "right-click" then Gnucash will
5889  * popup the contextual menu.
5890  */
5891 gboolean
5892 gnc_main_window_button_press_cb (GtkWidget *whatever,
5893  GdkEventButton *event,
5894  GncPluginPage *page)
5895 {
5896  g_return_val_if_fail(GNC_IS_PLUGIN_PAGE(page), FALSE);
5897 
5898  ENTER("widget %p, event %p, page %p", whatever, event, page);
5899  /* Ignore double-clicks and triple-clicks */
5900  if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
5901  {
5902  do_popup_menu(page, event);
5903  LEAVE("menu shown");
5904  return TRUE;
5905  }
5906 
5907  LEAVE("other click");
5908  return FALSE;
5909 }
5910 
5911 void
5913  gboolean sensitive)
5914 {
5915  for (auto tmp = active_windows; tmp; tmp = g_list_next(tmp))
5916  {
5917  auto action{gnc_main_window_find_action (static_cast<GncMainWindow*>(tmp->data), action_name)};
5918  g_simple_action_set_enabled (G_SIMPLE_ACTION(action), sensitive);
5919  }
5920 }
5921 
5922 GMenuModel *
5923 gnc_main_window_get_menu_model (GncMainWindow *window)
5924 {
5925  GncMainWindowPrivate *priv;
5926 
5927  g_return_val_if_fail (GNC_IS_MAIN_WINDOW(window), nullptr);
5928 
5929  priv = GNC_MAIN_WINDOW_GET_PRIVATE(window);
5930 
5931  return priv->menubar_model;
5932 }
5933 
5934 gboolean
5935 gnc_main_window_just_plugin_prefs (GncMainWindow* window)
5936 {
5937  return window->just_plugin_prefs;
5938 }
5939 
Holds all of the options for a book, report, or stylesheet, organized by GncOptionSections.
void gnc_preferences_dialog(GtkWindow *parent)
This function creates the preferences dialog and presents it to the user.
GncPluginPage * gnc_plugin_page_recreate_page(GtkWidget *window, const gchar *page_type, GKeyFile *key_file, const gchar *page_group)
This function looks up a specific plugin type by name, and then calls a plugin specific function to c...
GtkWidget * statusbar
A pointer to the status bar at the bottom edge of the window.
Functions to load, save and get gui state.
void gnc_menubar_model_remove_items_with_attrib(GMenuModel *menu_model, const gchar *attrib)
Remove GMenuModel entries based on having an attribute value equal to attrib, it does not matter what...
gboolean gnc_plugin_page_has_books(GncPluginPage *page)
Query a page to see if it has a reference to any book.
gboolean gnc_plugin_page_get_use_new_window(GncPluginPage *page)
Retrieve the "use new window" setting associated with this page.
void gnc_option_db_clean(GncOptionDB *odb)
Reset all ui_items to the option value.
gboolean gnc_plugin_page_finish_pending(GncPluginPage *page)
Tell a page to finish any outstanding activities.
void gnc_main_window_restore_all_windows(const GKeyFile *keyfile)
Restore the persistent state of all windows.
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_book_load_options(QofBook *book, GncOptionLoad load_cb, GncOptionDB *odb)
Load a GncOptionsDB from KVP data.
Definition: qofbook.cpp:1334
GtkApplicationWindow gtk_application_window
The parent object for a main window.
void gnc_plugin_page_destroy_widget(GncPluginPage *plugin_page)
Destroy the display widget that corresponds to this plugin.
GtkAccelGroup * accel_group
The accelerator group for the window.
The instance data structure for a content plugin.
void qof_book_set_dirty_cb(QofBook *book, QofBookDirtyCB cb, gpointer user_data)
Set the function to call when a book transitions from clean to dirty, or vice versa.
Definition: qofbook.cpp:426
const GList * gnc_gobject_tracking_get_list(const gchar *name)
Get a list of all known objects of a specified type.
gboolean gnc_main_window_button_press_cb(GtkWidget *whatever, GdkEventButton *event, GncPluginPage *page)
Callback function invoked when the user clicks in the content of any Gnucash window.
gulong gnc_prefs_register_cb(const char *group, const gchar *pref_name, gpointer func, gpointer user_data)
Register a callback that gets triggered when the given preference changes.
Definition: gnc-prefs.cpp:127
GtkWindow * gnc_ui_get_main_window(GtkWidget *widget)
Get a pointer to the final GncMainWindow widget is rooted in.
gint index
Index number in active windows list.
utility functions for the GnuCash UI
#define PINFO(format, args...)
Print an informational note.
Definition: qoflog.h:256
void gnc_main_window_set_vis_of_items_by_action(GncMainWindow *window, const gchar **action_names, gboolean vis)
Show or hide menu and toolbar items based on a NULL terminated list of action names.
functions to query various version related strings that were set at build time.
gtk helper routines.
void gnc_plugin_page_merge_actions(GncPluginPage *page)
Add the actions for a content page to the specified window.
QofBackendError
The errors that can be reported to the GUI & other front-end users.
Definition: qofbackend.h:57
void gnc_main_window_menu_add_accelerator_keys(GncMainWindow *window)
Scan the main window menu and add accelerator keys to main window accelerator group.
const gchar * gnc_plugin_page_get_page_long_name(GncPluginPage *page)
Retrieve the long name of this page.
gulong gnc_prefs_get_reg_negative_color_pref_id(void)
Get and Set registered preference id for register negative_color_pref.
Definition: gnc-prefs.cpp:401
void gnc_gobject_tracking_forget(GObject *object)
Tell gnucash to remember this object in the database.
time64 qof_book_get_session_dirty_time(const QofBook *book)
Retrieve the earliest modification time on the book.
Definition: qofbook.cpp:420
GMenuModel * gnc_main_window_get_menu_model(GncMainWindow *window)
Return the GMenuModel for the main window menu bar.
gboolean gnc_menubar_model_find_item(GMenuModel *menu_model, GncMenuModelSearch *gsm)
Find a GtkMenu item from the action name.
This data structure allows the passing of the tab width and whether the tab layout is on the left or ...
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.
gint qof_book_get_num_days_autoreadonly(const QofBook *book)
Returns the number of days for auto-read-only transactions.
Definition: qofbook.cpp:986
GMenuModel * menubar_model
The menubar_model.
Functions that are supported by all types of windows.
void gnc_features_set_used(QofBook *book, const gchar *feature)
Indicate that the current book uses the given feature.
gboolean qof_book_use_split_action_for_num_field(const QofBook *book)
Returns TRUE if this book uses split action field as the &#39;Num&#39; field, FALSE if it uses transaction nu...
GSimpleActionGroup * gnc_plugin_page_get_action_group(GncPluginPage *page)
Retrieve the GSimpleActionGroup object associated with this page.
GtkWidget * toolbar
The toolbar.
void gnc_plugin_add_toolbar_tooltip_callbacks(GtkWidget *toolbar, GtkWidget *statusbar)
This function adds the tooltip callbacks to make the tooltips appear in the status bar...
Definition: gnc-plugin.c:299
GKeyFile helper routines.
GtkBuilder * gnc_plugin_page_get_builder(GncPluginPage *page)
Retrieve the GtkBuilder object associated with this page.
gboolean restoring_pages
Set when restoring plugin pages.
gboolean gnc_is_dark_theme(GdkRGBA *fg_color)
Return whether the current gtk theme is a dark one.
gint pos[2]
Array for window position.
Plugin management functions for the GnuCash UI.
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_plugin_add_to_window(GncPlugin *plugin, GncMainWindow *window, GQuark type)
Add the specified plugin from the specified window.
Definition: gnc-plugin.c:133
GtkWidget * window
The window that contains the display widget for this plugin.
gint event_handler_id
The identifier for this window&#39;s engine event handler.
gchar * gnc_uri_get_path(const gchar *uri)
Extracts the path part from a uri.
gboolean window_quitting
Set to TRUE when quitting from this window.
const gchar * gnc_plugin_page_get_page_color(GncPluginPage *page)
Retrieve the color of this page.
gboolean gnc_main_window_is_restoring_pages(GncMainWindow *window)
Check if the main window is restoring the plugin pages.
GtkWidget * gnc_book_options_dialog_cb(gboolean modal, gchar *title, GtkWindow *parent)
Opens the Book Options dialog.
C public interface for the Options Database.
void gnc_plugin_page_set_page_long_name(GncPluginPage *page, const char *name)
Set the long name of this page.
void gnc_main_window_merge_actions(GncMainWindow *window, const gchar *group_name, GActionEntry *actions, guint n_actions, const gchar **ui_updates, const gchar *ui_filename, gpointer user_data)
Add a set of actions to the specified window.
void gnc_engine_add_commit_error_callback(EngineCommitErrorCallback cb, gpointer data)
Set a callback function to be called in case an engine commit fails.
Definition: gnc-engine.cpp:166
void gnc_shutdown(int exit_status)
Shutdown gnucash.
void gnc_ui_page_setup(GtkWindow *parent)
Run a page setup dialog and save the resulting GtkPageSetup in a static variable. ...
Definition: print-session.c:76
void gnc_main_window_foreach_page(GncMainWindowPageFunc fn, gpointer user_data)
Iterator function to walk all pages in all windows, calling the specified function for each 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.
void gnc_main_window_unmerge_actions(GncMainWindow *window, const gchar *group_name)
Remove a set of actions from the specified window.
const gchar * gnc_plugin_page_get_menu_qualifier(GncPluginPage *page)
Retrieve the menu qualifier for this page.
#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 gnc_option_db_save(GncOptionDB *odb, QofBook *book, gboolean clear_options)
Save the GncOptionDB contents into a book&#39;s options store.
GtkWindow * gnc_ui_get_gtk_window(GtkWidget *widget)
Get a pointer to the widget&#39;s immediate top level GtkWindow.
void gnc_main_window_show_all_windows(void)
Shows all main windows.
const gchar * gnc_plugin_page_get_menu_popup_qualifier(GncPluginPage *page)
Retrieve the menu popup qualifier for this page.
void gnc_book_option_num_field_source_change_cb(gboolean num_action)
Calls gnc_book_option_num_field_source_change to initiate registered callbacks when num_field_source ...
void gnc_main_window_display_page(GncPluginPage *page)
Bring the window containing the specified page to the top of the window stack, then switch the notebo...
void gnc_main_window_save_all_windows(GKeyFile *keyfile)
Save the persistent state of all windows.
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.
gint gnc_prefs_get_int(const gchar *group, const gchar *pref_name)
Get an integer value from the preferences backend.
Functions for adding content to a window.
void gnc_plugin_add_menu_tooltip_callbacks(GtkWidget *menubar, GMenuModel *menubar_model, GtkWidget *statusbar)
This function adds the tooltip callbacks to make the tooltips appear in the status bar...
Definition: gnc-plugin.c:268
G_DEFINE_TYPE_WITH_CODE(GncMainWindow, gnc_main_window, GTK_TYPE_APPLICATION_WINDOW, G_IMPLEMENT_INTERFACE(GNC_TYPE_WINDOW, gnc_window_main_window_init)) static guint main_window_signals[LAST_SIGNAL]
A holding place for all the signals generated by the main window code.
GtkWidget * gnc_get_dialog_widget_from_id(GtkDialog *dialog, const gchar *id)
Find the Widget defined by &#39;id&#39; in the dialog.
gint qof_event_register_handler(QofEventHandler handler, gpointer user_data)
Register a handler for events.
Definition: qofevent.cpp:73
void main_window_update_page_long_name(GncPluginPage *page, const gchar *long_name_in)
Update the long name of the page in the main window.
#define PWARN(format, args...)
Log a warning.
Definition: qoflog.h:250
void gnc_prefs_remove_cb_by_id(const gchar *group, guint id)
Remove a function that was registered for a callback when a specific preference in the settings group...
Definition: gnc-prefs.cpp:152
void gnc_gobject_tracking_remember(GObject *object)
Tell gnucash to remember this object in the database.
void qof_book_save_options(QofBook *book, GncOptionSave save_cb, GncOptionDB *odb, gboolean clear)
Save a GncOptionsDB back to the book&#39;s KVP.
Definition: qofbook.cpp:1340
gboolean visible
Whether or not the GAction should be visible.
void gnc_options_dialog_set_new_book_option_values(GncOptionDB *odb)
Set the initial values of new book options to values specified in user preferences.
GAction * gnc_main_window_find_action_in_group(GncMainWindow *window, const gchar *group_name, const gchar *action_name)
Find the GAction in a specific action group for window.
gboolean gnc_main_window_is_quitting(GncMainWindow *window)
Check if the main window is quitting.
void gnc_main_window_all_action_set_sensitive(const gchar *action_name, gboolean sensitive)
Change the sensitivity of a command in all windows.
QofBook * qof_session_get_book(const QofSession *session)
Returns the QofBook of this session.
Definition: qofsession.cpp:574
#define QOF_CHECK_TYPE(obj, type)
return TRUE if object is of the given type
Definition: qofid.h:102
void main_window_update_page_color(GncPluginPage *page, const gchar *color_in)
Update the color on the page tabs in the main window.
gchar * gnc_uri_normalize_uri(const gchar *uri, gboolean allow_password)
Composes a normalized uri starting from any uri (filename, db spec,...).
gchar * gnc_filepath_locate_doc_file(const gchar *name)
Given a documentation file name, find the file in the doc directory associated with this application...
gint QofEventId
Define the type of events allowed.
Definition: qofevent.h:45
Gobject helper routines.
void qof_book_mark_session_saved(QofBook *book)
The qof_book_mark_saved() routine marks the book as having been saved (to a file, to a database)...
Definition: qofbook.cpp:383
void gnc_plugin_page_set_use_new_window(GncPluginPage *page, gboolean use_new)
Set the "use new window" setting associated with this page.
void gnc_gnome_help(GtkWindow *parent, const char *file_name, const char *anchor)
Launch the systems default help browser, gnome&#39;s yelp for linux, and open to a given link within a gi...
GAction * gnc_main_window_find_action(GncMainWindow *window, const gchar *action_name)
Find the GAction in the main window.
gboolean gnc_prefs_set_bool(const gchar *group, const gchar *pref_name, gboolean value)
Store a boolean value into the preferences backend.
Definition: gnc-prefs.cpp:277
GtkWidget * notebook
The notebook containing all the pages in this window.
void gnc_plugin_page_disconnect_page_changed(GncPluginPage *page)
Disconnect the page_changed_id signal callback.
void gnc_option_db_load(GncOptionDB *odb, QofBook *book)
Load a book&#39;s options into the GncOptionDB.
gchar * action_name
The name of the GAction to be updated.
void gnc_option_db_destroy(GncOptionDB *odb)
Destruct and release a GncOptionDB.
gboolean gnc_plugin_page_has_book(GncPluginPage *page, QofBook *book)
Query a page to see if it has a reference to a given book.
char * gnc_print_time64(time64 time, const char *format)
print a time64 as a date string per format
Definition: gnc-date.cpp:370
gboolean gnc_main_window_popup_menu_cb(GtkWidget *widget, GncPluginPage *page)
Callback function invoked when the user requests that Gnucash popup the contextual menu via the keybo...
The instance private data structure for an embedded window object.
The instance data structure for a main window object.
GtkWidget * gnc_menubar_model_find_menu_item(GMenuModel *menu_model, GtkWidget *menu, const gchar *action_name)
Find a GtkMenu item from the action name.
gboolean gnc_book_options_dialog_apply_helper(GncOptionDB *options)
Processes selected options in the Book Options dialog: checks book_currency and use_split_action_for_...
void qof_event_unregister_handler(gint handler_id)
Unregister an event handler.
Definition: qofevent.cpp:103
const gchar * gnc_plugin_page_get_simple_action_group_name(GncPluginPage *page)
Retrieve the simple action group name associated with this plugin page.
GncPluginManager * gnc_plugin_manager_get(void)
Retrieve a pointer to the plugin manager.
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
GList * usage_order
A list of pages in order of use (most recent -> least recent)
Gnome specific utility functions.
void gnc_plugin_remove_from_window(GncPlugin *plugin, GncMainWindow *window, GQuark type)
Remove the specified plugin from the specified window.
Definition: gnc-plugin.c:175
void gnc_plugin_page_save_page(GncPluginPage *page, GKeyFile *key_file, const gchar *group_name)
Call the plugin specific function that will save the state of a content page to a disk...
#define PLUGIN_PAGE_LABEL
This label is used to provide a mapping from a visible page widget back to the corresponding GncPlugi...
gboolean show_color_tabs
Show account color as background on tabs.
GtkWidget * gnc_find_toolbar_item(GtkWidget *toolbar, const gchar *action_name)
Search the toolbar for the tool item based on the action name.
Dialog for handling user preferences.
GtkWidget * menubar
The menubar.
gboolean qof_book_session_not_saved(const QofBook *book)
qof_book_not_saved() returns the value of the session_dirty flag, set when changes to any object in t...
Definition: qofbook.cpp:375
All type declarations for the whole Gnucash engine.
const char * gnc_quote_source_fq_version(void)
This function returns the version of the Finance::Quote module installed on a user&#39;s computer...
gboolean gnc_main_window_finish_pending(GncMainWindow *window)
Tell a window to finish any outstanding activities.
GLib helper routines.
Generic api to store and retrieve preferences.
Utility functions for file access.
gboolean just_plugin_prefs
Just remove preferences only from plugins.
void gnc_add_accelerator_keys_for_menu(GtkWidget *menu, GMenuModel *model, GtkAccelGroup *accel_group)
Add accelerator keys for menu item widgets.
void gnc_plugin_init_short_names(GtkWidget *toolbar, GncToolBarShortNames *toolbar_labels)
Add "short" labels to existing actions.
Definition: gnc-plugin.c:229
gboolean gnc_uri_targets_local_fs(const gchar *uri)
Checks if the given uri is either a valid file uri or a local filesystem path.
QofBook reference.
Definition: qofbook-p.hpp:46
gchar * label
The new label for this GAction.
This data structure is used to describe the requested state of a GAction, and is used to pass data am...
void main_window_update_page_set_read_only_icon(GncPluginPage *page, gboolean read_only)
Update the icon on the page tabs in the main window.
gboolean qof_book_is_readonly(const QofBook *book)
Return whether the book is read only.
Definition: qofbook.cpp:497
A structure for defining alternate action names for use in the toolbar.
GncMainWindow * gnc_main_window_new(void)
Create a new gnc main window plugin.
void gnc_plugin_page_set_page_color(GncPluginPage *page, const char *color)
Set the color of this page.
GList * gnc_option_db_commit(GncOptionDB *odb)
Write all changed ui_item values to their options.
cannot write to file/directory
Definition: qofbackend.h:68
gboolean gnc_prefs_get_bool(const gchar *group, const gchar *pref_name)
Get a boolean value from the preferences backend.
const char * gnc_version(void)
Parse <prefix>/etc/gnucash/environment and set environment variables based on the contents of that fi...
Definition: gnc-version.c:35
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
GList * gnc_plugin_manager_get_plugins(GncPluginManager *manager)
Get a list of all plugins being held by the plugin manager.
void gnc_plugin_page_set_page_name(GncPluginPage *page, const char *name)
Set the name of this page.
GList * installed_pages
A list of all pages that are installed in this window.
GtkWidget * progressbar
A pointer to the progress bar at the bottom right of the window that is contained in the status bar...
time64 gnc_time(time64 *tbuf)
get the current time
Definition: gnc-date.cpp:262
Utility functions for convert uri in separate components and back.
GncPluginPage * current_page
The currently selected page.
GSimpleActionGroup * gnc_main_window_get_action_group(GncMainWindow *window, const gchar *group_name)
Retrieve a specific set of user interface actions from a window.
gint64 time64
Most systems that are currently maintained, including Microsoft Windows, BSD-derived Unixes and Linux...
Definition: gnc-date.h:87
gulong gnc_prefs_get_reg_auto_raise_lists_id(void)
Get and Set registered preference id for register auto_raise_lists.
Definition: gnc-prefs.cpp:391
void gnc_launch_doclink(GtkWindow *parent, const char *uri)
Launch the default browser and open the provided URI.
void gnc_main_window_restore_default_state(GncMainWindow *window)
Restore the persistent state of one window to a sane default.
The class data structure for a main window object.
File path resolution utility functions.
gboolean gnc_main_window_all_finish_pending(void)
Tell all pages in all windows to finish any outstanding activities.
void gnc_option_db_book_options(GncOptionDB *odb)
Register the standard option set for a QofBook.
gint gnc_list_length_cmp(const GList *list, size_t len)
Scans the GList elements the minimum number of iterations required to test it against a specified siz...
void gnc_main_window_manual_merge_actions(GncMainWindow *window, const gchar *group_name, GSimpleActionGroup *group)
Manually add a set of actions to the specified window.
void main_window_update_page_name(GncPluginPage *page, const gchar *name_in)
Update the name of the page in the main window.
gboolean gnc_menubar_model_update_item(GMenuModel *menu_model, const gchar *action_name, const gchar *target, const gchar *label, const gchar *accel_name, const gchar *tooltip)
Update the GMenuModel item based on the action name by copying existing item, removing it and inserti...
GAction * gnc_plugin_page_get_action(GncPluginPage *page, const gchar *name)
Retrieve a GAction object associated with this page.
GtkWidget * notebook_page
The display widget for this plugin.
GtkWidget * menu_dock
The dock (vbox) at the top of the window containing the menubar and toolbar.
gchar * gnc_uri_create_uri(const gchar *scheme, const gchar *hostname, gint32 port, const gchar *username, const gchar *password, const gchar *path)
Composes a normalized uri starting from its separate components.
void gnc_plugin_page_show_summarybar(GncPluginPage *page, gboolean visible)
Show/hide the summarybar associated with this page.
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.
GtkWidget * gnc_plugin_page_create_widget(GncPluginPage *plugin_page)
Create the display widget that corresponds to this plugin.
constexpr auto gnc_main_window_max_number
Max number of windows allowed.
void gnc_main_window_set_progressbar_window(GncMainWindow *window)
Set the window where all progressbar updates should occur.
void gnc_prefs_remove_cb_by_func(const gchar *group, const gchar *pref_name, gpointer func, gpointer user_data)
Remove a function that was registered for a callback when the given preference changed.
Definition: gnc-prefs.cpp:142
gdouble gnc_prefs_get_float(const gchar *group, const gchar *pref_name)
Get an float value from the preferences backend.
const gchar * gnc_plugin_page_get_plugin_name(GncPluginPage *plugin_page)
Retrieve the textual name of a plugin.
Utility functions for file access.
GncOptionDB * gnc_option_db_new(void)
Create an empty option database.