1 /* ************************************************************************** */
2 /* */
3 /* Copyright (C) 2001-2008 Cédric Auger (cedric@grisbi.org) */
4 /* 2003-2008 Benjamin Drieu (bdrieu@april.org) */
5 /* 2009-2018 Pierre Biava (grisbi@pierre.biava.name) */
6 /* https://www.grisbi.org/ */
7 /* */
8 /* This program is free software; you can redistribute it and/or modify */
9 /* it under the terms of the GNU General Public License as published by */
10 /* the Free Software Foundation; either version 2 of the License, or */
11 /* (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, write to the Free Software */
20 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
21 /* */
22 /* ************************************************************************** */
23
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include <string.h>
30 #include <unistd.h>
31 #include <stdlib.h>
32 #include <sys/types.h>
33
34 #include <glib/gi18n.h>
35 #include <gdk/gdkkeysyms.h>
36 #include <gtk/gtk.h>
37
38 /*START_INCLUDE*/
39 #include "grisbi_app.h"
40 #include "accueil.h"
41 #include "bet_data.h"
42 #include "bet_data_finance.h"
43 #include "bet_finance_ui.h"
44 #include "bet_hist.h"
45 #include "bet_tab.h"
46 #include "categories_onglet.h"
47 #include "etats_onglet.h"
48 #include "dialog.h"
49 #include "gsb_account_property.h"
50 #include "gsb_data_form.h"
51 #include "gsb_data_account.h"
52 #include "gsb_dirs.h"
53 #include "gsb_form.h"
54 #include "gsb_rgba.h"
55 #include "gsb_scheduler_list.h"
56 #include "gsb_transactions_list.h"
57 #include "imputation_budgetaire.h"
58 #include "menu.h"
59 #include "navigation.h"
60 #include "tiers_onglet.h"
61 #include "structures.h"
62 #include "transaction_list.h"
63 #include "utils.h"
64 #include "utils_buttons.h"
65 #include "utils_dates.h"
66 #include "utils_str.h"
67 #include "erreur.h"
68 /*END_INCLUDE*/
69
70
71 /*START_STATIC*/
72 /*END_STATIC*/
73
74 /*START_EXTERN*/
75 /*END_EXTERN*/
76
77 struct _GrisbiWin
78 {
79 GtkApplicationWindow parent;
80 };
81
82 struct _GrisbiWinClass
83 {
84 GtkApplicationWindowClass parent_class;
85 };
86
87 typedef struct _GrisbiWinPrivate GrisbiWinPrivate;
88
89 struct _GrisbiWinPrivate
90 {
91 GtkBuilder * builder;
92
93 /* box principale */
94 GtkWidget * main_box;
95 GtkWidget * stack_box;
96
97 /* page d'accueil affichée si pas de fichier chargé */
98 GtkWidget * no_file_frame;
99 GtkWidget * no_file_sw;
100 GtkWidget * no_file_grid;
101 GtkWidget * bouton_nouveau;
102 GtkWidget * bouton_ouvrir;
103 GtkWidget * bouton_importer;
104
105 /* widgets si un fichier est chargé */
106 GtkWidget * hpaned_general;
107 GtkWidget * notebook_general;
108 GtkWidget * account_page; /* account_page est un notebook qui contient les onglets du compte */
109 GtkWidget * scheduler_calendar;
110 GtkWidget * sw_general;
111 GtkWidget * vbox_general;
112
113 GtkWidget * form_general;
114 GtkWidget * form_frame; /* frame of form */
115 GtkWidget * form_expander; /* expander of form */
116 GtkWidget * form_hbox_label; /* hbox pour le label de l'expander */
117 GtkWidget * form_label_last_statement; /* label de la partie variable de l'expander */
118
119 /* widgets de la fenêtre des operations */
120 GtkWidget * vbox_transactions_list; /* vbox contenant le tree_view des opérations */
121
122 /* nom du fichier associé à la fenêtre */
123 gchar * filename;
124
125 /* titre de la fenêtre */
126 gchar * window_title;
127
128 /* Menus et barres d'outils */
129 /* menu move-to-acc */
130 GMenu * menu;
131 gboolean init_move_to_acc; /* Si VRAI le sous menu des comptes est initialisé */
132
133 /* statusbar */
134 GtkWidget * statusbar;
135 GdkWindow * tracked_window;
136 guint context_id;
137 guint message_id;
138
139 /* headings_bar */
140 GtkWidget * headings_eb;
141 GtkWidget * headings_title; /** Title for the heading bar. */
142 GtkWidget * headings_suffix; /** Suffix for the heading bar. */
143
144 /* paned */
145 gint hpaned_general_width;
146
147 /* form organization */
148 gpointer form_organization;
149
150 /* variables de configuration de la fenêtre */
151 GrisbiWinEtat *w_etat;
152
153 /* structure run */
154 GrisbiWinRun *w_run;
155
156 /* prefs dialog*/
157 GtkWidget * prefs_dialog;
158 };
159
160 G_DEFINE_TYPE_WITH_PRIVATE(GrisbiWin, grisbi_win, GTK_TYPE_APPLICATION_WINDOW)
161
162 /* variables initialisées lors de l'exécution de grisbi PROVISOIRE */
163 struct _GrisbiWinRun run;
164
165 /* global "etat" structure shared in the entire program */
166 struct _GrisbiWinEtat etat;
167
168 /******************************************************************************/
169 /* Private functions */
170 /******************************************************************************/
171 /* HEADINGS_EB */
172 /**
173 *
174 *
175 * \param
176 * \param
177 * \param
178 *
179 * \return
180 **/
grisbi_win_headings_private_update_label_markup(GtkLabel * label,const gchar * text,gboolean escape_text)181 static void grisbi_win_headings_private_update_label_markup (GtkLabel *label,
182 const gchar *text,
183 gboolean escape_text)
184 {
185 gchar* tmp_str;
186
187 if (escape_text)
188 tmp_str = g_markup_printf_escaped ("<b>%s</b>", text);
189 else
190 tmp_str = g_strconcat ("<b>", text, "</b>", NULL);
191 gtk_label_set_markup (label,tmp_str);
192
193 g_free (tmp_str);
194 }
195
196 /**
197 * Trigger a callback functions only if button event that triggered it
198 * was a simple click.
199 *
200 * \param button
201 * \param event
202 * \param callback function
203 *
204 * \return TRUE.
205 */
grisbi_win_headings_simpleclick_event_run(GtkWidget * button,GdkEvent * button_event,GCallback callback)206 static gboolean grisbi_win_headings_simpleclick_event_run (GtkWidget *button,
207 GdkEvent *button_event,
208 GCallback callback)
209 {
210 if (button_event->type == GDK_BUTTON_PRESS)
211 {
212 callback ();
213 }
214
215 return TRUE;
216 }
217
218 /**
219 * retourne headings_eb
220 *
221 * \param GrisbiWin *win
222 *
223 * \return priv->headings_eb
224 **/
grisbi_win_get_headings_eb(GrisbiWin * win)225 static GtkWidget *grisbi_win_get_headings_eb (GrisbiWin *win)
226 {
227 GrisbiWinPrivate *priv;
228
229 if (win == NULL)
230 win = grisbi_app_get_active_window (NULL);
231
232 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
233 return priv->headings_eb;
234 }
235
236 /**
237 * initiate the headings_bar information.
238 *
239 * \param GrisbiWin *win
240 *
241 * \return
242 */
grisbi_win_create_headings_eb(GrisbiWin * win)243 static void grisbi_win_create_headings_eb (GrisbiWin *win)
244 {
245 GtkWidget *grid;
246 GtkWidget *arrow_eb;
247 GtkWidget *arrow_left;
248 GtkWidget *arrow_right;
249 GrisbiWinPrivate *priv;
250
251 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
252
253 priv->headings_eb = gtk_event_box_new ();
254 gtk_widget_set_name (priv->headings_eb, "grey_box");
255 gtk_widget_set_margin_start (priv->headings_eb, MARGIN_BOX);
256 gtk_widget_set_margin_end (priv->headings_eb, MARGIN_BOX);
257
258 grid = gtk_grid_new ();
259 gtk_widget_set_margin_end (grid, MARGIN_BOX);
260 gtk_grid_set_column_spacing (GTK_GRID (grid), MARGIN_BOX);
261 gtk_widget_set_hexpand (grid, TRUE);
262 gtk_container_set_border_width (GTK_CONTAINER (grid), MARGIN_BOX);
263
264 /* Create two arrows. */
265 arrow_left = gtk_image_new_from_icon_name ("pan-start-symbolic", GTK_ICON_SIZE_BUTTON);
266 arrow_eb = gtk_event_box_new ();
267 gtk_container_add (GTK_CONTAINER (arrow_eb), arrow_left);
268 g_signal_connect (G_OBJECT (arrow_eb), "button-press-event",
269 G_CALLBACK (grisbi_win_headings_simpleclick_event_run),
270 gsb_gui_navigation_select_prev);
271 gtk_grid_attach (GTK_GRID (grid), arrow_eb, 0,0,1,1);
272
273 arrow_right = gtk_image_new_from_icon_name ("pan-end-symbolic", GTK_ICON_SIZE_BUTTON);
274 arrow_eb = gtk_event_box_new ();
275 gtk_container_add (GTK_CONTAINER (arrow_eb), arrow_right);
276 g_signal_connect (G_OBJECT (arrow_eb), "button-press-event",
277 G_CALLBACK (grisbi_win_headings_simpleclick_event_run),
278 gsb_gui_navigation_select_next);
279 gtk_grid_attach (GTK_GRID (grid), arrow_eb, 1,0,1,1);
280
281 /* Define labels. */
282 priv->headings_title = gtk_label_new (NULL);
283 gtk_label_set_justify (GTK_LABEL(priv->headings_title), GTK_JUSTIFY_LEFT);
284 utils_labels_set_alignment (GTK_LABEL (priv->headings_title), 0.0, 0.5);
285 gtk_grid_attach (GTK_GRID (grid), priv->headings_title, 2,0,1,1);
286
287 priv->headings_suffix = gtk_label_new (NULL);
288 utils_labels_set_alignment (GTK_LABEL (priv->headings_suffix), 0.0, 0.5);
289 gtk_widget_set_hexpand (priv->headings_suffix, TRUE);
290 gtk_widget_set_halign (priv->headings_suffix, GTK_ALIGN_END);
291 gtk_grid_attach (GTK_GRID (grid), priv->headings_suffix, 3,0,1,1);
292
293 gtk_container_add (GTK_CONTAINER (priv->headings_eb), grid);
294 }
295
296 /* HPANED_GENERAL */
297 /**
298 * save hpahed width
299 *
300 * \param GtkWidget hpaned
301 * \param GtkAllocation allocation
302 * \param gpointer NULL
303 *
304 * \return FALSE
305 */
grisbi_win_hpaned_size_allocate(GtkWidget * hpaned_general,GtkAllocation * allocation,GrisbiAppConf * a_conf)306 static void grisbi_win_hpaned_size_allocate (GtkWidget *hpaned_general,
307 GtkAllocation *allocation,
308 GrisbiAppConf *a_conf)
309 {
310 gint position;
311
312 position = gtk_paned_get_position (GTK_PANED (hpaned_general));
313 a_conf->panel_width = position;
314 }
315
316 /* FORM_GENERAL */
317 /**
318 * Called when the state of the expander changes
319 *
320 * \param expander Expanded that triggered signal.
321 * \param null Not used.
322 *
323 * \return FALSE
324 * */
grisbi_win_form_expander_activate(GtkWidget * expander,GrisbiWin * win)325 static gboolean grisbi_win_form_expander_activate (GtkWidget *expander,
326 GrisbiWin *win)
327 {
328 GrisbiAppConf *a_conf;
329
330 devel_debug (NULL);
331 a_conf = grisbi_app_get_a_conf ();
332
333 if (gtk_expander_get_expanded (GTK_EXPANDER (expander)))
334 gsb_form_expander_is_extanded (expander);
335 else
336 a_conf->formulaire_toujours_affiche = FALSE;
337
338 gsb_menu_gui_toggle_show_form ();
339
340 return FALSE;
341 }
342
343 /**
344 * Create an empty form in an GtkExpander.
345 *
346 * \param
347 *
348 * \return Expander that contains form.
349 **/
grisbi_win_form_new(GrisbiWin * win)350 static GtkWidget *grisbi_win_form_new (GrisbiWin *win)
351 {
352 GtkWidget *label;
353 gchar *tmp_str;
354 GrisbiAppConf *a_conf;
355 GrisbiWinPrivate *priv;
356
357 devel_debug (NULL);
358 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
359 a_conf = grisbi_app_get_a_conf ();
360
361 /* Create the form frame */
362 priv->form_frame = gtk_frame_new ("");
363
364 /* Create the expander */
365 priv->form_expander = gtk_expander_new ("");
366 utils_widget_set_padding (priv->form_expander, MARGIN_BOX, MARGIN_BOX);
367
368 gtk_expander_set_expanded (GTK_EXPANDER (priv->form_expander), a_conf->formulaire_toujours_affiche);
369 gtk_container_add (GTK_CONTAINER (priv->form_frame), priv->form_expander);
370
371 g_object_set_data (G_OBJECT (priv->form_frame), "form_expander", priv->form_expander);
372 g_signal_connect_after (G_OBJECT(priv->form_expander),
373 "activate",
374 G_CALLBACK (grisbi_win_form_expander_activate),
375 win);
376
377 /* create the label of expander */
378 /* Expander has a composite label */
379 priv->form_hbox_label = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
380 gtk_expander_set_label_widget (GTK_EXPANDER(priv->form_expander), priv->form_hbox_label);
381 gtk_expander_set_label_fill (GTK_EXPANDER(priv->form_expander), FALSE);
382 gtk_expander_set_resize_toplevel (GTK_EXPANDER(priv->form_expander), FALSE);
383
384 /* set the label transaction form */
385 label = gtk_label_new (NULL);
386 tmp_str = dialogue_make_pango_attribut ("weight=\"bold\"", _("Transaction/Scheduled _form"));
387 gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), tmp_str);
388 g_free (tmp_str);
389 gtk_box_pack_start (GTK_BOX (priv->form_hbox_label), label, FALSE, FALSE, 0);
390
391 /* set the last statement label */
392 priv->form_label_last_statement = gtk_label_new (NULL);
393 gtk_box_pack_end (GTK_BOX (priv->form_hbox_label), priv->form_label_last_statement, FALSE, FALSE, 0);
394
395 gtk_widget_show_all (priv->form_hbox_label);
396
397 gsb_form_create_widgets ();
398
399 gtk_widget_hide (priv->form_frame);
400
401 return priv->form_frame;
402 }
403
404 /* NAVIGATION PANE */
405 /* NOTEBOOK_GENERAL */
406 /**
407 * fill the notebook given in param
408 *
409 * \param notebook a notebook (usually the main_notebook...)
410 *
411 * \return FALSE
412 * */
grisbi_win_fill_general_notebook(GrisbiWin * win)413 static gboolean grisbi_win_fill_general_notebook (GrisbiWin *win)
414 {
415 GrisbiWinPrivate *priv;
416
417 devel_debug (NULL);
418 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
419
420 /* append the main page */
421 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
422 creation_onglet_accueil(),
423 gtk_label_new (_("Main page")));
424
425 /* append the account page : a notebook with the account configuration
426 * the bet pages and transactions page */
427 priv->account_page = gtk_notebook_new ();
428 gtk_notebook_set_show_border (GTK_NOTEBOOK(priv->account_page), TRUE);
429 gtk_widget_show (priv->account_page);
430
431 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
432 priv->account_page,
433 gtk_label_new (_("Accounts")));
434
435 gtk_notebook_append_page (GTK_NOTEBOOK (priv->account_page),
436 gsb_transactions_list_creation_fenetre_operations (),
437 gtk_label_new (_("Transactions")));
438
439 /* append the balance estimate pages */
440 gtk_notebook_append_page (GTK_NOTEBOOK (priv->account_page),
441 bet_array_create_page (),
442 gtk_label_new (_("Forecast")));
443
444 gtk_notebook_append_page (GTK_NOTEBOOK (priv->account_page),
445 bet_historical_create_page (),
446 gtk_label_new (_("Historical data")));
447
448 /* append the amortization page */
449 gtk_notebook_append_page (GTK_NOTEBOOK (priv->account_page),
450 bet_finance_ui_create_account_amortization_page (),
451 gtk_label_new (_("Amortization array")));
452
453 gtk_notebook_append_page (GTK_NOTEBOOK (priv->account_page),
454 gsb_account_property_create_page (),
455 gtk_label_new (_("Properties")));
456
457 g_signal_connect (G_OBJECT (priv->account_page),
458 "switch-page",
459 G_CALLBACK (grisbi_win_on_account_switch_page),
460 NULL);
461
462 /* append the scheduled transactions page */
463 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
464 gsb_scheduler_list_create_list (),
465 gtk_label_new (_("Scheduler")));
466
467 /* append the payee page */
468 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
469 payees_create_list (),
470 gtk_label_new (_("Payee")));
471
472 /* append the financial page */
473 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
474 bet_finance_ui_create_loan_simulator (),
475 gtk_label_new (_("Credits simulator")));
476
477 /* append the categories page */
478 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
479 categories_create_list (),
480 gtk_label_new (_("Categories")));
481
482 /* append the budget page */
483 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
484 budgetary_lines_create_list (),
485 gtk_label_new (_("Budgetary lines")));
486
487 /* append the reports page */
488 gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook_general),
489 etats_onglet_create_reports_tab (),
490 gtk_label_new (_("Reports")));
491
492 /* Set the signal for the navigation treeview selection when the notebook_general is filled */
493 gsb_gui_navigation_tree_view_selection_changed ();
494
495 /* update toolbars */
496 grisbi_win_update_all_toolbars ();
497
498 return FALSE;
499 }
500
501 /**
502 * Init the main notebook :
503 * a notebook which contains the pages : main page, accounts, scheduler... and
504 * the form on the bottom, the form will be showed only for accounts page and
505 * scheduler page
506 *
507 * \param GrisbiWin active window
508 *
509 * \return GtkWidget general_notebook
510 */
grisbi_win_create_general_notebook(GrisbiWin * win)511 static GtkWidget *grisbi_win_create_general_notebook (GrisbiWin *win)
512 {
513 GtkWidget *sw_general;
514 GtkWidget *grid;
515 GrisbiWinPrivate *priv;
516
517 devel_debug ("create_main_notebook");
518 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
519
520 sw_general = gtk_scrolled_window_new (NULL, NULL);
521 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw_general),
522 GTK_POLICY_AUTOMATIC,
523 GTK_POLICY_AUTOMATIC);
524
525 /* the main right page is a grid with a notebook on the top and the form on the bottom */
526 grid = gtk_grid_new ();
527 gtk_container_add (GTK_CONTAINER(sw_general), grid);
528 gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
529
530 /* append the notebook */
531 priv->notebook_general = gtk_notebook_new ();
532 gtk_widget_set_margin_end (priv->notebook_general, MARGIN_END);
533 gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->notebook_general), FALSE);
534 gtk_notebook_set_show_border (GTK_NOTEBOOK (priv->notebook_general), FALSE);
535 gtk_grid_attach (GTK_GRID (grid), priv->notebook_general, 0,0,1,1);
536
537
538 /* append the form */
539 priv->form_general = grisbi_win_form_new (win);
540 gtk_widget_set_margin_end (priv->form_general, MARGIN_END);
541 gtk_grid_attach (GTK_GRID (grid), priv->form_general, 0,1,1,1);
542 gtk_widget_hide (priv->form_general);
543
544 /* show widgets */
545 gtk_widget_show (sw_general);
546 gtk_widget_show (grid);
547 gtk_widget_show (priv->notebook_general);
548
549 return sw_general;
550 }
551
552 /* VBOX_GENERAL */
553 /**
554 *
555 *
556 * \param GrisbiWin active window
557 *
558 * \return
559 **/
grisbi_win_init_general_widgets(GrisbiWin * win)560 static void grisbi_win_init_general_widgets (GrisbiWin *win)
561 {
562 GrisbiWinPrivate *priv;
563
564 devel_debug (NULL);
565 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
566
567 /* création de vbox_general */
568 priv->vbox_general = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
569 gtk_widget_show (priv->vbox_general);
570 }
571
572 /**
573 * create vbox_general
574 *
575 * \param
576 *
577 * \return
578 **/
grisbi_win_create_general_widgets(GrisbiWin * win)579 static void grisbi_win_create_general_widgets (GrisbiWin *win)
580 {
581 GrisbiAppConf *a_conf;
582 GrisbiWinPrivate *priv;
583
584 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
585 a_conf = grisbi_app_get_a_conf ();
586
587 /* création de vbox_general */
588 if (priv->vbox_general == NULL)
589 {
590 grisbi_win_init_general_widgets (win);
591 gtk_stack_add_named (GTK_STACK (priv->stack_box), priv->vbox_general, "file_page");
592 }
593
594 /* chargement de headings_eb */
595 /* initialisation de headings_eb */
596 grisbi_win_create_headings_eb (GRISBI_WIN (win));
597 gtk_box_pack_start (GTK_BOX (priv->vbox_general), priv->headings_eb, FALSE, FALSE, 0);
598 if (a_conf->show_headings_bar)
599 gtk_widget_show_all (priv->headings_eb);
600 else
601 gtk_widget_hide (priv->headings_eb);
602
603 /* Then create the main hpaned. */
604 priv->hpaned_general = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
605 g_signal_connect (G_OBJECT (priv->hpaned_general),
606 "size-allocate",
607 G_CALLBACK (grisbi_win_hpaned_size_allocate),
608 a_conf);
609 gtk_box_pack_start (GTK_BOX (priv->vbox_general), priv->hpaned_general, TRUE, TRUE, 0);
610
611 /* fill the main hpaned. */
612 gtk_paned_pack1 (GTK_PANED (priv->hpaned_general),
613 gsb_gui_navigation_create_navigation_pane (),
614 TRUE,
615 FALSE);
616
617 priv->sw_general = grisbi_win_create_general_notebook (win);
618 gtk_paned_pack2 (GTK_PANED (priv->hpaned_general),
619 priv->sw_general,
620 TRUE,
621 FALSE);
622 gtk_widget_set_margin_bottom (priv->hpaned_general, MARGIN_BOTTOM);
623 gtk_widget_set_margin_start (priv->hpaned_general, MARGIN_START);
624 gtk_widget_set_margin_top (priv->hpaned_general, MARGIN_TOP);
625
626 if (a_conf->panel_width > PANEL_MIN_WIDTH)
627 gtk_paned_set_position (GTK_PANED (priv->hpaned_general), a_conf->panel_width);
628 else
629 {
630 gint width, height;
631
632 gtk_window_get_size (GTK_WINDOW (win), &width, &height);
633 gtk_paned_set_position (GTK_PANED (priv->hpaned_general), (gint) width / 4);
634 }
635
636 /* show the widgets */
637 gtk_widget_show (priv->hpaned_general);
638 gtk_widget_show (priv->vbox_general);
639 }
640
641 /* NO_FILE_PAGE */
642 /**
643 * page d'accueil si on ne charge pas un fichier automatiquement
644 *
645 * \param
646 *
647 * \return
648 **/
grisbi_win_no_file_page_new(GrisbiWin * win)649 static void grisbi_win_no_file_page_new (GrisbiWin *win)
650 {
651 gchar **recent_files_array;
652 gint i;
653 gint col = 0;
654 gint row = 1;
655 GrisbiAppConf *a_conf;
656 GrisbiWinPrivate *priv;
657
658 devel_debug (NULL);
659 a_conf = grisbi_app_get_a_conf ();
660 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
661
662 gtk_container_set_border_width (GTK_CONTAINER (priv->no_file_frame), MARGIN_BOX);
663
664 /* set grid properties */
665 gtk_grid_set_column_spacing (GTK_GRID (priv->no_file_grid), MARGIN_PADDING_BOX);
666 gtk_grid_set_column_homogeneous (GTK_GRID (priv->no_file_grid), TRUE);
667 gtk_grid_set_row_spacing (GTK_GRID (priv->no_file_grid), MARGIN_PADDING_BOX);
668 gtk_grid_set_row_homogeneous (GTK_GRID (priv->no_file_grid), TRUE);
669 gtk_widget_set_hexpand (priv->no_file_grid, TRUE);
670 gtk_widget_set_vexpand (priv->no_file_grid, TRUE);
671
672 gtk_container_add (GTK_CONTAINER (priv->no_file_sw), priv->no_file_grid);
673
674 /* set bouton nouveau */
675 priv->bouton_nouveau = utils_buttons_button_new_from_image ("gsb-new-file-24.png");
676 gtk_button_set_label (GTK_BUTTON (priv->bouton_nouveau), _("New"));
677 gtk_button_set_image_position (GTK_BUTTON (priv->bouton_nouveau), GTK_POS_TOP);
678 gtk_widget_set_tooltip_text (priv->bouton_nouveau, _("Create a new account file"));
679 gtk_widget_set_size_request (priv->bouton_nouveau, 150, 150);
680 gtk_widget_set_halign (priv->bouton_nouveau, GTK_ALIGN_CENTER);
681 gtk_widget_set_valign (priv->bouton_nouveau, GTK_ALIGN_CENTER);
682 gtk_actionable_set_action_name (GTK_ACTIONABLE (priv->bouton_nouveau), "win.new-acc-file");
683 gtk_grid_attach (GTK_GRID (priv->no_file_grid), priv->bouton_nouveau, 0,0,1,1);
684 gtk_widget_show (priv->bouton_nouveau);
685
686 /* set bouton ouvrir */
687 priv->bouton_ouvrir = utils_buttons_button_new_from_image ("gtk-open-24.png");
688 gtk_button_set_label (GTK_BUTTON (priv->bouton_ouvrir), _("Open"));
689 gtk_button_set_image_position (GTK_BUTTON (priv->bouton_ouvrir), GTK_POS_TOP);
690 gtk_widget_set_tooltip_text (priv->bouton_ouvrir, _("Open an existing account file"));
691 gtk_widget_set_size_request (priv->bouton_ouvrir, 150, 150);
692 gtk_widget_set_halign (priv->bouton_ouvrir, GTK_ALIGN_CENTER);
693 gtk_widget_set_valign (priv->bouton_ouvrir, GTK_ALIGN_CENTER);
694 gtk_actionable_set_action_name (GTK_ACTIONABLE (priv->bouton_ouvrir), "win.open-file");
695 gtk_grid_attach (GTK_GRID (priv->no_file_grid), priv->bouton_ouvrir, 1,0,1,1);
696 gtk_widget_show (priv->bouton_ouvrir);
697
698 /* set the button "import" */
699 priv->bouton_importer = utils_buttons_button_new_from_image ("gsb-convert-24.png");
700 gtk_button_set_label (GTK_BUTTON (priv->bouton_importer), _("Import"));
701 gtk_button_set_image_position (GTK_BUTTON (priv->bouton_importer), GTK_POS_TOP);
702 gtk_widget_set_tooltip_text (priv->bouton_importer, _("Import a CSV, QIF, OFX file ..."));
703 gtk_widget_set_size_request (priv->bouton_importer, 150, 150);
704 gtk_widget_set_halign (priv->bouton_importer, GTK_ALIGN_CENTER);
705 gtk_widget_set_valign (priv->bouton_importer, GTK_ALIGN_CENTER);
706 gtk_actionable_set_action_name (GTK_ACTIONABLE (priv->bouton_importer), "win.import-file");
707
708 gtk_grid_attach (GTK_GRID (priv->no_file_grid), priv->bouton_importer, 2,0,1,1);
709 gtk_widget_show (priv->bouton_importer);
710
711 /* set the recent files buttons */
712 recent_files_array = grisbi_app_get_recent_files_array ();
713 for (i = 0; i < a_conf->nb_derniers_fichiers_ouverts; i++)
714 {
715 if (g_file_test (recent_files_array[i], G_FILE_TEST_EXISTS))
716 {
717
718 GtkWidget *bouton;
719 gchar *tmp_str;
720 gchar *target_value;
721 gchar *basename;
722
723 basename = g_path_get_basename (recent_files_array[i]);
724 tmp_str = utils_str_break_filename (basename, GSB_NBRE_CHAR_TRUNC);
725 g_free (basename);
726
727 bouton = utils_buttons_button_new_from_image ("gtk-open-24.png");
728 gtk_button_set_label (GTK_BUTTON (bouton), tmp_str);
729 gtk_widget_set_tooltip_text (bouton, recent_files_array[i]);
730 gtk_button_set_image_position (GTK_BUTTON (bouton), GTK_POS_TOP);
731 gtk_widget_set_size_request (bouton, 150, 150);
732 gtk_widget_set_halign (bouton, GTK_ALIGN_CENTER);
733 gtk_widget_set_valign (bouton, GTK_ALIGN_CENTER);
734
735 gtk_grid_attach (GTK_GRID (priv->no_file_grid), bouton, col,row,1,1);
736 gtk_widget_show (bouton);
737
738 /* set action */
739 target_value = g_strdup_printf ("%d", i+1);
740 gtk_actionable_set_action_target_value (GTK_ACTIONABLE (bouton), g_variant_new_string (target_value));
741 gtk_actionable_set_action_name (GTK_ACTIONABLE (bouton), "win.direct-open-file");
742
743 g_free (target_value);
744
745 col++;
746 if ((col % 3) == 0)
747 {
748 col = 0;
749 row++;
750 }
751
752 g_free (tmp_str);
753 }
754 }
755
756 /* finalisation de no_file_page */
757 gtk_widget_show (priv->no_file_frame);
758 }
759
760 /* WIN CALLBACK */
761 /**
762 * check on any change on the main window
763 * for now, only to check if we set/unset the full-screen
764 *
765 * \param window
766 * \param event
767 * \param null
768 *
769 * \return FALSE
770 * */
grisbi_win_change_state_window(GtkWidget * window,GdkEventWindowState * event,gpointer null)771 static gboolean grisbi_win_change_state_window (GtkWidget *window,
772 GdkEventWindowState *event,
773 gpointer null)
774 {
775 GrisbiAppConf *a_conf;
776
777 a_conf = grisbi_app_get_a_conf ();
778
779 /* en premier on fixe a_conf->maximize_screen */
780 if (event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED)
781 {
782 gboolean show;
783
784 show = !(event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED);
785 a_conf->maximize_screen = !show;
786 }
787
788 return FALSE;
789 }
790
791 /* FREE STRUCTURES */
792 /**
793 * libère la mémoire utilisée par w_etat
794 *
795 * \param object
796 *
797 * \return
798 **/
grisbi_win_free_w_etat(GrisbiWinEtat * w_etat)799 static void grisbi_win_free_w_etat (GrisbiWinEtat *w_etat)
800 {
801 devel_debug (NULL);
802
803 /* variables generales */
804 if (w_etat->accounting_entity)
805 g_free (w_etat->accounting_entity);
806 if (w_etat->adr_common)
807 g_free (w_etat->adr_common);
808 if (w_etat->adr_secondary)
809 g_free (w_etat->adr_secondary);
810 if (w_etat->date_format)
811 g_free (w_etat->date_format);
812
813 g_free (w_etat);
814 }
815
816 /**
817 * libère la mémoire utilisée par w_run
818 *
819 * \param object
820 *
821 * \return
822 **/
grisbi_win_free_w_run(GrisbiWinRun * w_run)823 static void grisbi_win_free_w_run (GrisbiWinRun *w_run)
824 {
825
826 devel_debug (NULL);
827
828 if (w_run->prefs_selected_row)
829 g_free (w_run->prefs_selected_row);
830
831 g_free (w_run);
832 }
833
834 /******************************************************************************/
835 /* Fonctions propres à l'initialisation des fenêtres */
836 /******************************************************************************/
837 /**
838 *
839 *
840 * \param GrisbiWin *win
841 *
842 * \return
843 **/
grisbi_win_init(GrisbiWin * win)844 static void grisbi_win_init (GrisbiWin *win)
845 {
846 GrisbiWinPrivate *priv;
847 GrisbiAppConf *a_conf;
848
849 a_conf = grisbi_app_get_a_conf ();
850 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
851
852 /* initialisation des variables chaînes */
853 priv->filename = NULL;
854 priv->window_title = NULL;
855
856 /* initialisations des widgets liés à grisbi_win_new_file_gui */
857 priv->vbox_general = NULL;
858 priv->notebook_general = NULL;
859 priv->form_expander = NULL;
860 priv->vbox_transactions_list = NULL;
861
862 /* creation et initialisation de la structure w_run */
863 priv->w_run = g_malloc0 (sizeof (GrisbiWinRun));
864 (priv->w_run)->account_number_is_0 = FALSE;
865 (priv->w_run)->display_one_line = 0; /* fixes bug 1875 */
866 (priv->w_run)->new_account_file = FALSE;
867 (priv->w_run)->prefs_expand_tree = TRUE;
868 (priv->w_run)->prefs_selected_row = g_strdup ("0:0");
869
870 /* initialisation de la variable w_etat */
871 priv->w_etat = g_malloc0 (sizeof (GrisbiWinEtat));
872 (priv->w_etat)->metatree_add_archive_in_totals = TRUE; /* add the archived transactions by default */
873 (priv->w_etat)->export_quote_dates = TRUE; /* "cite les dates" TRUE par défaut */
874
875 /* init widgets in grisbi_win.ui */
876 gtk_widget_init_template (GTK_WIDGET (win));
877
878 /* set font size of statusbar */
879 gtk_widget_set_name (priv->statusbar, "global_statusbar");
880
881 /* adding accueil_page */
882 grisbi_win_no_file_page_new (win);
883 if ((a_conf->dernier_fichier_auto && a_conf->last_open_file))
884 {
885 grisbi_win_init_general_widgets (win);
886 gtk_stack_add_named (GTK_STACK (priv->stack_box), priv->vbox_general, "file_page");
887 }
888 else
889 {
890 gtk_stack_add_named (GTK_STACK (priv->stack_box), priv->no_file_frame, "accueil_page");
891 (priv->w_run)->file_is_loading = FALSE;
892 }
893
894 /* initialisation de la barre d'état */
895 if (!a_conf->low_definition_screen)
896 grisbi_win_init_statusbar (GRISBI_WIN (win));
897
898 /* initialisation du format de la date */
899 (priv->w_etat)->date_format = gsb_date_initialise_format_date ();
900 }
901
902 /**
903 *
904 *
905 * \param
906 *
907 * \return
908 **/
grisbi_win_finalize(GObject * object)909 static void grisbi_win_finalize (GObject *object)
910 {
911 G_OBJECT_CLASS (grisbi_win_parent_class)->finalize (object);
912 }
913
914
915 /**
916 *
917 *
918 * \param
919 *
920 * \return
921 **/
grisbi_win_class_init(GrisbiWinClass * klass)922 static void grisbi_win_class_init (GrisbiWinClass *klass)
923 {
924 GObjectClass *object_class = G_OBJECT_CLASS (klass);
925
926 object_class->finalize = grisbi_win_finalize;
927
928 gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
929 "/org/gtk/grisbi/ui/grisbi_win.ui");
930
931 gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GrisbiWin, main_box);
932 gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GrisbiWin, stack_box);
933 gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GrisbiWin, statusbar);
934 gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GrisbiWin, no_file_frame);
935 gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GrisbiWin, no_file_sw);
936 gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GrisbiWin, no_file_grid);
937
938 /* signaux */
939 gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), grisbi_win_change_state_window);
940 }
941
942 /******************************************************************************/
943 /* Public functions */
944 /******************************************************************************/
945 /**
946 *
947 *
948 * \param
949 *
950 * \return
951 **/
grisbi_win_file_is_loading(void)952 gboolean grisbi_win_file_is_loading (void)
953 {
954 GrisbiWin *win;
955 GrisbiWinPrivate *priv;
956 GrisbiWinRun *w_run;
957
958 win = grisbi_app_get_active_window (NULL);
959
960 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
961 w_run = priv->w_run;
962
963 return w_run->file_is_loading;
964 }
965
966 /**
967 *
968 *
969 * \param
970 *
971 * \return
972 **/
grisbi_win_get_filename(GrisbiWin * win)973 const gchar *grisbi_win_get_filename (GrisbiWin *win)
974 {
975 GrisbiWinPrivate *priv;
976 gchar *filename = NULL;
977
978 if (win == NULL)
979 win = grisbi_app_get_active_window (NULL);
980
981 if (win)
982 {
983 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
984 filename = priv->filename;
985 }
986
987 return filename;
988 }
989
990 /**
991 *
992 *
993 * \param
994 *
995 * \return
996 **/
grisbi_win_set_filename(GrisbiWin * win,const gchar * filename)997 void grisbi_win_set_filename (GrisbiWin *win,
998 const gchar *filename)
999 {
1000 GrisbiWinPrivate *priv;
1001
1002 if (!win)
1003 win = grisbi_app_get_active_window (NULL);
1004
1005 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1006 if (priv->filename)
1007 g_free (priv->filename);
1008
1009 if (filename)
1010 {
1011 priv->filename = g_strdup (filename);
1012 }
1013 else
1014 {
1015 priv->filename = NULL;
1016 }
1017 }
1018
1019 /**
1020 *
1021 *
1022 * \param
1023 *
1024 * \return
1025 **/
grisbi_win_get_w_etat(void)1026 gpointer grisbi_win_get_w_etat (void)
1027 {
1028 GrisbiWin *win;
1029 GrisbiWinPrivate *priv;
1030
1031 win = grisbi_app_get_active_window (NULL);
1032 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1033
1034 return priv->w_etat;
1035 }
1036
1037 /**
1038 *
1039 *
1040 * \param
1041 *
1042 * \return
1043 **/
grisbi_win_get_w_run(void)1044 gpointer grisbi_win_get_w_run (void)
1045 {
1046 GrisbiWin *win;
1047 GrisbiWinPrivate *priv;
1048
1049 win = grisbi_app_get_active_window (NULL);
1050 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1051
1052 return priv->w_run;
1053 }
1054
1055 /* GET WIDGET */
1056 /**
1057 * retourne account_page
1058 *
1059 * \param
1060 *
1061 * \return account_page
1062 **/
grisbi_win_get_account_page(void)1063 GtkWidget *grisbi_win_get_account_page (void)
1064 {
1065 GrisbiWin *win;
1066 GrisbiWinPrivate *priv;
1067
1068 win = grisbi_app_get_active_window (NULL);
1069 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1070
1071 return priv->account_page;
1072 }
1073
1074 /**
1075 * retourne form_expander
1076 *
1077 * \param
1078 *
1079 * \return form_expander
1080 **/
grisbi_win_get_form_expander(void)1081 GtkWidget *grisbi_win_get_form_expander (void)
1082 {
1083 GrisbiWin *win;
1084 GrisbiWinPrivate *priv;
1085
1086 win = grisbi_app_get_active_window (NULL);
1087 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1088
1089 return priv->form_expander;
1090 }
1091
1092 /**
1093 * retourne label_last_statement
1094 *
1095 * \param
1096 *
1097 * \return form_label_last_statement
1098 **/
grisbi_win_get_label_last_statement(void)1099 GtkWidget *grisbi_win_get_label_last_statement (void)
1100 {
1101 GrisbiWin *win;
1102 GrisbiWinPrivate *priv;
1103
1104 win = grisbi_app_get_active_window (NULL);
1105 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1106
1107 return priv->form_label_last_statement;
1108 }
1109
1110 /**
1111 * retourne notebook_general
1112 *
1113 * \param GrisbiWin *win
1114 *
1115 * \return notebook_general
1116 **/
grisbi_win_get_notebook_general(void)1117 GtkWidget *grisbi_win_get_notebook_general (void)
1118 {
1119 GrisbiWin *win;
1120 GrisbiWinPrivate *priv;
1121
1122 win = grisbi_app_get_active_window (NULL);
1123 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1124
1125 return priv->notebook_general;
1126 }
1127
1128 /**
1129 * retourne prefs object
1130 *
1131 * \param GrisbiWin *win
1132 *
1133 * \return prefs_dialog
1134 **/
grisbi_win_get_prefs_dialog(GrisbiWin * win)1135 GtkWidget *grisbi_win_get_prefs_dialog (GrisbiWin *win)
1136 {
1137 GrisbiWinPrivate *priv;
1138
1139 if (!win)
1140 win = grisbi_app_get_active_window (NULL);
1141
1142 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1143
1144 return priv->prefs_dialog;
1145 }
1146
1147 /**
1148 *
1149 *
1150 * \param
1151 * \param
1152 *
1153 * \return
1154 **/
grisbi_win_set_prefs_dialog(GrisbiWin * win,GtkWidget * prefs_dialog)1155 void grisbi_win_set_prefs_dialog (GrisbiWin *win,
1156 GtkWidget *prefs_dialog)
1157 {
1158 GrisbiWinPrivate *priv;
1159
1160 if (!win)
1161 win = grisbi_app_get_active_window (NULL);
1162 if (win)
1163 {
1164 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1165 priv->prefs_dialog = prefs_dialog;
1166 }
1167 }
1168
1169 /**
1170 * retourne stack_box
1171 *
1172 * \param GrisbiWin *win
1173 *
1174 * \return stack_box
1175 **/
grisbi_win_get_stack_box(GrisbiWin * win)1176 GtkWidget *grisbi_win_get_stack_box (GrisbiWin *win)
1177 {
1178 GrisbiWinPrivate *priv;
1179
1180 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1181 return priv->stack_box;
1182 }
1183
1184 /**
1185 * retourne vbox_transactions_list (ex tree_view_vbox)
1186 *
1187 * \param GrisbiWin *win
1188 *
1189 * \return vbox_transactions_list
1190 **/
grisbi_win_get_vbox_transactions_list(GrisbiWin * win)1191 GtkWidget *grisbi_win_get_vbox_transactions_list (GrisbiWin *win)
1192 {
1193 GrisbiWinPrivate *priv;
1194
1195 if (win == NULL)
1196 win = grisbi_app_get_active_window (NULL);
1197
1198 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1199 return priv->vbox_transactions_list;
1200 }
1201
1202 /**
1203 * set vbox_transactions_list (ex tree_view_vbox)
1204 *
1205 * \param GrisbiWin *win
1206 * \param vbox
1207 *
1208 * \return
1209 **/
grisbi_win_set_vbox_transactions_list(GrisbiWin * win,GtkWidget * vbox)1210 gboolean grisbi_win_set_vbox_transactions_list (GrisbiWin *win,
1211 GtkWidget *vbox)
1212 {
1213 GrisbiWinPrivate *priv;
1214
1215 if (win == NULL)
1216 win = grisbi_app_get_active_window (NULL);
1217
1218 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1219 priv->vbox_transactions_list = vbox;
1220
1221 return TRUE;
1222 }
1223
1224 /* WIN_MENU */
1225 /**
1226 *
1227 *
1228 * \param GrisbiWin win
1229 * \param GMenuModel menubar
1230 *
1231 * \return
1232 **/
grisbi_win_init_menubar(GrisbiWin * win,gpointer app)1233 void grisbi_win_init_menubar (GrisbiWin *win,
1234 gpointer app)
1235 {
1236 GAction *action;
1237 const gchar * items[] = {
1238 "save",
1239 "save-as",
1240 "export-accounts",
1241 "create-archive",
1242 "export-archive",
1243 "debug-acc-file",
1244 "obf-acc-file",
1245 "debug-mode",
1246 "file-close",
1247 "edit-ope",
1248 "new-ope",
1249 "remove-ope",
1250 "template-ope",
1251 "clone-ope",
1252 "convert-ope",
1253 "new-acc",
1254 "remove-acc",
1255 "show-form",
1256 "show-reconciled",
1257 "show-archived",
1258 "show-closed-acc",
1259 "show-ope",
1260 "reset-width-col",
1261 NULL
1262 };
1263 const gchar **tmp = items;
1264 gboolean has_app_menu;
1265 GrisbiAppConf *a_conf;
1266
1267 a_conf = grisbi_app_get_a_conf ();
1268
1269 /* initialisations sub menus */
1270 action = g_action_map_lookup_action (G_ACTION_MAP (win), "show-form");
1271 g_action_change_state (G_ACTION (action), g_variant_new_boolean (a_conf->formulaire_toujours_affiche));
1272 action = g_action_map_lookup_action (G_ACTION_MAP (win), "show-closed-acc");
1273 g_action_change_state (G_ACTION (action), g_variant_new_boolean (a_conf->show_closed_accounts));
1274
1275 /* disabled menus */
1276 while (*tmp)
1277 {
1278 gsb_menu_gui_sensitive_win_menu_item (*tmp, FALSE);
1279
1280 tmp++;
1281 }
1282
1283 /* sensibilise le menu new-window PROVISOIRE*/
1284 has_app_menu = grisbi_app_get_has_app_menu (GRISBI_APP (app));
1285 if (!has_app_menu)
1286 gsb_menu_gui_sensitive_win_menu_item ("new-window", FALSE);
1287 }
1288
1289 /**
1290 *
1291 *
1292 * \param
1293 *
1294 * \return
1295 **/
grisbi_win_menu_move_to_acc_delete(void)1296 void grisbi_win_menu_move_to_acc_delete (void)
1297 {
1298 GrisbiWin *win;
1299 GrisbiWinPrivate *priv;
1300 GMenu *menu;
1301 GSList *tmp_list;
1302
1303 win = grisbi_app_get_active_window (NULL);
1304 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1305
1306 if (priv->init_move_to_acc == FALSE)
1307 return;
1308
1309 tmp_list = gsb_data_account_get_list_accounts ();
1310 while (tmp_list)
1311 {
1312 gint i;
1313
1314 i = gsb_data_account_get_no_account (tmp_list->data);
1315
1316 if (!gsb_data_account_get_closed_account (i))
1317 {
1318 gchar *tmp_name;
1319
1320 tmp_name = g_strdup_printf ("move-to-acc%d", i);
1321 g_action_map_remove_action (G_ACTION_MAP (win), tmp_name);
1322
1323 g_free (tmp_name);
1324 }
1325 tmp_list = tmp_list->next;
1326 }
1327
1328 menu = grisbi_app_get_menu_edit ();
1329
1330 g_menu_remove (menu, 3);
1331 priv->init_move_to_acc = FALSE;
1332 }
1333
1334 /**
1335 *
1336 *
1337 * \param GrisbiWin win
1338 *
1339 * \return
1340 **/
grisbi_win_menu_move_to_acc_new(void)1341 void grisbi_win_menu_move_to_acc_new (void)
1342 {
1343 GrisbiWin *win;
1344 GrisbiWinPrivate *priv;
1345 GAction *action;
1346 GMenu *menu;
1347 GMenu *submenu;
1348 GMenuItem *menu_item;
1349 GSList *tmp_list;
1350
1351 win = grisbi_app_get_active_window (NULL);
1352 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1353
1354 menu = grisbi_app_get_menu_edit ();
1355
1356 submenu = g_menu_new ();
1357
1358 tmp_list = gsb_data_account_get_list_accounts ();
1359 while (tmp_list)
1360 {
1361 gint i;
1362
1363 i = gsb_data_account_get_no_account (tmp_list->data);
1364
1365 if (!gsb_data_account_get_closed_account (i))
1366 {
1367 gchar *tmp_name;
1368 gchar *account_name;
1369 gchar *action_name;
1370
1371 tmp_name = g_strdup_printf ("move-to-acc%d", i);
1372 account_name = gsb_data_account_get_name (i);
1373 if (!account_name)
1374 account_name = _("Unnamed account");
1375
1376 action = (GAction *) g_simple_action_new (tmp_name, NULL);
1377 g_signal_connect (action,
1378 "activate",
1379 G_CALLBACK (grisbi_cmd_move_to_account_menu),
1380 GINT_TO_POINTER (i));
1381 g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE);
1382
1383 g_action_map_add_action (G_ACTION_MAP (grisbi_app_get_active_window (NULL)), action);
1384 g_object_unref (G_OBJECT (action));
1385
1386 action_name = g_strconcat ("win.", tmp_name, NULL);
1387 g_menu_append (submenu, account_name, action_name);
1388
1389 g_free (tmp_name);
1390 g_free (action_name);
1391 }
1392
1393 tmp_list = tmp_list->next;
1394 }
1395
1396 menu_item = g_menu_item_new_submenu (_("Move transaction to another account"), (GMenuModel*) submenu);
1397 g_menu_item_set_detailed_action (menu_item, "win.move-to-acc");
1398
1399 g_menu_insert_item (G_MENU (menu), 3, menu_item);
1400 g_object_unref (menu_item);
1401 g_object_unref (submenu);
1402 priv->init_move_to_acc = TRUE;
1403 }
1404
1405 /**
1406 *
1407 *
1408 * \param
1409 *
1410 * \return
1411 **/
grisbi_win_menu_move_to_acc_update(gboolean active)1412 void grisbi_win_menu_move_to_acc_update (gboolean active)
1413 {
1414 GrisbiWin *win;
1415 GAction *action;
1416 GSList *tmp_list;
1417
1418 win = grisbi_app_get_active_window (NULL);
1419
1420 tmp_list = gsb_data_account_get_list_accounts ();
1421 while (tmp_list)
1422 {
1423 gint i;
1424
1425 i = gsb_data_account_get_no_account (tmp_list->data);
1426
1427 if (!gsb_data_account_get_closed_account (i))
1428 {
1429 gchar *tmp_name;
1430
1431 tmp_name = g_strdup_printf ("move-to-acc%d", i);
1432 action = g_action_map_lookup_action (G_ACTION_MAP (win), tmp_name);
1433
1434 if (gsb_gui_navigation_get_current_account () == i)
1435 {
1436 g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE);
1437 tmp_list = tmp_list->next;
1438 continue;
1439 }
1440 if (active)
1441 g_simple_action_set_enabled (G_SIMPLE_ACTION (action), TRUE);
1442 else
1443 g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE);
1444
1445 g_free (tmp_name);
1446 }
1447 tmp_list = tmp_list->next;
1448 }
1449 }
1450
1451 /* MAIN WINDOW */
1452 /**
1453 * Active la vue accueil ou la vue fichier
1454 *
1455 * \param GrisbiWin active window
1456 * \param gchar nom de la page
1457 *
1458 * \return
1459 **/
grisbi_win_stack_box_show(GrisbiWin * win,const gchar * page_name)1460 void grisbi_win_stack_box_show (GrisbiWin *win,
1461 const gchar *page_name)
1462 {
1463 GrisbiWinPrivate *priv;
1464
1465 devel_debug (page_name);
1466 if (win == NULL)
1467 win = grisbi_app_get_active_window (NULL);
1468
1469 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1470 if (gtk_stack_get_child_by_name (GTK_STACK (priv->stack_box), page_name))
1471 gtk_stack_set_visible_child_name (GTK_STACK (priv->stack_box), page_name);
1472 else
1473 {
1474 gtk_stack_add_named (GTK_STACK (priv->stack_box), priv->no_file_frame, page_name);
1475 gtk_stack_set_visible_child_name (GTK_STACK (priv->stack_box), page_name);
1476 }
1477 if (strcmp (page_name, "accueil_page") == 0)
1478 {
1479 (priv->w_run)->file_is_loading = FALSE;
1480 }
1481 }
1482
1483 /**
1484 * set the title of the window
1485 *
1486 * \param gint account_number
1487 *
1488 * \return TRUE if OK, FALSE otherwise
1489 * */
grisbi_win_set_window_title(gint account_number)1490 gboolean grisbi_win_set_window_title (gint account_number)
1491 {
1492 const gchar *filename;
1493 gchar *titre_grisbi = NULL;
1494 gboolean return_value;
1495
1496 filename = grisbi_win_get_filename (NULL);
1497 if (filename == NULL)
1498 {
1499 titre_grisbi = g_strdup (_("Grisbi"));
1500 return_value = TRUE;
1501 }
1502 else
1503 {
1504 gchar *titre = NULL;
1505 gint tmp_number;
1506 GrisbiAppConf *a_conf;
1507 GrisbiWinEtat *w_etat;
1508
1509 devel_debug_int (account_number);
1510 a_conf = grisbi_app_get_a_conf ();
1511 w_etat = (GrisbiWinEtat *) grisbi_win_get_w_etat ();
1512
1513 switch (a_conf->display_window_title)
1514 {
1515 case GSB_ACCOUNT_ENTITY:
1516 if (w_etat->accounting_entity && strlen (w_etat->accounting_entity))
1517 titre = g_strdup (w_etat->accounting_entity);
1518 break;
1519 case GSB_ACCOUNT_HOLDER:
1520 {
1521 if (account_number == -1)
1522 tmp_number = gsb_data_account_first_number ();
1523 else
1524 tmp_number = account_number;
1525
1526 if (tmp_number == -1)
1527 {
1528 if (w_etat->accounting_entity && strlen (w_etat->accounting_entity))
1529 titre = g_strdup (w_etat->accounting_entity);
1530 }
1531 else
1532 {
1533 titre = g_strdup (gsb_data_account_get_holder_name (tmp_number));
1534
1535 if (titre == NULL)
1536 titre = g_strdup (gsb_data_account_get_name (tmp_number));
1537 }
1538 break;
1539 }
1540 case GSB_ACCOUNT_FILENAME:
1541 if (filename && strlen (filename))
1542 titre = g_path_get_basename (filename);
1543 break;
1544 }
1545
1546 if (titre && strlen (titre) > 0)
1547 {
1548 titre_grisbi = g_strconcat (titre, " - ", _("Grisbi"), NULL);
1549 g_free (titre);
1550
1551 return_value = TRUE;
1552 }
1553 else
1554 {
1555 titre_grisbi = g_strconcat ("<", _("unnamed"), ">", NULL);
1556 return_value = FALSE;
1557 }
1558 }
1559 gtk_window_set_title (GTK_WINDOW (grisbi_app_get_active_window (NULL)), titre_grisbi);
1560
1561 if (titre_grisbi && strlen (titre_grisbi) > 0)
1562 {
1563 gsb_main_page_update_homepage_title (titre_grisbi);
1564 g_free (titre_grisbi);
1565 }
1566
1567 return return_value;
1568 }
1569
1570 /**
1571 * set size and position of the main window of grisbi.
1572 *
1573 * \param GrisbiWin *win
1574 *
1575 * \return
1576 * */
grisbi_win_set_size_and_position(GtkWindow * win)1577 void grisbi_win_set_size_and_position (GtkWindow *win)
1578 {
1579 GrisbiAppConf *a_conf;
1580
1581 a_conf = grisbi_app_get_a_conf ();
1582
1583 /* set the size of the window */
1584 if (a_conf->main_width && a_conf->main_height)
1585 gtk_window_set_default_size (GTK_WINDOW (win), a_conf->main_width, a_conf->main_height);
1586 else
1587 gtk_window_set_default_size (GTK_WINDOW (win), WIN_MIN_WIDTH, WIN_MIN_HEIGHT);
1588
1589 /* display window at position */
1590 gtk_window_move (GTK_WINDOW (win), a_conf->x_position, a_conf->y_position);
1591
1592 /* set the full screen if necessary */
1593 if (a_conf->full_screen)
1594 gtk_window_fullscreen (GTK_WINDOW (win));
1595
1596 /* put up the screen if necessary */
1597 if (a_conf->maximize_screen)
1598 gtk_window_maximize (GTK_WINDOW (win));
1599 }
1600
1601 /**
1602 * Remplace la fonction gtk_window_close () en libérant la mémoire utilisée
1603 * par la fenêtre quand on quitte l'application par le menu quitter.
1604 *
1605 * \param
1606 *
1607 * \return
1608 **/
grisbi_win_close_window(GtkWindow * win)1609 void grisbi_win_close_window (GtkWindow *win)
1610 {
1611 GrisbiWinPrivate *priv;
1612
1613 devel_debug (NULL);
1614 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1615
1616 g_free (priv->filename);
1617 priv->filename = NULL;
1618
1619 g_free (priv->window_title);
1620 priv->window_title = NULL;
1621
1622 g_free (priv->form_organization);
1623
1624 g_clear_object (&priv->builder);
1625 g_clear_object (&priv->menu);
1626
1627 /* libération de la mémoiré utilisée par w_etat */
1628 grisbi_win_free_w_etat (priv->w_etat);
1629
1630 /* libération mémoire de la structure run */
1631 grisbi_win_free_w_run (priv->w_run);
1632 }
1633
1634 /* NO_FILE_PAGE */
1635 /**
1636 * update page d'accueil si on ferme le fichier
1637 *
1638 * \param
1639 *
1640 * \return
1641 **/
grisbi_win_no_file_page_update(GrisbiWin * win)1642 void grisbi_win_no_file_page_update (GrisbiWin *win)
1643 {
1644 gchar **recent_files_array;
1645 gint i;
1646 gint col = 0;
1647 gint row = 1;
1648 GrisbiAppConf *a_conf;
1649 GrisbiWinPrivate *priv;
1650
1651 devel_debug (NULL);
1652 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1653 a_conf = grisbi_app_get_a_conf ();
1654
1655 if ((priv->w_run)->file_is_loading == TRUE)
1656 {
1657 grisbi_win_stack_box_show (win, "accueil_page");
1658 }
1659
1660 recent_files_array = grisbi_app_get_recent_files_array ();
1661 for (i = 0; i < a_conf->nb_derniers_fichiers_ouverts; i++)
1662 {
1663 GtkWidget *bouton;
1664 gchar *tmp_str;
1665 gchar *target_value;
1666 gchar *basename;
1667
1668 bouton = gtk_grid_get_child_at (GTK_GRID (priv->no_file_grid), col, row);
1669 if (bouton == NULL)
1670 {
1671 bouton = utils_buttons_button_new_from_stock ("gtk-open", _("Open"));
1672 gtk_button_set_image_position (GTK_BUTTON (bouton), GTK_POS_TOP);
1673 gtk_widget_set_size_request (bouton, 150, 150);
1674 gtk_widget_set_halign (bouton, GTK_ALIGN_CENTER);
1675 gtk_widget_set_valign (bouton, GTK_ALIGN_CENTER);
1676
1677 gtk_grid_attach (GTK_GRID (priv->no_file_grid), bouton, col,row,1,1);
1678 gtk_widget_show (bouton);
1679
1680 /* set action */
1681 target_value = g_strdup_printf ("%d", i+1);
1682 gtk_actionable_set_action_target_value (GTK_ACTIONABLE (bouton), g_variant_new_string (target_value));
1683 gtk_actionable_set_action_name (GTK_ACTIONABLE (bouton), "win.direct-open-file");
1684
1685 g_free (target_value);
1686 }
1687
1688 basename = g_path_get_basename (recent_files_array[i]);
1689 tmp_str = utils_str_break_filename (basename, GSB_NBRE_CHAR_TRUNC);
1690 g_free (basename);
1691
1692 gtk_button_set_label (GTK_BUTTON (bouton), tmp_str);
1693 gtk_widget_set_tooltip_text (bouton, recent_files_array[i]);
1694
1695 col++;
1696 if ((col % 3) == 0)
1697 {
1698 col = 0;
1699 row++;
1700 }
1701 g_free (tmp_str);
1702 }
1703 }
1704
1705 /* VBOX_GENERAL */
1706 /**
1707 * free vbox_general
1708 *
1709 * \param
1710 *
1711 * \return
1712 **/
grisbi_win_free_general_vbox(void)1713 void grisbi_win_free_general_vbox (void)
1714 {
1715 GrisbiWin *win;
1716 GrisbiWinPrivate *priv;
1717
1718 win = grisbi_app_get_active_window (NULL);
1719 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1720
1721 if (priv->vbox_general)
1722 {
1723 gtk_widget_destroy (priv->vbox_general);
1724 priv->vbox_general = NULL;
1725 }
1726 }
1727
1728 /* NOTEBOOK_GENERAL */
1729 /**
1730 * Set the main notebook page.
1731 *
1732 * \param page Page to set.
1733 *
1734 * \return
1735 **/
grisbi_win_general_notebook_set_page(gint page)1736 void grisbi_win_general_notebook_set_page (gint page)
1737 {
1738 GrisbiWin *win;
1739 GrisbiWinPrivate *priv;
1740
1741 win = grisbi_app_get_active_window (NULL);
1742 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1743
1744 gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook_general), page);
1745 }
1746
1747 /**
1748 * free notebook_general
1749 *
1750 * \param
1751 *
1752 * \return
1753 **/
grisbi_win_free_general_notebook(void)1754 void grisbi_win_free_general_notebook (void)
1755 {
1756 GrisbiWin *win = NULL;
1757 GrisbiWinPrivate *priv;
1758
1759 win = grisbi_app_get_active_window (NULL);
1760 if (win == NULL)
1761 return;
1762
1763 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1764
1765 if (priv->notebook_general)
1766 priv->notebook_general = NULL;
1767 }
1768
1769 /* ACCOUNT_PAGE */
1770 /**
1771 * called when the account notebook changed page between
1772 * transactions list and account description
1773 *
1774 * \param notebook Widget that triggered event.
1775 * \param page Not used.
1776 * \param page_number Page set.
1777 * \param null Not used.
1778 *
1779 * \return FALSE
1780 */
grisbi_win_on_account_switch_page(GtkNotebook * notebook,gpointer page,guint page_number,gpointer null)1781 gboolean grisbi_win_on_account_switch_page (GtkNotebook *notebook,
1782 gpointer page,
1783 guint page_number,
1784 gpointer null)
1785 {
1786 gint account_number;
1787
1788 grisbi_win_menu_move_to_acc_update (FALSE);
1789 if (page_number != GSB_TRANSACTIONS_PAGE)
1790 {
1791 gsb_menu_set_menus_view_account_sensitive (FALSE);
1792 gsb_menu_gui_sensitive_win_menu_item ("new-ope", FALSE);
1793 }
1794
1795 switch (page_number)
1796 {
1797 case GSB_TRANSACTIONS_PAGE:
1798 grisbi_win_set_form_expander_visible (TRUE, TRUE);
1799 gsb_menu_set_menus_view_account_sensitive (TRUE);
1800 gsb_menu_gui_sensitive_win_menu_item ("new-ope", TRUE);
1801 break;
1802 case GSB_ESTIMATE_PAGE:
1803 grisbi_win_set_form_expander_visible (FALSE, FALSE);
1804 account_number = gsb_gui_navigation_get_current_account ();
1805 if (gsb_data_account_get_bet_maj (account_number))
1806 bet_data_update_bet_module (account_number, GSB_ESTIMATE_PAGE);
1807 gsb_menu_gui_sensitive_win_menu_item ("reset-width-col", TRUE);
1808 break;
1809 case GSB_HISTORICAL_PAGE:
1810 grisbi_win_set_form_expander_visible (FALSE, FALSE);
1811 account_number = gsb_gui_navigation_get_current_account ();
1812 if (gsb_data_account_get_bet_maj (account_number))
1813 bet_data_update_bet_module (account_number, GSB_HISTORICAL_PAGE);
1814 bet_historical_set_page_title (account_number);
1815 break;
1816 case GSB_FINANCE_PAGE:
1817 grisbi_win_set_form_expander_visible (FALSE, FALSE);
1818 account_number = gsb_gui_navigation_get_current_account ();
1819 bet_finance_update_amortization_tab (account_number);
1820 /* FALLTHRU */
1821 case GSB_PROPERTIES_PAGE:
1822 grisbi_win_set_form_expander_visible (FALSE, FALSE);
1823 break;
1824 }
1825
1826 return (FALSE);
1827 }
1828
1829 /* FILE_GUI */
1830 /**
1831 * Initialize user interface part when a new accounts file is created.
1832 *
1833 * \param
1834 *
1835 * \return
1836 **/
grisbi_win_new_file_gui(void)1837 void grisbi_win_new_file_gui (void)
1838 {
1839 GtkWidget *sw_transaction_list;
1840 GtkWidget *vbox_transactions_list;
1841 GrisbiWin *win;
1842 GrisbiWinPrivate *priv;
1843
1844 win = grisbi_app_get_active_window (NULL);
1845 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1846
1847 /* dégrise les menus nécessaire */
1848 gsb_menu_set_menus_with_file_sensitive (TRUE);
1849
1850 /* récupère l'organisation des colonnes */
1851 gsb_transactions_list_set_titles_tips_col_list_ope ();
1852
1853 /* Create main widget. */
1854 grisbi_win_status_bar_message (_("Creating main window"));
1855
1856 /* création de grid_general */
1857 grisbi_win_create_general_widgets (GRISBI_WIN (win));
1858 grisbi_win_stack_box_show (win, "file_page");
1859
1860 /* fill the general notebook */
1861 grisbi_win_fill_general_notebook (GRISBI_WIN (win));
1862
1863 /* create the model */
1864 if (!transaction_list_create ())
1865 {
1866 dialogue_error (_("The model of the list couldn't be created... "
1867 "Bad things will happen very soon..."));
1868 return;
1869 }
1870
1871 /* Create transaction list. */
1872 sw_transaction_list = gsb_transactions_list_make_gui_list ();
1873 vbox_transactions_list = grisbi_win_get_vbox_transactions_list (win);
1874 gtk_box_pack_start (GTK_BOX (vbox_transactions_list), sw_transaction_list, TRUE, TRUE, 0);
1875 gtk_widget_show (sw_transaction_list);
1876
1877 /* Display accounts in menus */
1878 grisbi_win_menu_move_to_acc_delete ();
1879 grisbi_win_menu_move_to_acc_new ();
1880
1881 gtk_notebook_set_current_page (GTK_NOTEBOOK(priv->notebook_general), GSB_HOME_PAGE);
1882
1883 gtk_widget_show (priv->notebook_general);
1884 }
1885
1886 /* FORM_GENERAL */
1887 /**
1888 * hide the frame
1889 *
1890 * \param
1891 *
1892 * \return
1893 **/
grisbi_win_form_expander_hide_frame(void)1894 void grisbi_win_form_expander_hide_frame (void)
1895 {
1896 GrisbiWin *win;
1897 GrisbiWinPrivate *priv;
1898
1899 win = grisbi_app_get_active_window (NULL);
1900 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1901
1902 gtk_widget_hide (priv->form_frame);
1903 }
1904
1905 /**
1906 * Check if transactions form is visible.
1907 *
1908 * \param
1909 *
1910 * \return TRUE if transactions forms is expanded, FALSE otherwise.
1911 */
grisbi_win_form_expander_is_expanded(void)1912 gboolean grisbi_win_form_expander_is_expanded (void)
1913 {
1914 GrisbiWin *win;
1915 GrisbiWinPrivate *priv;
1916
1917 win = grisbi_app_get_active_window (NULL);
1918 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1919
1920 return gtk_expander_get_expanded (GTK_EXPANDER (priv->form_expander));
1921 }
1922 /**
1923 * show the frame
1924 *
1925 * \param
1926 *
1927 * \return
1928 **/
grisbi_win_form_expander_show_frame(void)1929 void grisbi_win_form_expander_show_frame (void)
1930 {
1931 GrisbiWin *win;
1932 GrisbiWinPrivate *priv;
1933
1934 win = grisbi_app_get_active_window (NULL);
1935 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1936
1937 gtk_widget_show (priv->form_frame);
1938 }
1939
1940 /**
1941 * Positionne le label des rapprochements à la fin du label de l'expander
1942 * utile juste pour les comptes.
1943 *
1944 * \param GtkAllocation allocation
1945 *
1946 * \return
1947 **/
grisbi_win_form_label_align_right(GtkAllocation * allocation)1948 void grisbi_win_form_label_align_right (GtkAllocation *allocation)
1949 {
1950 GtkWidget *expander_label;
1951 gint new_width;
1952 gint sw_general_width;
1953 GrisbiWin *win;
1954 GrisbiWinPrivate *priv;
1955
1956 win = grisbi_app_get_active_window (NULL);
1957 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1958
1959 new_width = allocation->width -30;
1960
1961 /* addition of a feedback loop EXPERIMENTAL */
1962 sw_general_width = gtk_widget_get_allocated_width (priv->sw_general);
1963 if (new_width + 40 > sw_general_width)
1964 new_width = sw_general_width - 40;
1965
1966 expander_label = gtk_expander_get_label_widget (GTK_EXPANDER(priv->form_expander));
1967 gtk_widget_set_size_request (expander_label, new_width, -1);
1968 }
1969
1970 /**
1971 * get the form_organization
1972 *
1973 * \param
1974 *
1975 * \return form_organization
1976 **/
grisbi_win_get_form_organization(void)1977 gpointer grisbi_win_get_form_organization (void)
1978 {
1979 GrisbiWin *win;
1980 GrisbiWinPrivate *priv;
1981
1982 win = grisbi_app_get_active_window (NULL);
1983 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
1984
1985 return priv->form_organization;
1986 }
1987
1988 /**
1989 * show or hide the expander
1990 *
1991 * \param visible TRUE or FALSE
1992 * \param transactions_list TRUE if we are on transactions, FALSE if we are on scheduler
1993 *
1994 * return FALSE
1995 * */
grisbi_win_set_form_expander_visible(gboolean visible,gboolean transactions_list)1996 gboolean grisbi_win_set_form_expander_visible (gboolean visible,
1997 gboolean transactions_list)
1998 {
1999 GrisbiWin *win;
2000 GrisbiWinPrivate *priv;
2001
2002 win = grisbi_app_get_active_window (NULL);
2003 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
2004
2005 if (visible)
2006 {
2007 gtk_widget_show (priv->form_expander);
2008 gtk_widget_show (priv->form_frame);
2009
2010 if (transactions_list)
2011 gtk_widget_show (priv->form_label_last_statement);
2012 else
2013 gtk_widget_hide (priv->form_label_last_statement);
2014 }
2015 else
2016 {
2017 gtk_widget_hide (priv->form_expander);
2018 gtk_widget_hide (priv->form_frame);
2019 }
2020
2021 return FALSE;
2022 }
2023
2024 /**
2025 * set the form_organization
2026 *
2027 * \param form_organization form_organization to set
2028 *
2029 * \return TRUE
2030 * */
grisbi_win_set_form_organization(gpointer form_organization)2031 gboolean grisbi_win_set_form_organization (gpointer form_organization)
2032 {
2033 GrisbiWin *win;
2034 GrisbiWinPrivate *priv;
2035
2036 win = grisbi_app_get_active_window (NULL);
2037 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
2038
2039 priv->form_organization = form_organization;
2040
2041 return TRUE;
2042 }
2043
2044 /**
2045 * show/hide the form according to the expander,
2046 * this will emit a signal as if the user changed it by himself
2047 *
2048 * \param
2049 *
2050 * \return FALSE
2051 * */
grisbi_win_switch_form_expander(void)2052 gboolean grisbi_win_switch_form_expander (void)
2053 {
2054 gboolean is_visible;
2055 GrisbiWin *win;
2056 GrisbiWinPrivate *priv;
2057
2058 win = grisbi_app_get_active_window (NULL);
2059 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
2060
2061 if (!priv->form_expander)
2062 return FALSE;
2063
2064 is_visible = gtk_expander_get_expanded (GTK_EXPANDER (priv->form_expander));
2065 gtk_expander_set_expanded (GTK_EXPANDER (priv->form_expander), !is_visible);
2066
2067 return FALSE;
2068 }
2069
2070 /* HEADINGS */
2071 /**
2072 * sensitive or unsensitive the headings
2073 *
2074 * \param sensitive TRUE to sensitive
2075 *
2076 * \return
2077 * */
grisbi_win_headings_sensitive_headings(gboolean sensitive)2078 void grisbi_win_headings_sensitive_headings (gboolean sensitive)
2079 {
2080 GtkWidget *headings_eb;
2081
2082 headings_eb = grisbi_win_get_headings_eb (NULL);
2083 gtk_widget_set_sensitive (headings_eb, sensitive);
2084 }
2085
2086 /**
2087 * Display or hide the headings bar depending on configuration.
2088 *
2089 * \param
2090 *
2091 * \return FALSE
2092 */
grisbi_win_headings_update_show_headings(void)2093 gboolean grisbi_win_headings_update_show_headings (void)
2094 {
2095 GtkWidget *headings_eb;
2096 GrisbiAppConf *a_conf;
2097
2098 a_conf = grisbi_app_get_a_conf ();
2099 headings_eb = grisbi_win_get_headings_eb (NULL);
2100 if (a_conf->show_headings_bar)
2101 {
2102 gtk_widget_show_all (headings_eb);
2103 }
2104 else
2105 {
2106 gtk_widget_hide (headings_eb);
2107 }
2108 return FALSE;
2109 }
2110
2111 /**
2112 * Update headings bar with a new title.
2113 *
2114 * \param title String to display as a title in headings bar.
2115 *
2116 */
grisbi_win_headings_update_title(gchar * title)2117 void grisbi_win_headings_update_title (gchar *title)
2118 {
2119 GrisbiAppConf *a_conf;
2120 GrisbiWinPrivate *priv;
2121
2122 a_conf = grisbi_app_get_a_conf ();
2123 if (!a_conf->show_headings_bar)
2124 return;
2125
2126 priv = grisbi_win_get_instance_private (GRISBI_WIN (grisbi_app_get_active_window (NULL)));
2127
2128 grisbi_win_headings_private_update_label_markup (GTK_LABEL (priv->headings_title), title, TRUE);
2129 }
2130
2131 /**
2132 * Update headings bar with a new suffix.
2133 *
2134 * \param suffix String to display as a suffix in headings bar.
2135 *
2136 */
grisbi_win_headings_update_suffix(const gchar * suffix)2137 void grisbi_win_headings_update_suffix (const gchar *suffix)
2138 {
2139 GrisbiAppConf *a_conf;
2140 GrisbiWinPrivate *priv;
2141
2142 a_conf = grisbi_app_get_a_conf ();
2143 if (!a_conf->show_headings_bar)
2144 return;
2145
2146 priv = grisbi_win_get_instance_private (GRISBI_WIN (grisbi_app_get_active_window (NULL)));
2147 grisbi_win_headings_private_update_label_markup (GTK_LABEL (priv->headings_suffix), suffix, FALSE);
2148 }
2149
2150 /* STATUS_BAR */
2151 /**
2152 * initiate the GtkStatusBar to hold various status
2153 * information.
2154 *
2155 * \param GrisbiWin *win
2156 *
2157 * \return
2158 */
grisbi_win_init_statusbar(GrisbiWin * win)2159 void grisbi_win_init_statusbar (GrisbiWin *win)
2160 {
2161 GrisbiAppConf *a_conf;
2162 GrisbiWinPrivate *priv;
2163
2164 if (!win)
2165 win = grisbi_app_get_active_window (NULL);
2166
2167 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
2168 a_conf = grisbi_app_get_a_conf ();
2169
2170 /* set status_bar PROVISOIRE */
2171 priv->context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR (priv->statusbar), "Grisbi");
2172 priv->message_id = G_MAXUINT;
2173
2174 /* set visible statusbar if necessary */
2175 if (a_conf->low_definition_screen)
2176 gtk_widget_hide (priv->statusbar);
2177 else
2178 gtk_widget_show (priv->statusbar);
2179 }
2180
2181
2182 /**
2183 * Clear any message in the status bar.
2184 *
2185 * \param
2186 *
2187 * \return
2188 **/
grisbi_win_status_bar_clear(void)2189 void grisbi_win_status_bar_clear (void)
2190 {
2191 GrisbiAppConf *a_conf;
2192 GrisbiWinPrivate *priv;
2193
2194 priv = grisbi_win_get_instance_private (GRISBI_WIN (grisbi_app_get_active_window (NULL)));
2195 a_conf = grisbi_app_get_a_conf ();
2196 if (a_conf->low_definition_screen || !priv->statusbar || !GTK_IS_STATUSBAR (priv->statusbar))
2197 return;
2198
2199 if (priv->message_id < G_MAXUINT)
2200 {
2201 gtk_statusbar_remove (GTK_STATUSBAR (priv->statusbar), priv->context_id, priv->message_id);
2202 priv->message_id = G_MAXUINT;
2203 }
2204
2205 /* force status message to be displayed NOW */
2206 update_gui ();
2207 }
2208
2209 /**
2210 * Display a message in the status bar.
2211 *
2212 * \param message Message to display.
2213 *
2214 * \return
2215 **/
grisbi_win_status_bar_message(gchar * message)2216 void grisbi_win_status_bar_message (gchar *message)
2217 {
2218 GrisbiAppConf *a_conf;
2219 GrisbiWinPrivate *priv;
2220
2221 priv = grisbi_win_get_instance_private (GRISBI_WIN (grisbi_app_get_active_window (NULL)));
2222 a_conf = grisbi_app_get_a_conf ();
2223 if (a_conf->low_definition_screen || !priv->statusbar || !GTK_IS_STATUSBAR (priv->statusbar))
2224 return;
2225
2226 if (priv->message_id < G_MAXUINT)
2227 gtk_statusbar_remove (GTK_STATUSBAR (priv->statusbar), priv->context_id, priv->message_id);
2228
2229 priv->message_id = gtk_statusbar_push (GTK_STATUSBAR (priv->statusbar), priv->context_id, message);
2230
2231 /* force status message to be displayed NOW */
2232 update_gui ();
2233 }
2234
2235 /**
2236 * Change current cursor to a animated watch (if animation supported
2237 * by environment).
2238 *
2239 * \param force_update Call a gtk iteration to ensure cursor
2240 * is updated. May cause trouble if
2241 * called from some signal handlers.
2242 *
2243 * \return
2244 **/
grisbi_win_status_bar_wait(gboolean force_update)2245 void grisbi_win_status_bar_wait (gboolean force_update)
2246 {
2247 GdkCursor *cursor;
2248 GdkDevice *device;
2249 GdkDisplay *display;
2250 GdkWindow *current_window;
2251 GdkWindow *run_window;
2252 GrisbiAppConf *a_conf;
2253 GrisbiWin *win;
2254 GrisbiWinPrivate *priv;
2255
2256 a_conf = grisbi_app_get_a_conf ();
2257 if (a_conf->low_definition_screen)
2258 return;
2259
2260 win = grisbi_app_get_active_window (NULL);
2261 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
2262
2263 run_window = gtk_widget_get_window (GTK_WIDGET (win));
2264 display = gdk_window_get_display (run_window);
2265 cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
2266 gdk_window_set_cursor (run_window, cursor);
2267
2268 #if GTK_CHECK_VERSION (3,20,0)
2269 GdkSeat *default_seat;
2270
2271 default_seat = gdk_display_get_default_seat (display);
2272 device = gdk_seat_get_pointer (default_seat);
2273 #else
2274 GdkDeviceManager *device_manager;
2275
2276 device_manager = gdk_display_get_device_manager (display);
2277 device = gdk_device_manager_get_client_pointer (device_manager);
2278 #endif
2279
2280 current_window = gdk_device_get_window_at_position (device, NULL, NULL);
2281 if (current_window && GDK_IS_WINDOW (current_window) && current_window != run_window)
2282 {
2283 GdkWindow *parent;
2284
2285 parent = gdk_window_get_toplevel (current_window);
2286 if (parent && parent != current_window)
2287 {
2288 current_window = parent;
2289 }
2290 gdk_window_set_cursor (current_window, cursor);
2291
2292 priv->tracked_window = current_window;
2293 }
2294
2295 if (force_update)
2296 update_gui ();
2297 }
2298
2299 /**
2300 * Change current cursor to default cursor.
2301 *
2302 * \param force_update Call a gtk iteration to ensure cursor
2303 * is updated. May cause trouble if
2304 * called from some signal handlers.
2305 *
2306 * \return
2307 **/
grisbi_win_status_bar_stop_wait(gboolean force_update)2308 void grisbi_win_status_bar_stop_wait (gboolean force_update)
2309 {
2310 GrisbiWin *win;
2311 GrisbiWinPrivate *priv;
2312 GrisbiAppConf *a_conf;
2313
2314 a_conf = grisbi_app_get_a_conf ();
2315 if (a_conf->low_definition_screen)
2316 return;
2317
2318 win = grisbi_app_get_active_window (NULL);
2319 if (!win)
2320 return;
2321
2322 priv = grisbi_win_get_instance_private (GRISBI_WIN (win));
2323 if (priv->tracked_window && gdk_window_is_visible (priv->tracked_window))
2324 {
2325 gdk_window_set_cursor (priv->tracked_window, NULL);
2326 priv->tracked_window = NULL;
2327 }
2328
2329 gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (win)), NULL);
2330
2331 if (force_update)
2332 update_gui ();
2333 }
2334
2335 /**
2336 *
2337 *
2338 * \param
2339 *
2340 * \return
2341 **/
grisbi_win_status_bar_set_font_size(gint font_size)2342 void grisbi_win_status_bar_set_font_size (gint font_size)
2343 {
2344 gchar *data = NULL;
2345 gchar *font_size_str;
2346 GrisbiAppConf *a_conf;
2347
2348 devel_debug (NULL);
2349 a_conf = grisbi_app_get_a_conf ();
2350 if (a_conf->low_definition_screen)
2351 return;
2352
2353 font_size_str = utils_str_itoa (font_size);
2354 data = g_strconcat ("#global_statusbar {\n\tfont-size: ", font_size_str, "px;\n}\n", NULL);
2355 gsb_css_set_property_from_name ("#global_statusbar", data);
2356
2357 g_free (font_size_str);
2358 g_free (data);
2359 }
2360
2361 /* TOOLBARS */
2362 /**
2363 *
2364 *
2365 * \param
2366 *
2367 * \return
2368 **/
grisbi_win_update_all_toolbars(void)2369 void grisbi_win_update_all_toolbars (void)
2370 {
2371 gint toolbar_style = 0;
2372 GrisbiAppConf *a_conf;
2373
2374 a_conf = grisbi_app_get_a_conf ();
2375 switch (a_conf->display_toolbar)
2376 {
2377 case GSB_BUTTON_TEXT:
2378 toolbar_style = GTK_TOOLBAR_TEXT;
2379 break;
2380 case GSB_BUTTON_ICON:
2381 toolbar_style = GTK_TOOLBAR_ICONS;
2382 break;
2383 case GSB_BUTTON_BOTH:
2384 toolbar_style = GTK_TOOLBAR_BOTH;
2385 break;
2386 case GSB_BUTTON_BOTH_HORIZ:
2387 toolbar_style = GTK_TOOLBAR_BOTH_HORIZ;
2388 break;
2389 }
2390
2391 gsb_gui_transaction_toolbar_set_style (toolbar_style);
2392 gsb_gui_scheduler_toolbar_set_style (toolbar_style);
2393 gsb_gui_payees_toolbar_set_style (toolbar_style);
2394 gsb_gui_categories_toolbar_set_style (toolbar_style);
2395 gsb_gui_budgetary_lines_toolbar_set_style (toolbar_style);
2396 etats_onglet_reports_toolbar_set_style (toolbar_style);
2397 bet_array_update_toolbar (toolbar_style);
2398 bet_historical_update_toolbar (toolbar_style);
2399 bet_finance_ui_update_all_finance_toolbars (toolbar_style);
2400 }
2401
2402 /**
2403 *
2404 *
2405 * \param
2406 *
2407 * \return
2408 **/
2409 /* Local Variables: */
2410 /* c-basic-offset: 4 */
2411 /* End: */
2412