1 /* ************************************************************************** */
2 /* */
3 /* Copyright (C) 2000-2008 Cédric Auger (cedric@grisbi.org) */
4 /* 2003-2008 Benjamin Drieu (bdrieu@april.org) */
5 /* https://www.grisbi.org/ */
6 /* */
7 /* This program is free software; you can redistribute it and/or modify */
8 /* it under the terms of the GNU General Public License as published by */
9 /* the Free Software Foundation; either version 2 of the License, or */
10 /* (at your option) any later version. */
11 /* */
12 /* This program is distributed in the hope that it will be useful, */
13 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
14 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
15 /* GNU General Public License for more details. */
16 /* */
17 /* You should have received a copy of the GNU General Public License */
18 /* along with this program; if not, write to the Free Software */
19 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
20 /* */
21 /* ************************************************************************** */
22
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include "include.h"
29 #include <gdk/gdkkeysyms.h>
30 #include <glib/gi18n.h>
31
32 /*START_INCLUDE*/
33 #include "navigation.h"
34 #include "accueil.h"
35 #include "bet_data.h"
36 #include "bet_finance_ui.h"
37 #include "categories_onglet.h"
38 #include "dialog.h"
39 #include "etats_onglet.h"
40 #include "grisbi_app.h"
41 #include "gsb_account.h"
42 #include "gsb_account_property.h"
43 #include "gsb_assistant_account.h"
44 #include "gsb_calendar.h"
45 #include "gsb_data_account.h"
46 #include "gsb_data_archive_store.h"
47 #include "gsb_data_import_rule.h"
48 #include "gsb_data_reconcile.h"
49 #include "gsb_data_report.h"
50 #include "gsb_dirs.h"
51 #include "gsb_file.h"
52 #include "gsb_form.h"
53 #include "gsb_form_scheduler.h"
54 #include "gsb_form_widget.h"
55 #include "gsb_real.h"
56 #include "gsb_reconcile.h"
57 #include "gsb_report.h"
58 #include "gsb_rgba.h"
59 #include "gsb_scheduler_list.h"
60 #include "gsb_transactions_list.h"
61 #include "imputation_budgetaire.h"
62 #include "menu.h"
63 #include "metatree.h"
64 #include "mouse.h"
65 #include "structures.h"
66 #include "tiers_onglet.h"
67 #include "traitement_variables.h"
68 #include "transaction_list.h"
69 #include "transaction_list_select.h"
70 #include "transaction_list_sort.h"
71 #include "utils.h"
72 #include "utils_dates.h"
73 #include "utils_real.h"
74 #include "utils_str.h"
75 #include "erreur.h"
76 /*END_INCLUDE*/
77
78
79 /*START_STATIC*/
80 static void gsb_gui_navigation_activate_expander ( GtkTreeView *tree_view,
81 GtkTreeIter *iter,
82 GtkTreePath *path,
83 gpointer user_data );
84 static gboolean gsb_gui_navigation_button_press ( GtkWidget *tree_view,
85 GdkEventButton *ev,
86 gpointer null );
87 static gboolean gsb_gui_navigation_check_key_press ( GtkWidget *tree_view,
88 GdkEventKey *ev,
89 GtkTreeModel *model );
90 static void gsb_gui_navigation_clear_pages_list ( void );
91 static void gsb_gui_navigation_context_menu ( GtkWidget *tree_view,
92 GtkTreePath *path );
93 static GtkTreePath *gsb_gui_navigation_get_page_path ( GtkTreeModel *model,
94 gint type_page );
95 static gboolean gsb_gui_navigation_move_ordre ( gint src_ordre,
96 gint dst_ordre );
97 static gboolean gsb_gui_navigation_remove_account_iterator ( GtkTreeModel *model,
98 GtkTreePath *path,
99 GtkTreeIter *iter,
100 gpointer data );
101 static gboolean gsb_gui_navigation_remove_report_iterator ( GtkTreeModel *model,
102 GtkTreePath *path,
103 GtkTreeIter *iter,
104 gpointer data );
105 static void gsb_gui_navigation_set_selection_branch ( GtkTreeSelection *selection,
106 GtkTreeIter * iter, gint page,
107 gint account_number, gint report_number );
108 static void gsb_gui_navigation_set_navigation_pages ( GtkTreeModel *model,
109 gint type_page,
110 gint ordre );
111 static void gsb_gui_navigation_update_account_iter ( GtkTreeModel *model,
112 GtkTreeIter * account_iter,
113 gint account_number );
114 static gboolean gsb_gui_navigation_update_account_iterator ( GtkTreeModel *model,
115 GtkTreePath *path,
116 GtkTreeIter *iter,
117 gpointer data );
118 static void gsb_gui_navigation_update_report_iter ( GtkTreeModel *model,
119 GtkTreeIter * report_iter,
120 gint report_number );
121 static gboolean gsb_gui_navigation_update_report_iterator ( GtkTreeModel *model,
122 GtkTreePath *path,
123 GtkTreeIter *iter,
124 gpointer data );
125 static gboolean navigation_sort_column ( GtkTreeModel *model,
126 GtkTreeIter *a,
127 GtkTreeIter *b,
128 gpointer user_data );
129 static gboolean navigation_tree_drag_data_get ( GtkTreeDragSource *drag_source,
130 GtkTreePath *path,
131 GtkSelectionData *selection_data );
132 /*END_STATIC*/
133
134
135 /*START_EXTERN*/
136 /*END_EXTERN*/
137
138
139 /** Holds data for the navigation tree. */
140 enum navigation_cols {
141 NAVIGATION_PIX,
142 NAVIGATION_PIX_VISIBLE,
143 NAVIGATION_TEXT,
144 NAVIGATION_FONT,
145 NAVIGATION_PAGE,
146 NAVIGATION_ACCOUNT,
147 NAVIGATION_REPORT,
148 NAVIGATION_COLOR_TEXT,
149 NAVIGATION_ORDRE, /* ordre des pages dans le modèle */
150 NAVIGATION_TOTAL
151 };
152
153 /** Navigation tree view. */
154 static GtkWidget *navigation_tree_view = NULL;
155
156 /** Model of the navigation tree. */
157 static GtkTreeModel *navigation_model = NULL;
158
159 /** Widget that hold the scheduler calendar. */
160 static GtkWidget *scheduler_calendar = NULL;
161
162 /** Widget that hold all reconciliation widgets. */
163 GtkWidget *reconcile_panel;
164
165 /* contains the number of the last account
166 * when switching between 2 accounts
167 * at the end of the switch, contains the current account number */
168 static gint buffer_last_account = -1;
169
170 /* contains a g_queue of GsbGuiNavigationPage */
171 static GQueue *pages_list = NULL;
172
173 /* nombre de pages du panneau de gauche */
174 static gint navigation_nbre_pages = 7;
175
176 /* ordre par défaut des pages du panneau de gauche */
177 const gchar *default_navigation_order_list = "0-2-3-4-5-6-7";
178
179 /* gestion des expandeurs */
180 static gboolean account_expander = TRUE;
181 static gboolean report_expander = FALSE;
182
183 static GtkTargetEntry row_targets[] = {{(gchar*)"GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0}};
184
185 /******************************************************************************/
186 /* Private functions */
187 /******************************************************************************/
188 /**
189 *
190 *
191 * \param
192 *
193 * \return
194 **/
gsb_gui_navigation_select_report(GtkTreeSelection * selection,GtkTreeModel * model)195 static void gsb_gui_navigation_select_report (GtkTreeSelection *selection,
196 GtkTreeModel *model )
197 {
198 GtkTreeIter iter;
199 GtkTreePath *path;
200
201 gtk_tree_selection_get_selected (selection, NULL, &iter);
202 path = gtk_tree_model_get_path (model, &iter);
203 if (path)
204 {
205 gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (navigation_tree_view), path, NULL, FALSE, 0.0, 0.0 );
206 gtk_tree_path_free (path);
207 }
208 }
209
210 /******************************************************************************/
211 /* Public functions */
212 /******************************************************************************/
gsb_gui_navigation_tree_view_selection_changed(void)213 gulong gsb_gui_navigation_tree_view_selection_changed (void)
214 {
215 gulong handler_ID;
216
217 handler_ID = g_signal_connect_after (gtk_tree_view_get_selection (GTK_TREE_VIEW (navigation_tree_view)),
218 "changed",
219 G_CALLBACK (gsb_gui_navigation_select_line),
220 navigation_model);
221
222 return handler_ID;
223 }
224
225 /**
226 * Create the navigation pane on the left of the GUI. It contains
227 * account list as well as shortcuts.
228 *
229 * \return The newly allocated pane.
230 */
gsb_gui_navigation_create_navigation_pane(void)231 GtkWidget *gsb_gui_navigation_create_navigation_pane ( void )
232 {
233 GtkWidget *window;
234 GtkWidget *grid;
235 GtkWidget *sw;
236 GQueue *tmp_queue;
237 GtkCellRenderer *renderer;
238 GtkTreeDragDestIface *navigation_dst_iface;
239 GtkTreeDragSourceIface *navigation_src_iface;
240 GtkTreeViewColumn *column;
241 gint i;
242 gint xpad;
243 gint ypad;
244 GrisbiAppConf *a_conf;
245
246 a_conf = (GrisbiAppConf *) grisbi_app_get_a_conf ();
247 window = GTK_WIDGET (grisbi_app_get_active_window (NULL));
248 grid = gtk_grid_new ();
249
250 sw = gtk_scrolled_window_new (NULL, NULL);
251 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
252 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
253 GTK_POLICY_AUTOMATIC,
254 GTK_POLICY_AUTOMATIC);
255
256 /* Create the view */
257 navigation_tree_view = gtk_tree_view_new ();
258 gtk_widget_set_name (navigation_tree_view, "tree_view");
259 gtk_tree_view_set_headers_visible ( GTK_TREE_VIEW(navigation_tree_view), FALSE );
260 gtk_widget_set_events (navigation_tree_view, GDK_SCROLL_MASK);
261 gtk_container_add ( GTK_CONTAINER(sw), navigation_tree_view );
262
263 navigation_model = GTK_TREE_MODEL ( gtk_tree_store_new ( NAVIGATION_TOTAL,
264 GDK_TYPE_PIXBUF, /* NAVIGATION_PIX */
265 G_TYPE_BOOLEAN, /* NAVIGATION_PIX_VISIBLE */
266 G_TYPE_STRING, /* NAVIGATION_TEXT */
267 G_TYPE_INT, /* NAVIGATION_FONT */
268 G_TYPE_INT, /* NAVIGATION_PAGE */
269 G_TYPE_INT, /* NAVIGATION_ACCOUNT */
270 G_TYPE_INT, /* NAVIGATION_REPORT */
271 G_TYPE_STRING, /* NAVIGATION_COLOR_TEXT */
272 G_TYPE_INT ) ); /* NAVIGATION_ORDRE */
273
274 gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE ( navigation_model ),
275 NAVIGATION_ORDRE, GTK_SORT_ASCENDING );
276 gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE ( navigation_model ),
277 NAVIGATION_ORDRE, navigation_sort_column,
278 NULL, NULL );
279
280 /* Enable drag & drop */
281 gtk_tree_view_enable_model_drag_source ( GTK_TREE_VIEW ( navigation_tree_view ),
282 GDK_BUTTON1_MASK,
283 row_targets, 1,
284 GDK_ACTION_MOVE | GDK_ACTION_COPY );
285 gtk_tree_view_enable_model_drag_dest ( GTK_TREE_VIEW ( navigation_tree_view ),
286 row_targets,
287 1,
288 GDK_ACTION_MOVE | GDK_ACTION_COPY );
289 gtk_tree_view_set_reorderable ( GTK_TREE_VIEW ( navigation_tree_view ), TRUE );
290 gtk_tree_selection_set_mode ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( navigation_tree_view ) ),
291 GTK_SELECTION_SINGLE );
292 gtk_tree_view_set_model ( GTK_TREE_VIEW ( navigation_tree_view ), GTK_TREE_MODEL( navigation_model ) );
293 /* FIXME, since navigation_model is a static variable, we _do_ hold a ref...
294 Maybe we should be using a WeakRef? */
295 g_object_unref ( G_OBJECT ( navigation_model ) );
296
297 /* Handle drag & drop */
298 navigation_dst_iface = GTK_TREE_DRAG_DEST_GET_IFACE ( navigation_model );
299 if ( navigation_dst_iface )
300 {
301 navigation_dst_iface -> drag_data_received = &gsb_gui_navigation_drag_data_received;
302 navigation_dst_iface -> row_drop_possible = &gsb_gui_navigation_row_drop_possible;
303 }
304
305 navigation_src_iface = GTK_TREE_DRAG_SOURCE_GET_IFACE (navigation_model);
306 if ( navigation_src_iface )
307 {
308 gtk_selection_add_target (window,
309 GDK_SELECTION_PRIMARY,
310 GDK_SELECTION_TYPE_ATOM,
311 1);
312 navigation_src_iface -> drag_data_get = &navigation_tree_drag_data_get;
313 }
314
315 /* check the keyboard before all, if we need to move other things that the navigation
316 * tree view (for example, up and down on transactions list) */
317 g_signal_connect ( navigation_tree_view,
318 "key-press-event",
319 G_CALLBACK ( gsb_gui_navigation_check_key_press ),
320 navigation_model );
321
322 g_signal_connect ( navigation_tree_view,
323 "scroll-event",
324 G_CALLBACK ( gsb_gui_navigation_check_scroll ),
325 NULL );
326
327 if ( a_conf->active_scrolling_left_pane == 0 )
328 g_signal_handlers_block_by_func ( gsb_gui_navigation_get_tree_view ( ),
329 G_CALLBACK ( gsb_gui_navigation_check_scroll ),
330 NULL );
331
332 /* Create column */
333 column = gtk_tree_view_column_new ( );
334
335 /* Pixbuf renderer. */
336 renderer = gtk_cell_renderer_pixbuf_new ();
337 gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
338 gtk_tree_view_column_add_attribute(GTK_TREE_VIEW_COLUMN(column), renderer,
339 "pixbuf", NAVIGATION_PIX);
340 gtk_tree_view_column_add_attribute(GTK_TREE_VIEW_COLUMN(column), renderer,
341 "visible", NAVIGATION_PIX_VISIBLE);
342 gtk_tree_view_column_set_expand ( column, FALSE );
343
344 /* Text renderer. */
345 renderer = gtk_cell_renderer_text_new ();
346
347 gtk_cell_renderer_get_padding ( GTK_CELL_RENDERER ( renderer ), &xpad, &ypad );
348 gtk_cell_renderer_set_padding ( GTK_CELL_RENDERER ( renderer ), 6, ypad );
349 gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, TRUE);
350 gtk_tree_view_column_add_attribute(GTK_TREE_VIEW_COLUMN(column), renderer,
351 "text", NAVIGATION_TEXT);
352 gtk_tree_view_column_add_attribute(GTK_TREE_VIEW_COLUMN(column), renderer,
353 "weight", NAVIGATION_FONT);
354 gtk_tree_view_column_add_attribute(GTK_TREE_VIEW_COLUMN(column), renderer,
355 "foreground", NAVIGATION_COLOR_TEXT);
356
357 gtk_tree_view_append_column ( GTK_TREE_VIEW ( navigation_tree_view ),
358 GTK_TREE_VIEW_COLUMN ( column ) );
359
360 /* disable searching searching */
361 gtk_tree_view_set_search_column (GTK_TREE_VIEW (navigation_tree_view), -1);
362
363 /* crée les pages dans le panneau de gauche */
364 tmp_queue = gsb_gui_navigation_get_pages_list ( );
365
366 for ( i = 0 ; i < (gint) tmp_queue->length ; i++ )
367 {
368 GsbGuiNavigationPage *page;
369
370 page = g_queue_peek_nth ( tmp_queue, i );
371 gsb_gui_navigation_set_navigation_pages ( navigation_model, page -> type_page, i );
372 }
373
374 /* Finish tree. */
375 gtk_grid_attach (GTK_GRID (grid), sw, 0,0,1,1);
376 gtk_widget_set_hexpand (sw, TRUE);
377 gtk_widget_set_vexpand (sw, TRUE);
378
379 /* Create calendar (hidden for now). */
380 scheduler_calendar = gsb_calendar_new ();
381 gtk_grid_attach (GTK_GRID (grid), scheduler_calendar, 0,1,1,1);
382
383 /* Create reconcile stuff (hidden for now). */
384 reconcile_panel = gsb_reconcile_create_box ();
385 gtk_grid_attach (GTK_GRID (grid), reconcile_panel, 0,2,1,1);
386
387 /* signals of tree_view */
388 g_signal_connect ( G_OBJECT ( navigation_tree_view ),
389 "button-press-event",
390 G_CALLBACK ( gsb_gui_navigation_button_press ),
391 NULL );
392
393 g_signal_connect ( G_OBJECT ( navigation_tree_view ),
394 "row-collapsed",
395 G_CALLBACK ( gsb_gui_navigation_activate_expander ),
396 GINT_TO_POINTER ( 0 ) );
397 g_signal_connect ( G_OBJECT ( navigation_tree_view ),
398 "row-expanded",
399 G_CALLBACK ( gsb_gui_navigation_activate_expander ),
400 GINT_TO_POINTER ( 1 ) );
401
402 gtk_widget_show_all (grid);
403 gtk_widget_hide ( scheduler_calendar );
404 gtk_widget_hide ( reconcile_panel );
405
406 return grid;
407 }
408
409
410
411 /**
412 * return the current page selected
413 * the value returned is defined by GSB_GENERAL_NOTEBOOK_PAGES
414 *
415 * \param
416 *
417 * \return a gint which is the numero of the page, -1 if problem
418 *
419 * */
gsb_gui_navigation_get_current_page(void)420 gint gsb_gui_navigation_get_current_page ( void )
421 {
422 GtkTreeSelection *selection;
423 GtkTreeIter iter;
424 gint page;
425
426 if (!navigation_tree_view)
427 return -1;
428
429 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (navigation_tree_view));
430
431 if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
432 return GSB_HOME_PAGE;
433
434 gtk_tree_model_get ( GTK_TREE_MODEL (navigation_model),
435 &iter,
436 NAVIGATION_PAGE, &page,
437 -1);
438 return page;
439 }
440
441
442
443 /**
444 * return the account number selected
445 * rem : this is only for account number of the transactions list,
446 * if we want the current account number, for transactions or scheduled, go to
447 * see gsb_form_get_account_number
448 *
449 * \param
450 *
451 * \return a gint, the account number or -1 if none selected
452 * */
gsb_gui_navigation_get_current_account(void)453 gint gsb_gui_navigation_get_current_account ( void )
454 {
455 GtkTreeSelection *selection;
456 GtkTreeIter iter;
457 gint page;
458 gint account_number;
459
460 if ( !navigation_tree_view )
461 return -1;
462
463 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (navigation_tree_view));
464
465 if (! gtk_tree_selection_get_selected (selection, NULL, &iter))
466 return -1;
467
468 gtk_tree_model_get ( GTK_TREE_MODEL (navigation_model),
469 &iter,
470 NAVIGATION_PAGE, &page,
471 NAVIGATION_ACCOUNT, &account_number,
472 -1);
473
474 if ( page == GSB_ACCOUNT_PAGE )
475 return account_number;
476
477 return -1;
478 }
479
480
481 /*
482 * return the content of buffer_last_account
483 * used while changing an account, as long as the work
484 * is not finished, that variable contains the last account number
485 *
486 * \param
487 *
488 * \return the last account number (become the current account number once the
489 * switch is finished...)
490 *
491 * */
gsb_gui_navigation_get_last_account(void)492 gint gsb_gui_navigation_get_last_account ( void )
493 {
494 return buffer_last_account;
495 }
496
497
498 /**
499 * Return the number of the current selected report
500 *
501 * \param
502 *
503 * \return the current number of the report, or 0 if none selected
504 * */
gsb_gui_navigation_get_current_report(void)505 gint gsb_gui_navigation_get_current_report ( void )
506 {
507 GtkTreeSelection *selection;
508 GtkTreeIter iter;
509 gint page;
510
511 if ( ! navigation_tree_view )
512 {
513 return 0;
514 }
515
516 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (navigation_tree_view));
517
518 if (! gtk_tree_selection_get_selected (selection, NULL, &iter))
519 return 0;
520
521 gtk_tree_model_get ( GTK_TREE_MODEL (navigation_model),
522 &iter,
523 NAVIGATION_PAGE, &page,
524 -1);
525
526 if ( page == GSB_REPORTS_PAGE)
527 {
528 gint report_number;
529 gtk_tree_model_get (GTK_TREE_MODEL(navigation_model), &iter, NAVIGATION_REPORT, &report_number, -1);
530
531 return report_number;
532 }
533
534 return -1;
535 }
536
537
538
539
540 /**
541 * Create a list of tree items that are shortcuts to accounts.
542 *
543 * \param model Tree model to insert items into.
544 * \param account_iter Parent iter.
545 */
gsb_gui_navigation_create_account_list(GtkTreeModel * model)546 void gsb_gui_navigation_create_account_list ( GtkTreeModel *model )
547 {
548 GSList *list_tmp;
549 GtkTreeIter parent, child;
550 GtkTreePath *path;
551 GrisbiAppConf *a_conf;
552
553 a_conf = (GrisbiAppConf *) grisbi_app_get_a_conf ();
554 path = gsb_gui_navigation_get_page_path ( model, GSB_HOME_PAGE );
555 gtk_tree_model_get_iter ( GTK_TREE_MODEL( model ), &parent, path );
556 gtk_tree_path_free (path);
557
558 /* Remove childs if any. */
559 while ( gtk_tree_model_iter_children ( model, &child, &parent ) )
560 {
561 gtk_tree_store_remove ( GTK_TREE_STORE ( model ), &child );
562 }
563
564 /* Fill in with accounts. */
565 list_tmp = gsb_data_account_get_list_accounts ();
566 while ( list_tmp )
567 {
568 gint i = gsb_data_account_get_no_account ( list_tmp -> data );
569
570 if ( a_conf->show_closed_accounts ||
571 ! gsb_data_account_get_closed_account ( i ) )
572 {
573 gsb_gui_navigation_add_account ( i, FALSE );
574 }
575
576 list_tmp = list_tmp -> next;
577 }
578
579 /* Expand stuff */
580 if ( account_expander )
581 {
582 path = gtk_tree_model_get_path ( GTK_TREE_MODEL ( model ), &parent );
583 gtk_tree_view_expand_to_path ( GTK_TREE_VIEW ( navigation_tree_view ), path );
584 gtk_tree_path_free ( path );
585 }
586 }
587
588
589
590 /**
591 * Create a list of tree items that are shortcuts to reports.
592 *
593 * \param model Tree model to insert items into.
594 * \param reports_iter Parent iter.
595 */
gsb_gui_navigation_create_report_list(GtkTreeModel * model)596 void gsb_gui_navigation_create_report_list ( GtkTreeModel *model )
597 {
598 GSList *tmp_list;
599 GtkTreeIter parent, child;
600 GtkTreePath *path;
601 gchar *str_color = (gchar*)"black";
602
603 path = gsb_gui_navigation_get_page_path ( model, GSB_REPORTS_PAGE );
604 gtk_tree_model_get_iter ( GTK_TREE_MODEL( model ), &parent, path );
605 gtk_tree_path_free (path);
606
607 /* Remove childs if any. */
608 while ( gtk_tree_model_iter_children ( model, &child, &parent ) )
609 {
610 gtk_tree_store_remove ( GTK_TREE_STORE ( model ), &child );
611 }
612
613 str_color = gsb_rgba_get_couleur_with_indice_to_str ("color_text", 0);
614
615 /* Fill in with reports */
616 tmp_list = gsb_data_report_get_report_list ();
617
618 while ( tmp_list )
619 {
620 gint report_number;
621 gchar *tmp_name;
622
623 report_number = gsb_data_report_get_report_number ( tmp_list -> data );
624 tmp_name = utils_str_break_form_name_field (gsb_data_report_get_report_name (report_number),
625 TRUNC_FORM_FIELD);
626
627 gtk_tree_store_append ( GTK_TREE_STORE ( model ), &child, &parent);
628 gtk_tree_store_set(GTK_TREE_STORE(model), &child,
629 NAVIGATION_PIX_VISIBLE, FALSE,
630 NAVIGATION_TEXT, tmp_name,
631 NAVIGATION_FONT, 400,
632 NAVIGATION_PAGE, GSB_REPORTS_PAGE,
633 NAVIGATION_ACCOUNT, -1,
634 NAVIGATION_COLOR_TEXT, str_color,
635 NAVIGATION_REPORT, report_number,
636 -1 );
637 g_free (tmp_name);
638
639 tmp_list = tmp_list -> next;
640 }
641
642 /* Expand stuff */
643 if ( report_expander )
644 {
645 path = gtk_tree_model_get_path ( GTK_TREE_MODEL ( model ), &parent );
646 gtk_tree_view_expand_to_path ( GTK_TREE_VIEW ( navigation_tree_view ), path );
647 gtk_tree_path_free ( path );
648 }
649 }
650
651
652
653
654 /**
655 *
656 *
657 *
658 */
navigation_sort_column(GtkTreeModel * model,GtkTreeIter * a,GtkTreeIter * b,gpointer user_data)659 gboolean navigation_sort_column ( GtkTreeModel *model,
660 GtkTreeIter *a,
661 GtkTreeIter *b,
662 gpointer user_data )
663 {
664 gint ordre_a, page_a, account_a, report_a;
665 gint ordre_b, page_b, account_b, report_b;
666
667 if ( ! model )
668 return FALSE;
669
670 gtk_tree_model_get ( model, a,
671 NAVIGATION_PAGE, &page_a,
672 NAVIGATION_ACCOUNT, &account_a,
673 NAVIGATION_REPORT, &report_a,
674 NAVIGATION_ORDRE, &ordre_a,
675 -1 );
676
677 gtk_tree_model_get ( model, b,
678 NAVIGATION_PAGE, &page_b,
679 NAVIGATION_ACCOUNT, &account_b,
680 NAVIGATION_REPORT, &report_b,
681 NAVIGATION_ORDRE, &ordre_b,
682 -1 );
683
684 if ( ordre_a < ordre_b )
685 return - 1;
686 if ( ordre_a > ordre_b )
687 return 1;
688
689 if ( page_a == GSB_ACCOUNT_PAGE && page_b == GSB_ACCOUNT_PAGE )
690 {
691 return gsb_data_account_compare_position (account_a, account_b);
692 }
693 else if ( page_a == GSB_REPORTS_PAGE && page_b == GSB_REPORTS_PAGE )
694 {
695 return gsb_data_report_compare_position (report_a, report_b);
696 }
697 else
698 return 0;
699 }
700
701
702 /**
703 * Iterator that iterates over the navigation pane model and update
704 * iter of account that is equal to `data'.
705 *
706 * \param tree_model Pointer to the model of the navigation tree.
707 * \param path Not used.
708 * \param iter Current iter to test.
709 * \param data Number of an account to match against the
710 * NAVIGATION_ACCOUNT column of current iter.
711 *
712 * \return TRUE if this iter matches.
713 */
gsb_gui_navigation_update_account_iterator(GtkTreeModel * tree_model,GtkTreePath * path,GtkTreeIter * iter,gpointer data)714 static gboolean gsb_gui_navigation_update_account_iterator ( GtkTreeModel *tree_model,
715 GtkTreePath *path,
716 GtkTreeIter *iter,
717 gpointer data )
718 {
719 gint account_number;
720
721 gtk_tree_model_get ( GTK_TREE_MODEL ( tree_model ), iter,
722 NAVIGATION_ACCOUNT, &account_number,
723 -1 );
724
725 if ( account_number == GPOINTER_TO_INT ( data ) )
726 {
727 gsb_gui_navigation_update_account_iter ( tree_model, iter, GPOINTER_TO_INT(data) );
728 return TRUE;
729 }
730
731 return FALSE;
732 }
733
734
735
736 /**
737 * Iterator that iterates over the navigation pane model and update
738 * iter of report that is equal to `data'.
739 *
740 * \param tree_model Pointer to the model of the navigation tree.
741 * \param path Not used.
742 * \param iter Current iter to test.
743 * \param data Number of an report to match against the
744 * NAVIGATION_REPORT column of current iter.
745 *
746 * \return TRUE if this iter matches.
747 */
gsb_gui_navigation_update_report_iterator(GtkTreeModel * tree_model,GtkTreePath * path,GtkTreeIter * iter,gpointer data)748 static gboolean gsb_gui_navigation_update_report_iterator ( GtkTreeModel *tree_model,
749 GtkTreePath *path,
750 GtkTreeIter *iter,
751 gpointer data )
752 {
753 gint report_nb;
754
755 gtk_tree_model_get ( GTK_TREE_MODEL ( tree_model ), iter,
756 NAVIGATION_REPORT, &report_nb,
757 -1 );
758
759 if ( report_nb == GPOINTER_TO_INT ( data ) )
760 {
761 gsb_gui_navigation_update_report_iter ( tree_model, iter, GPOINTER_TO_INT ( data ));
762 return TRUE;
763 }
764
765 return FALSE;
766 }
767
768
769
770 /**
771 * Update information for an report in navigation pane.
772 *
773 * \param report_nb Number of the report that has to be updated.
774 */
gsb_gui_navigation_update_report(gint report_number)775 void gsb_gui_navigation_update_report ( gint report_number )
776 {
777 gtk_tree_model_foreach ( GTK_TREE_MODEL(navigation_model),
778 (GtkTreeModelForeachFunc) gsb_gui_navigation_update_report_iterator,
779 GINT_TO_POINTER ( report_number ) );
780 }
781
782
783
784 /**
785 * Update contents of an iter with report data.
786 *
787 * \param model Pointer to the model of the navigation tree.
788 * \param report_iter Iter to update.
789 * \param data Number of report as a reference.
790 */
gsb_gui_navigation_update_report_iter(GtkTreeModel * model,GtkTreeIter * report_iter,gint report_number)791 void gsb_gui_navigation_update_report_iter ( GtkTreeModel *model,
792 GtkTreeIter * report_iter,
793 gint report_number )
794 {
795 gchar *str_color = (gchar*)"black";
796
797 str_color = gsb_rgba_get_couleur_with_indice_to_str ("color_text", 0);
798 gtk_tree_store_set(GTK_TREE_STORE(model), report_iter,
799 NAVIGATION_TEXT, gsb_data_report_get_report_name (report_number),
800 NAVIGATION_PAGE, GSB_REPORTS_PAGE,
801 NAVIGATION_REPORT, report_number,
802 NAVIGATION_ACCOUNT, -1,
803 NAVIGATION_COLOR_TEXT, str_color,
804 -1 );
805 }
806
807
808
809 /**
810 * Iterator that iterates over the navigation pane model and remove
811 * iter of report that is equal to `data'.
812 *
813 * \param tree_model Pointer to the model of the navigation tree.
814 * \param path Not used.
815 * \param iter Current iter to test.
816 * \param data Number of an report to match against the
817 * NAVIGATION_REPORT column of current iter.
818 *
819 * \return TRUE if this iter matches.
820 */
gsb_gui_navigation_remove_report_iterator(GtkTreeModel * tree_model,GtkTreePath * path,GtkTreeIter * iter,gpointer data)821 static gboolean gsb_gui_navigation_remove_report_iterator ( GtkTreeModel *tree_model,
822 GtkTreePath *path,
823 GtkTreeIter *iter,
824 gpointer data )
825 {
826 gint report;
827
828 gtk_tree_model_get ( GTK_TREE_MODEL ( tree_model ), iter,
829 NAVIGATION_REPORT, &report,
830 -1 );
831
832 if ( report == GPOINTER_TO_INT (data))
833 {
834 if ( gsb_data_report_get_append_in_payee ( report ) )
835 gsb_form_widget_update_payee_combofix ( report, FALSE );
836
837 gtk_tree_store_remove ( GTK_TREE_STORE(tree_model), iter );
838 return TRUE;
839 }
840
841 return FALSE;
842 }
843
844
845
846 /**
847 * Add an report to the navigation pane.
848 *
849 * \param report_nb Report ID to add.
850 */
gsb_gui_navigation_add_report(gint report_number)851 void gsb_gui_navigation_add_report ( gint report_number )
852 {
853 GtkTreeIter parent, iter;
854 GtkTreeSelection *selection;
855 GtkTreePath *path;
856
857 path = gsb_gui_navigation_get_page_path ( navigation_model, GSB_REPORTS_PAGE );
858 gtk_tree_model_get_iter ( GTK_TREE_MODEL( navigation_model ), &parent, path );
859 gtk_tree_store_append ( GTK_TREE_STORE ( navigation_model ), &iter, &parent );
860 gtk_tree_view_expand_to_path ( GTK_TREE_VIEW ( navigation_tree_view ), path );
861
862 gsb_gui_navigation_update_report_iter ( GTK_TREE_MODEL ( navigation_model ), &iter, report_number );
863
864 selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW ( navigation_tree_view ) );
865 gtk_tree_selection_select_iter ( selection, &iter );
866 }
867
868
869
870 /**
871 * Remove report from the navigation pane.
872 *
873 * \param report_nb Report ID to add.
874 */
gsb_gui_navigation_remove_report(gint report_number)875 void gsb_gui_navigation_remove_report ( gint report_number )
876 {
877 gtk_tree_model_foreach ( GTK_TREE_MODEL(navigation_model),
878 (GtkTreeModelForeachFunc) gsb_gui_navigation_remove_report_iterator,
879 GINT_TO_POINTER ( report_number ) );
880 }
881
882
883
884 /**
885 * Update information for an account in navigation pane.
886 *
887 * \param account_number Number of the account that has to be updated.
888 */
gsb_gui_navigation_update_account(gint account_number)889 void gsb_gui_navigation_update_account ( gint account_number )
890 {
891 gtk_tree_model_foreach ( GTK_TREE_MODEL(navigation_model),
892 (GtkTreeModelForeachFunc) gsb_gui_navigation_update_account_iterator,
893 GINT_TO_POINTER ( account_number ) );
894 }
895
896
897
898 /**
899 * Update contents of an iter with account data.
900 *
901 * \param model Pointer to the model of the navigation tree.
902 * \param account_iter Iter to update.
903 * \param data Number of account as a reference.
904 */
gsb_gui_navigation_update_account_iter(GtkTreeModel * model,GtkTreeIter * account_iter,gint account_number)905 void gsb_gui_navigation_update_account_iter ( GtkTreeModel *model,
906 GtkTreeIter *account_iter,
907 gint account_number )
908 {
909 GdkPixbuf * pixbuf = NULL;
910 gboolean closed_account;
911 gchar *str_color = (gchar*)"black";
912 gchar *tmp_name;
913
914 closed_account = gsb_data_account_get_closed_account (account_number);
915 if (closed_account)
916 str_color = (gchar*)"grey";
917 else
918 str_color = gsb_rgba_get_couleur_with_indice_to_str ("color_text", 0);
919
920 pixbuf = gsb_data_account_get_account_icon_pixbuf ( account_number );
921 tmp_name = utils_str_break_form_name_field (gsb_data_account_get_name (account_number),
922 TRUNC_FORM_FIELD);
923
924 gtk_tree_store_set ( GTK_TREE_STORE ( model ), account_iter,
925 NAVIGATION_PIX, pixbuf,
926 NAVIGATION_PIX_VISIBLE, TRUE,
927 NAVIGATION_TEXT, tmp_name,
928 NAVIGATION_FONT, 400,
929 NAVIGATION_PAGE, GSB_ACCOUNT_PAGE,
930 NAVIGATION_ACCOUNT, account_number,
931 NAVIGATION_COLOR_TEXT, str_color,
932 NAVIGATION_REPORT, -1,
933 -1 );
934 g_free (tmp_name);
935
936 g_object_unref ( G_OBJECT ( pixbuf ) );
937 }
938
939
940
941 /**
942 * Iterator that iterates over the navigation pane model and remove
943 * iter of account that is equal to `data'.
944 *
945 * \param tree_model Pointer to the model of the navigation tree.
946 * \param path Not used.
947 * \param iter Current iter to test.
948 * \param data Number of an account to match against the
949 * NAVIGATION_ACCOUNT column of current iter.
950 *
951 * \return TRUE if this iter matches.
952 */
gsb_gui_navigation_remove_account_iterator(GtkTreeModel * tree_model,GtkTreePath * path,GtkTreeIter * iter,gpointer data)953 static gboolean gsb_gui_navigation_remove_account_iterator ( GtkTreeModel *tree_model,
954 GtkTreePath *path,
955 GtkTreeIter *iter,
956 gpointer data )
957 {
958 gint account_number;
959
960 gtk_tree_model_get ( GTK_TREE_MODEL ( tree_model ), iter,
961 NAVIGATION_ACCOUNT, &account_number,
962 -1 );
963
964 if ( account_number == GPOINTER_TO_INT ( data ) )
965 {
966 gtk_tree_store_remove ( GTK_TREE_STORE(tree_model), iter );
967 return TRUE;
968 }
969
970 return FALSE;
971 }
972
973
974
975 /**
976 * Add an account to the navigation pane.
977 *
978 * \param account_number Account ID to add.
979 * \param switch_to_account TRUE to show the account, FALSE to just create it
980 */
gsb_gui_navigation_add_account(gint account_number,gboolean switch_to_account)981 void gsb_gui_navigation_add_account ( gint account_number,
982 gboolean switch_to_account )
983 {
984 GtkTreeIter parent, iter;
985 GtkTreePath *path;
986
987 path = gsb_gui_navigation_get_page_path ( navigation_model, GSB_HOME_PAGE );
988 gtk_tree_model_get_iter ( GTK_TREE_MODEL( navigation_model ), &parent, path );
989 gtk_tree_store_append ( GTK_TREE_STORE ( navigation_model ), &iter, &parent );
990 gtk_tree_path_free (path);
991
992 gsb_gui_navigation_update_account_iter ( GTK_TREE_MODEL ( navigation_model ), &iter, account_number );
993
994 if ( switch_to_account )
995 {
996 GtkTreeSelection * selection;
997
998 selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW ( navigation_tree_view ) );
999 gtk_tree_selection_select_iter ( selection, &iter );
1000 }
1001 }
1002
1003
1004
1005 /**
1006 * change the list of transactions, according to the new account
1007 *
1008 * \param no_account a pointer on the number of the account we want to see
1009 *
1010 * \return FALSE
1011 * */
gsb_gui_navigation_change_account(gint new_account)1012 gboolean gsb_gui_navigation_change_account ( gint new_account )
1013 {
1014 gint current_account;
1015 GrisbiAppConf *a_conf;
1016
1017 devel_debug_int (new_account);
1018 if ( new_account < 0 )
1019 return FALSE;
1020
1021 /* the selection on the navigation bar has already changed, so
1022 * have to use a buffer variable to get the last account */
1023 current_account = gsb_gui_navigation_get_last_account ();
1024
1025 /* mise à jour du menu Editer */
1026 gsb_menu_gui_sensitive_win_menu_item ( "new-ope", TRUE );
1027
1028 /* save the row_align of the last account */
1029 gsb_data_account_set_row_align ( current_account,
1030 gsb_transactions_list_get_row_align ( ) );
1031
1032 /* set the appearance of the list according to the new account */
1033 transaction_list_sort_set_column ( gsb_data_account_get_sort_column (new_account ),
1034 gsb_data_account_get_sort_type ( new_account ) );
1035
1036 gsb_transactions_list_update_tree_view ( new_account, FALSE );
1037 gsb_transactions_list_set_row_align ( gsb_data_account_get_row_align ( new_account ) );
1038
1039 /* mise en place de la date du dernier relevé */
1040 gsb_gui_navigation_update_statement_label ( new_account );
1041
1042 /* show or hide the rules button in toolbar */
1043 gsb_transactions_list_show_menu_import_rule (new_account);
1044
1045 /* Update the title of the file if needed */
1046 a_conf = (GrisbiAppConf *) grisbi_app_get_a_conf ();
1047 if ( a_conf->display_window_title == GSB_ACCOUNT_HOLDER )
1048 grisbi_win_set_window_title ( new_account );
1049
1050 /* select the good tab */
1051 bet_data_select_bet_pages ( new_account );
1052
1053 /* unset the last date written */
1054 gsb_date_free_last_date ();
1055
1056 /* check if balance is < 0 and account_kind == GSB_TYPE_CASH */
1057 if ( gsb_data_account_get_kind ( new_account ) == GSB_TYPE_CASH )
1058 {
1059 GsbReal balance;
1060
1061 balance = gsb_data_account_get_current_balance ( new_account );
1062
1063 if ( balance.mantissa < 0 )
1064 {
1065 dialogue_error ( _("This account cannot be negative.\n\n"
1066 "You must make positive the balance of this account "
1067 "before you can use it.") );
1068
1069 return ( FALSE );
1070 }
1071 }
1072
1073 return FALSE;
1074 }
1075
1076
1077 /**
1078 * update the statement label for the given account
1079 *
1080 * \param account_number
1081 *
1082 * \return
1083 * */
gsb_gui_navigation_update_statement_label(gint account_number)1084 void gsb_gui_navigation_update_statement_label ( gint account_number )
1085 {
1086 GtkWidget *label_last_statement;
1087 gint reconcile_number;
1088 gchar* tmp_str;
1089 gchar* tmp_str1;
1090 gchar* tmp_str2;
1091 gchar *balance_str;
1092 gboolean has_pointed;
1093 GsbReal amount;
1094
1095 reconcile_number = gsb_data_reconcile_get_account_last_number ( account_number );
1096 amount = gsb_data_account_get_marked_balance ( account_number );
1097 has_pointed = gsb_data_account_get_has_pointed (account_number);
1098 if (has_pointed)
1099 balance_str = g_strdup (_("Pointed balance: "));
1100 else
1101 balance_str = g_strdup (_("Reconciled balance: "));
1102
1103 label_last_statement = grisbi_win_get_label_last_statement ();
1104 if ( reconcile_number )
1105 {
1106 tmp_str1 = gsb_format_gdate ( gsb_data_reconcile_get_final_date (
1107 reconcile_number ) );
1108 tmp_str2 = utils_real_get_string_with_currency ( amount,
1109 gsb_data_account_get_currency ( account_number ), TRUE );
1110
1111 tmp_str = g_strconcat (_("Last statement: "), tmp_str1, " - ", balance_str, tmp_str2, NULL);
1112 gtk_label_set_text ( GTK_LABEL ( label_last_statement ), tmp_str);
1113 g_free ( tmp_str );
1114 g_free ( tmp_str1 );
1115 g_free ( tmp_str2 );
1116 }
1117 else if ( amount.mantissa != 0 )
1118 {
1119 tmp_str2 = utils_real_get_string_with_currency (amount,
1120 gsb_data_account_get_currency ( account_number ), TRUE );
1121
1122 tmp_str = g_strconcat (_("Last statement: none"), " - ", balance_str, tmp_str2, NULL);
1123 gtk_label_set_text ( GTK_LABEL ( label_last_statement ), tmp_str);
1124 g_free ( tmp_str );
1125 g_free ( tmp_str2 );
1126 }
1127 else
1128 {
1129 gtk_label_set_text ( GTK_LABEL ( label_last_statement ),
1130 _("Last statement: none") );
1131 }
1132 g_free (balance_str);
1133 }
1134
1135
1136 /**
1137 * Update the account name in the heading bar
1138 *
1139 * \param account_number
1140 *
1141 * \return
1142 */
gsb_gui_navigation_update_account_label(gint account_number)1143 void gsb_gui_navigation_update_account_label ( gint account_number )
1144 {
1145 gchar * title = NULL;
1146
1147 title = g_strconcat ( _("Account"), " : ",
1148 gsb_data_account_get_name ( account_number ),
1149 NULL );
1150 if ( gsb_data_account_get_closed_account ( account_number ) )
1151 {
1152 gchar* old_title = title;
1153 title = g_strconcat ( title, " (", _("closed"), ")", NULL );
1154 g_free ( old_title );
1155 }
1156
1157 gsb_data_account_colorize_current_balance ( account_number );
1158 grisbi_win_headings_update_title ( title );
1159
1160 g_free ( title );
1161 }
1162
1163
1164 /**
1165 * Remove account from the navigation pane.
1166 *
1167 * \param account_number Account ID to remove.
1168 */
gsb_gui_navigation_remove_account(gint account_number)1169 void gsb_gui_navigation_remove_account ( gint account_number )
1170 {
1171 gtk_tree_model_foreach ( GTK_TREE_MODEL(navigation_model),
1172 (GtkTreeModelForeachFunc) gsb_gui_navigation_remove_account_iterator,
1173 GINT_TO_POINTER ( account_number ) );
1174 }
1175
1176
1177
1178 /**
1179 * Callback executed when the selection of the navigation tree
1180 * changed.
1181 * we must write here the changes to do when changing something in that selection,
1182 * not with a callback "switch-page" on the main notebook
1183 *
1184 * \param selection The selection that triggered event.
1185 * \param model Tree model associated to selection.
1186 *
1187 * \return FALSE
1188 */
gsb_gui_navigation_select_line(GtkTreeSelection * selection,GtkTreeModel * model)1189 gboolean gsb_gui_navigation_select_line ( GtkTreeSelection *selection,
1190 GtkTreeModel *model )
1191 {
1192 GtkWidget *account_page;
1193 gint account_number, page_number;
1194 gint report_number;
1195 gchar *title = NULL;
1196 gboolean clear_suffix = TRUE;
1197 GrisbiAppConf *a_conf;
1198
1199 devel_debug (NULL);
1200 a_conf = (GrisbiAppConf *) grisbi_app_get_a_conf ();
1201 page_number = gsb_gui_navigation_get_current_page ();
1202
1203 gtk_notebook_set_current_page ( GTK_NOTEBOOK ( grisbi_win_get_notebook_general ( ) ), page_number );
1204
1205 if ( page_number != GSB_ACCOUNT_PAGE )
1206 {
1207 /* on update le menu de la liste des comptes */
1208 grisbi_win_menu_move_to_acc_update ( FALSE );
1209
1210 /* on dé-sensibilise le menu view account */
1211 gsb_menu_set_menus_view_account_sensitive ( FALSE );
1212 }
1213
1214 if ( page_number != GSB_SCHEDULER_PAGE )
1215 {
1216 gtk_widget_hide ( scheduler_calendar );
1217 }
1218
1219 switch ( page_number )
1220 {
1221 case GSB_HOME_PAGE:
1222 notice_debug ("Home page selected");
1223
1224 title = g_strdup(_("My accounts"));
1225
1226 /* what to be done if switch to that page */
1227 mise_a_jour_accueil ( FALSE );
1228 grisbi_win_set_form_expander_visible ( FALSE, FALSE );
1229 grisbi_win_form_expander_hide_frame ();
1230 break;
1231
1232 case GSB_ACCOUNT_PAGE:
1233 notice_debug ("Account page selected");
1234
1235 gsb_menu_gui_sensitive_win_menu_item ( "remove-acc", TRUE );
1236
1237 account_number = gsb_gui_navigation_get_current_account ();
1238
1239 /* update title now -- different from others */
1240 gsb_gui_navigation_update_account_label (account_number);
1241
1242 /* what to be done if switch to that page */
1243 if (account_number >= 0 )
1244 {
1245 gsb_gui_navigation_change_account ( account_number );
1246 gsb_account_property_fill_page ();
1247 clear_suffix = FALSE;
1248 if ( gsb_data_archive_store_account_have_transactions_visibles ( account_number ) )
1249 gsb_transactions_list_set_visible_archived_button ( TRUE );
1250 else
1251 gsb_transactions_list_set_visible_archived_button ( FALSE );
1252 }
1253 grisbi_win_menu_move_to_acc_update (FALSE);
1254 gsb_menu_update_view_menu ( account_number );
1255
1256 /* set the form */
1257 account_page = grisbi_win_get_account_page ();
1258 grisbi_win_on_account_switch_page (GTK_NOTEBOOK (account_page),
1259 NULL,
1260 gtk_notebook_get_current_page (GTK_NOTEBOOK (account_page)),
1261 NULL );
1262 if (a_conf->formulaire_toujours_affiche)
1263 gsb_form_show (TRUE);
1264 else
1265 gsb_form_show (FALSE);
1266
1267 buffer_last_account = account_number;
1268
1269 break;
1270
1271 case GSB_SCHEDULER_PAGE:
1272 notice_debug ("Scheduler page selected");
1273
1274 title = g_strdup(_("Scheduled transactions"));
1275
1276 /* what to be done if switch to that page */
1277 /* set the form */
1278 grisbi_win_set_form_expander_visible (TRUE, FALSE );
1279 gsb_form_scheduler_clean ();
1280 gsb_form_show ( FALSE );
1281
1282 /* show the calendar */
1283 gsb_calendar_update ();
1284 gtk_widget_show_all ( scheduler_calendar );
1285
1286 /* show menu NewTransaction */
1287 gsb_menu_gui_sensitive_win_menu_item ( "new-ope", TRUE );
1288
1289 /* show menu InitwidthCol */
1290 gsb_menu_gui_sensitive_win_menu_item ( "reset-width-col", TRUE );
1291
1292 /* set last_selected_scheduler option */
1293 gsb_scheduler_list_update_tree_view (gsb_scheduler_list_get_tree_view ());
1294
1295 break;
1296
1297 case GSB_PAYEES_PAGE:
1298 notice_debug ("Payee page selected");
1299
1300 /* what to be done if switch to that page */
1301 grisbi_win_set_form_expander_visible (FALSE, FALSE );
1302 payees_fill_list ();
1303 clear_suffix = FALSE;
1304 grisbi_win_form_expander_hide_frame ();
1305 break;
1306
1307 case GSB_SIMULATOR_PAGE:
1308 notice_debug ("Credits simulator page selected");
1309
1310 title = g_strdup(_("Credits simulator"));
1311
1312 /* what to be done if switch to that page */
1313 grisbi_win_set_form_expander_visible (FALSE, FALSE);
1314 bet_finance_ui_switch_simulator_page ( );
1315 grisbi_win_form_expander_hide_frame ();
1316 break;
1317
1318 case GSB_CATEGORIES_PAGE:
1319 notice_debug ("Category page selected");
1320
1321 /* what to be done if switch to that page */
1322 grisbi_win_set_form_expander_visible (FALSE, FALSE );
1323 categories_fill_list ();
1324 clear_suffix = FALSE;
1325 grisbi_win_form_expander_hide_frame ();
1326 break;
1327
1328 case GSB_BUDGETARY_LINES_PAGE:
1329 notice_debug ("Budgetary page selected");
1330
1331 /* what to be done if switch to that page */
1332 grisbi_win_set_form_expander_visible (FALSE, FALSE );
1333 budgetary_lines_fill_list ();
1334 clear_suffix = FALSE;
1335 grisbi_win_form_expander_hide_frame ();
1336 break;
1337
1338 case GSB_REPORTS_PAGE:
1339 notice_debug ("Reports page selected");
1340
1341 report_number = gsb_gui_navigation_get_current_report ();
1342
1343 if ( report_number >= 0 )
1344 title = g_strconcat ( _("Report"), " : ", gsb_data_report_get_report_name (report_number), NULL );
1345 else
1346 title = g_strdup(_("Reports"));
1347
1348 /* what to be done if switch to that page */
1349 grisbi_win_set_form_expander_visible ( FALSE, FALSE );
1350
1351 if ( report_number > 0 )
1352 {
1353 gtk_notebook_set_current_page (GTK_NOTEBOOK (etats_onglet_get_notebook_etats ()), 0);
1354 gsb_gui_navigation_select_report (selection, model);
1355 etats_onglet_update_gui_to_report ( report_number );
1356 }
1357 else
1358 {
1359 gtk_notebook_set_current_page (GTK_NOTEBOOK (etats_onglet_get_notebook_etats ()), 1);
1360 etats_onglet_unsensitive_reports_widgets ();
1361 }
1362 grisbi_win_form_expander_hide_frame ();
1363 break;
1364
1365 default:
1366 notice_debug ("B0rk page selected");
1367 title = g_strdup("B0rk");
1368 grisbi_win_form_expander_hide_frame ();
1369 break;
1370 }
1371
1372 /* title is set here if necessary */
1373 if (title)
1374 {
1375 grisbi_win_headings_update_title ( title );
1376 g_free ( title );
1377 }
1378 if (clear_suffix)
1379 grisbi_win_headings_update_suffix ( "" );
1380
1381 return FALSE;
1382 }
1383
1384
1385
1386 /**
1387 * Set the selection of the navigation list depending on desired
1388 * page and/or account or report.
1389 *
1390 * \param page Page to switch to.
1391 * \param account_number If page is GSB_ACCOUNT_PAGE, switch to given
1392 * account.
1393 * \param report If page is GSB_REPORTS, switch to given
1394 * report.
1395 *
1396 * \return TRUE on success.
1397 */
gsb_gui_navigation_set_selection(gint page,gint account_number,gint report_number)1398 gboolean gsb_gui_navigation_set_selection ( gint page,
1399 gint account_number,
1400 gint report_number )
1401 {
1402 GtkTreeIter iter;
1403 GtkTreeSelection *selection;
1404
1405 selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW ( navigation_tree_view ) );
1406 g_return_val_if_fail ( selection, FALSE );
1407
1408 /* if we select an account, open the expander if necessary */
1409 if (page == GSB_ACCOUNT_PAGE || page == GSB_REPORTS_PAGE)
1410 {
1411 GtkTreePath *path;
1412
1413 if (page == GSB_ACCOUNT_PAGE)
1414 path = gsb_gui_navigation_get_page_path (navigation_model, GSB_HOME_PAGE);
1415 else
1416 path = gsb_gui_navigation_get_page_path (navigation_model,GSB_REPORTS_PAGE);
1417
1418 gtk_tree_view_expand_row ( GTK_TREE_VIEW ( navigation_tree_view ), path, TRUE );
1419 gtk_tree_path_free (path);
1420 }
1421
1422 if (gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(navigation_model), &iter ))
1423 gsb_gui_navigation_set_selection_branch (selection, &iter, page, account_number, report_number);
1424
1425 return TRUE;
1426 }
1427
1428
1429 /**
1430 * Set the selection of the navigation list depending on desired page
1431 * and/or account or report, but only for a branch of the tree.
1432 *
1433 * \param selection Selection to set.
1434 * \param iter Current iter to iterate over.
1435 * \param page Page to switch to.
1436 * \param account_number If page is GSB_ACCOUNT_PAGE, switch to given
1437 * account.
1438 * \param report If page is GSB_REPORTS, switch to given
1439 * report.
1440 *
1441 * \return TRUE on success.
1442 */
gsb_gui_navigation_set_selection_branch(GtkTreeSelection * selection,GtkTreeIter * iter,gint page,gint account_number,gint report_number)1443 void gsb_gui_navigation_set_selection_branch ( GtkTreeSelection *selection,
1444 GtkTreeIter *iter,
1445 gint page,
1446 gint account_number,
1447 gint report_number)
1448 {
1449 do
1450 {
1451 gint iter_page, iter_account_nb;
1452 gint iter_report;
1453
1454 gtk_tree_model_get ( GTK_TREE_MODEL(navigation_model), iter,
1455 NAVIGATION_REPORT, &iter_report,
1456 NAVIGATION_ACCOUNT, &iter_account_nb,
1457 NAVIGATION_PAGE, &iter_page,
1458 -1 );
1459
1460 if ( iter_page == page &&
1461 ! ( page == GSB_ACCOUNT_PAGE &&
1462 iter_account_nb != account_number ) &&
1463 ! ( page == GSB_REPORTS_PAGE &&
1464 iter_report != report_number ) )
1465 {
1466 gtk_tree_selection_select_iter ( selection, iter );
1467 }
1468
1469 if ( gtk_tree_model_iter_has_child ( GTK_TREE_MODEL(navigation_model), iter ) )
1470 {
1471 GtkTreeIter child;
1472
1473 gtk_tree_model_iter_children ( GTK_TREE_MODEL(navigation_model), &child, iter );
1474 gsb_gui_navigation_set_selection_branch ( selection, &child,
1475 page, account_number, report_number);
1476 }
1477 }
1478 while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL(navigation_model), iter ) );
1479
1480
1481 return;
1482 }
1483
1484
1485
1486 /**
1487 *
1488 *
1489 *
1490 */
gsb_gui_navigation_select_prev(void)1491 gboolean gsb_gui_navigation_select_prev ( void )
1492 {
1493 GtkTreeSelection * selection;
1494 GtkTreePath * path;
1495 GtkTreeModel * model;
1496 GtkTreeIter iter;
1497
1498 selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(navigation_tree_view) );
1499 g_return_val_if_fail ( selection, FALSE );
1500
1501 if ( !gtk_tree_selection_get_selected ( selection, &model, &iter ) )
1502 return TRUE;
1503 path = gtk_tree_model_get_path ( model, &iter );
1504 g_return_val_if_fail ( path, TRUE );
1505
1506 if ( !gtk_tree_path_prev ( path ) )
1507 {
1508 if ( gtk_tree_path_get_depth ( path ) > 1 )
1509 gtk_tree_path_up ( path );
1510 }
1511 else
1512 {
1513 gtk_tree_model_get_iter ( model, &iter, path );
1514 /* if row has children and if row is expanded, go to the last child */
1515 if ( gtk_tree_model_iter_has_child ( model, &iter )
1516 && gtk_tree_view_row_expanded ( GTK_TREE_VIEW ( navigation_tree_view ), path ) )
1517 {
1518 GtkTreeIter parent = iter;
1519 gtk_tree_model_iter_nth_child ( model, &iter, &parent,
1520 gtk_tree_model_iter_n_children ( model,
1521 &parent ) - 1 );
1522 path = gtk_tree_model_get_path ( model, &iter );
1523 }
1524 }
1525
1526 gtk_tree_selection_select_path ( selection, path );
1527 gtk_tree_path_free ( path );
1528
1529 return FALSE;
1530 }
1531
1532
1533
1534 /**
1535 *
1536 *
1537 *
1538 */
gsb_gui_navigation_select_next(void)1539 gboolean gsb_gui_navigation_select_next ( void )
1540 {
1541 GtkTreeSelection *selection;
1542 GtkTreePath *path;
1543 GtkTreeModel *model;
1544 GtkTreeIter iter;
1545
1546 selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(navigation_tree_view) );
1547 g_return_val_if_fail ( selection, FALSE );
1548
1549 if ( !gtk_tree_selection_get_selected ( selection, &model, &iter ) )
1550 return TRUE;
1551
1552 path = gtk_tree_model_get_path ( model, &iter );
1553 g_return_val_if_fail ( path, TRUE );
1554
1555 if ( gtk_tree_model_iter_has_child ( model, &iter ) )
1556 {
1557 if ( gtk_tree_view_row_expanded ( GTK_TREE_VIEW ( navigation_tree_view ), path ) )
1558 gtk_tree_path_down ( path );
1559 else
1560 gtk_tree_path_next ( path );
1561 }
1562 else
1563 {
1564 if ( !gtk_tree_model_iter_next ( model, &iter ) )
1565 {
1566 if ( gtk_tree_path_get_depth ( path ) > 1 )
1567 {
1568 gtk_tree_path_up ( path );
1569 gtk_tree_path_next ( path );
1570 }
1571 else
1572 {
1573 gtk_tree_path_free ( path );
1574 path = gtk_tree_path_new_first ( );
1575 }
1576 }
1577 else
1578 {
1579 path = gtk_tree_model_get_path ( model, &iter );
1580 }
1581 }
1582
1583 gtk_tree_selection_select_path ( selection, path );
1584 gtk_tree_path_free ( path );
1585
1586 return FALSE;
1587 }
1588
1589
1590
1591 /**
1592 * Check the key pressed on the navigation tree view,
1593 * if need, stop the event to do another thing with that key
1594 *
1595 * \param tree_view the navigation tree_view
1596 * \param ev the key event pressed
1597 * \param model
1598 *
1599 * \return FALSE : the signal continue / TRUE : the signal is stopped here
1600 * */
gsb_gui_navigation_check_key_press(GtkWidget * tree_view,GdkEventKey * ev,GtkTreeModel * model)1601 gboolean gsb_gui_navigation_check_key_press ( GtkWidget *tree_view,
1602 GdkEventKey *ev,
1603 GtkTreeModel *model )
1604 {
1605 gint page;
1606 GtkTreeIter iter;
1607 GtkTreePath *path;
1608
1609 if (! gtk_tree_selection_get_selected ( gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
1610 NULL,
1611 &iter))
1612 return FALSE;
1613
1614 gtk_tree_model_get (model, &iter, NAVIGATION_PAGE, &page, -1 );
1615 path = gtk_tree_model_get_path ( GTK_TREE_MODEL ( model ), &iter );
1616
1617 switch ( page )
1618 {
1619 case GSB_HOME_PAGE:
1620 case GSB_REPORTS_PAGE:
1621 /* expand or collapse subtree */
1622 if (ev -> keyval == GDK_KEY_Right)
1623 gtk_tree_view_expand_row ( GTK_TREE_VIEW ( tree_view ), path, FALSE );
1624 if (ev -> keyval == GDK_KEY_Left)
1625 gtk_tree_view_collapse_row ( GTK_TREE_VIEW ( tree_view ), path );
1626 break;
1627
1628 case GSB_ACCOUNT_PAGE:
1629 /* when come here, if we press the right key, give the focus to the list */
1630 if (ev -> keyval == GDK_KEY_Right)
1631 gtk_widget_grab_focus (gsb_transactions_list_get_tree_view ());
1632 break;
1633
1634 case GSB_PAYEES_PAGE:
1635 /* nothing to do here for now */
1636 break;
1637
1638 case GSB_CATEGORIES_PAGE:
1639 /* nothing to do here for now */
1640 break;
1641
1642 case GSB_BUDGETARY_LINES_PAGE:
1643 /* nothing to do here for now */
1644 break;
1645
1646 case GSB_SCHEDULER_PAGE:
1647 /* when come here, if we press the right key, give the focus to the list */
1648 if (ev -> keyval == GDK_KEY_Right)
1649 gtk_widget_grab_focus (gsb_scheduler_list_get_tree_view ());
1650 break;
1651 }
1652
1653 gtk_tree_path_free ( path );
1654
1655 return FALSE;
1656 }
1657
1658
1659
1660 /**
1661 * Check mouse scrolling on the navigation tree view.
1662 *
1663 * \param tree_view the navigation tree_view
1664 * \param ev the scroll event
1665 *
1666 * \return FALSE : the signal continue / TRUE : the signal is stopped here
1667 * */
gsb_gui_navigation_check_scroll(GtkWidget * tree_view,GdkEvent * ev,gpointer user_data)1668 gboolean gsb_gui_navigation_check_scroll (GtkWidget *tree_view,
1669 GdkEvent *ev,
1670 gpointer user_data)
1671 {
1672 gdouble delta_x;
1673 gdouble delta_y;
1674 GdkScrollDirection direction;
1675 gboolean etat1 = 0;
1676 gboolean etat2 = 0;
1677
1678 g_signal_handlers_block_by_func (G_OBJECT (tree_view),
1679 G_CALLBACK (gsb_gui_navigation_check_scroll),
1680 NULL);
1681 etat1 = gdk_event_get_scroll_deltas (ev, &delta_x, &delta_y);
1682 etat2 = gdk_event_get_scroll_direction (ev, &direction);
1683
1684 if (etat1 && (gint) delta_y == 1)
1685 gsb_gui_navigation_select_next ();
1686 else if (etat1 && (gint) delta_y == -1)
1687 gsb_gui_navigation_select_prev ();
1688 else if (etat2 && direction == GDK_SCROLL_UP)
1689 gsb_gui_navigation_select_prev ();
1690 else if (etat2 && direction == GDK_SCROLL_DOWN)
1691 gsb_gui_navigation_select_next ();
1692
1693 g_signal_handlers_unblock_by_func (G_OBJECT (tree_view),
1694 G_CALLBACK (gsb_gui_navigation_check_scroll),
1695 NULL);
1696 return FALSE;
1697 }
1698
1699
1700
1701 /**
1702 * Fill the drag & drop structure with the path of selected column.
1703 * This is an interface function called from GTK, much like a callback.
1704 *
1705 * \param drag_source Not used.
1706 * \param path Original path for the gtk selection.
1707 * \param selection_data A pointer to the drag & drop structure.
1708 *
1709 * \return FALSE, to allow future processing by the callback chain.
1710 */
navigation_tree_drag_data_get(GtkTreeDragSource * drag_source,GtkTreePath * path,GtkSelectionData * selection_data)1711 gboolean navigation_tree_drag_data_get ( GtkTreeDragSource *drag_source,
1712 GtkTreePath *path,
1713 GtkSelectionData *selection_data )
1714 {
1715 gchar *tmpstr = gtk_tree_path_to_string (path);
1716 gchar *tmpstr2 = g_strdup_printf ( "Orig path : %s", tmpstr);
1717 devel_debug (tmpstr2);
1718 g_free (tmpstr);
1719 g_free (tmpstr2);
1720
1721 if ( path )
1722 {
1723 gtk_tree_set_row_drag_data ( selection_data, GTK_TREE_MODEL(navigation_model),
1724 path );
1725 }
1726
1727 return FALSE;
1728 }
1729
1730
1731
1732 /**
1733 *
1734 *
1735 */
gsb_gui_navigation_drag_data_received(GtkTreeDragDest * drag_dest,GtkTreePath * dest_path,GtkSelectionData * selection_data)1736 gboolean gsb_gui_navigation_drag_data_received ( GtkTreeDragDest *drag_dest,
1737 GtkTreePath *dest_path,
1738 GtkSelectionData *selection_data )
1739 {
1740 gchar *tmpstr = gtk_tree_path_to_string (dest_path);
1741 gchar *tmpstr2 = g_strdup_printf ( "Dest path : %s", tmpstr);
1742 devel_debug (tmpstr2);
1743 g_free (tmpstr);
1744 g_free (tmpstr2);
1745
1746 if ( dest_path && selection_data )
1747 {
1748 GtkTreeModel *model;
1749 GtkTreeIter iter;
1750 GtkTreePath *orig_path;
1751 gint src_report = -1, dst_report = -1;
1752 gint src_account = -1, dst_account = -1;
1753 gint src_ordre = -1, dst_ordre = -1;
1754
1755 gtk_tree_get_row_drag_data (selection_data, &model, &orig_path);
1756
1757 if ( gtk_tree_model_get_iter ( GTK_TREE_MODEL(model), &iter, dest_path ) )
1758 gtk_tree_model_get (model , &iter,
1759 NAVIGATION_REPORT, &dst_report,
1760 NAVIGATION_ACCOUNT, &dst_account,
1761 NAVIGATION_ORDRE, &dst_ordre,
1762 -1 );
1763
1764 if ( gtk_tree_model_get_iter ( GTK_TREE_MODEL(model), &iter, orig_path ) )
1765 gtk_tree_model_get ( model, &iter,
1766 NAVIGATION_REPORT, &src_report,
1767 NAVIGATION_ACCOUNT, &src_account,
1768 NAVIGATION_ORDRE, &src_ordre,
1769 -1 );
1770
1771 /* at this stage, src_account or src_report contains the account/report we move
1772 * and dst_account/dst_report the account/report destination we want to move before,
1773 * or dst_account/dst_report can be -1 to set at the end of the list */
1774 if ( src_account != -1 )
1775 /* we moved an account */
1776 gsb_data_account_move_account ( src_account, dst_account );
1777 if ( src_report != -1 )
1778 /* we moved a report */
1779 gsb_data_report_move_report ( src_report, dst_report );
1780 if ( src_ordre != -1 )
1781 /* we moved a page */
1782 gsb_gui_navigation_move_ordre ( src_ordre, dst_ordre );
1783
1784 /* update the tree view */
1785 gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE ( model ),
1786 NAVIGATION_ORDRE, GTK_SORT_ASCENDING );
1787 gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE ( model ),
1788 NAVIGATION_ORDRE, navigation_sort_column,
1789 NULL, NULL );
1790
1791 /* update the order of accounts in first page */
1792 run.mise_a_jour_liste_comptes_accueil = TRUE;
1793
1794 gsb_file_set_modified ( TRUE );
1795 }
1796 return FALSE;
1797 }
1798
1799
1800
1801 /**
1802 *
1803 *
1804 */
gsb_gui_navigation_row_drop_possible(GtkTreeDragDest * drag_dest,GtkTreePath * dest_path,GtkSelectionData * selection_data)1805 gboolean gsb_gui_navigation_row_drop_possible ( GtkTreeDragDest *drag_dest,
1806 GtkTreePath *dest_path,
1807 GtkSelectionData *selection_data )
1808 {
1809 if ( dest_path && selection_data )
1810 {
1811 GtkTreePath *orig_path;
1812 GtkTreeModel *model;
1813 gint src_report = -1, dst_report = -1;
1814 gint src_account = -1, dst_account = -1;
1815 gint src_ordre = -1, dst_ordre = -1;
1816 GtkTreeIter iter;
1817
1818 gtk_tree_get_row_drag_data ( selection_data, &model, &orig_path );
1819
1820 if ( gtk_tree_model_get_iter ( model, &iter, orig_path ) )
1821 gtk_tree_model_get ( model, &iter,
1822 NAVIGATION_REPORT, &src_report,
1823 NAVIGATION_ACCOUNT, &src_account,
1824 NAVIGATION_ORDRE, &src_ordre,
1825 -1 );
1826
1827 if ( gtk_tree_model_get_iter ( model, &iter, dest_path ) )
1828 gtk_tree_model_get ( model, &iter,
1829 NAVIGATION_REPORT, &dst_report,
1830 NAVIGATION_ACCOUNT, &dst_account,
1831 NAVIGATION_ORDRE, &dst_ordre,
1832 -1 );
1833
1834 /* We handle an account */
1835 if ( src_account >= 0 && dst_account >= 0 )
1836 {
1837 return TRUE;
1838 }
1839 /* We handle a report */
1840 else if ( src_report > 0 && dst_report > 0 )
1841 {
1842 return TRUE;
1843 }
1844 else if ( src_ordre >= 0 && dst_ordre >= 0 )
1845 {
1846 return TRUE;
1847 }
1848
1849 }
1850
1851 return FALSE;
1852 }
1853
1854
1855 /**
1856 * Met à jour la page d'accueil immédiatement si elle est affichée sinon plus tard
1857 *
1858 */
gsb_gui_navigation_update_home_page(void)1859 void gsb_gui_navigation_update_home_page ( void )
1860 {
1861 if ( gsb_gui_navigation_get_current_page ( ) == GSB_HOME_PAGE )
1862 mise_a_jour_accueil ( TRUE );
1863 else
1864 run.mise_a_jour_liste_comptes_accueil = TRUE;
1865 }
1866
1867
1868 /**
1869 *
1870 *
1871 *
1872 */
gsb_gui_navigation_get_tree_view(void)1873 GtkWidget *gsb_gui_navigation_get_tree_view ( void )
1874 {
1875 return navigation_tree_view;
1876 }
1877
1878
1879 /**
1880 * change the position of an item in the list of pages
1881 *
1882 * \param src_ordre the position of item we want to move
1883 * \param dest_ordre the position before we want to move, or -1 to set at the end of list
1884 *
1885 * \return FALSE
1886 * */
gsb_gui_navigation_move_ordre(gint src_ordre,gint dst_ordre)1887 gboolean gsb_gui_navigation_move_ordre ( gint src_ordre,
1888 gint dst_ordre )
1889 {
1890 GQueue *tmp_queue;
1891 GList *dst_list;
1892 gint i;
1893 GsbGuiNavigationPage *page = NULL;
1894
1895 tmp_queue = pages_list;
1896 for ( i = 0 ; i < (gint) tmp_queue->length ; i++ )
1897 {
1898 page = g_queue_peek_nth ( tmp_queue, i );
1899 if ( page -> ordre == src_ordre )
1900 break;
1901 }
1902
1903 g_queue_pop_nth ( pages_list, i );
1904
1905 dst_list = g_queue_peek_nth_link ( pages_list, dst_ordre );
1906 if ( dst_list )
1907 g_queue_insert_before ( pages_list, dst_list, page );
1908 else
1909 g_queue_push_tail ( tmp_queue, page );
1910
1911 /* on reconstruit le modèle */
1912 if (!navigation_model || !GTK_IS_TREE_STORE (navigation_model))
1913 return FALSE;
1914 else
1915 gtk_tree_store_clear (GTK_TREE_STORE (navigation_model));
1916
1917 tmp_queue = pages_list;
1918
1919 for ( i = 0 ; i < (gint) tmp_queue->length ; i++ )
1920 {
1921 page = g_queue_peek_nth ( tmp_queue, i );
1922 page -> ordre = i;
1923 gsb_gui_navigation_set_navigation_pages ( navigation_model, page -> type_page, i );
1924 }
1925
1926 return FALSE;
1927 }
1928
1929
1930 /**
1931 *
1932 *
1933 *
1934 */
gsb_gui_navigation_init_tree_view(void)1935 void gsb_gui_navigation_init_tree_view ( void )
1936 {
1937 navigation_tree_view = NULL;
1938 }
1939
1940
1941 /**
1942 *
1943 *
1944 *
1945 */
gsb_gui_navigation_get_model(void)1946 GtkTreeModel *gsb_gui_navigation_get_model ( void )
1947 {
1948 if ( navigation_model )
1949 return navigation_model;
1950 else
1951 return NULL;
1952 }
1953
1954
1955 /**
1956 *
1957 *
1958 *
1959 */
gsb_gui_navigation_set_page_list_order(const gchar * order_list)1960 gboolean gsb_gui_navigation_set_page_list_order ( const gchar *order_list )
1961 {
1962 gchar **pointeur_char;
1963 gint i;
1964 gint nbre_pages;
1965
1966 if ( pages_list )
1967 gsb_gui_navigation_clear_pages_list ( );
1968
1969 pointeur_char = g_strsplit ( order_list, "-", 0 );
1970
1971 nbre_pages = g_strv_length ( pointeur_char );
1972
1973 if ( nbre_pages != navigation_nbre_pages )
1974 {
1975 g_strfreev ( pointeur_char );
1976 pointeur_char = g_strsplit ( default_navigation_order_list, "-", 0 );
1977 nbre_pages = navigation_nbre_pages;
1978 }
1979
1980 for ( i = 0 ; i < nbre_pages ; i++ )
1981 {
1982 GsbGuiNavigationPage *page;
1983
1984 page = g_malloc0 ( sizeof ( GsbGuiNavigationPage ) );
1985 page -> ordre = i;
1986 page -> type_page = utils_str_atoi ( pointeur_char[i] );
1987
1988 g_queue_push_tail ( pages_list, page );
1989 }
1990
1991 g_strfreev ( pointeur_char );
1992
1993 return TRUE;
1994 }
1995
1996
1997 /**
1998 *
1999 *
2000 *
2001 */
gsb_gui_navigation_init_pages_list(void)2002 void gsb_gui_navigation_init_pages_list ( void )
2003 {
2004 GQueue *new_queue;
2005
2006 gsb_gui_navigation_free_pages_list ( );
2007
2008 new_queue = g_queue_new ( );
2009 pages_list = new_queue;
2010 gsb_gui_navigation_set_page_list_order ( default_navigation_order_list );
2011 }
2012
2013
2014 /*
2015 * use an extra parameter to be of type GFunc ()
2016 */
my_g_free_null(gpointer data,gpointer user_data)2017 static void my_g_free_null (gpointer data, gpointer user_data)
2018 {
2019 g_free(data);
2020 }
2021
2022 /**
2023 *
2024 *
2025 *
2026 */
gsb_gui_navigation_clear_pages_list(void)2027 void gsb_gui_navigation_clear_pages_list ( void )
2028 {
2029 g_queue_foreach ( pages_list, my_g_free_null, NULL );
2030 g_queue_clear ( pages_list );
2031 }
2032
2033
2034 /**
2035 *
2036 *
2037 *
2038 */
gsb_gui_navigation_free_pages_list(void)2039 void gsb_gui_navigation_free_pages_list ( void )
2040 {
2041 if ( ! pages_list )
2042 return;
2043
2044 g_queue_free_full ( pages_list, g_free );
2045 pages_list = NULL;
2046 }
2047
2048
2049 /**
2050 * return a pointer on the first element of g_queue of navigation pages
2051 *
2052 * \param none
2053 * \return a GList
2054 * */
gsb_gui_navigation_get_pages_list(void)2055 GQueue *gsb_gui_navigation_get_pages_list ( void )
2056 {
2057 return pages_list;
2058 }
2059
2060
2061 /**
2062 *
2063 *
2064 *
2065 */
gsb_gui_navigation_set_navigation_pages(GtkTreeModel * model,gint type_page,gint ordre)2066 void gsb_gui_navigation_set_navigation_pages ( GtkTreeModel *model,
2067 gint type_page,
2068 gint ordre )
2069 {
2070 GdkPixbuf *pixbuf;
2071 GtkTreeIter iter;
2072 gchar *str_color = (gchar*)"black";
2073 gchar *title = NULL;
2074 gchar *tmp_str = NULL;
2075
2076 switch ( type_page )
2077 {
2078 case GSB_HOME_PAGE :
2079 tmp_str = g_build_filename ( gsb_dirs_get_pixmaps_dir ( ), "gsb-ac-home-32.png", NULL );
2080 title = g_strdup ( _("Accounts") );
2081 break;
2082 case GSB_SCHEDULER_PAGE :
2083 tmp_str = g_build_filename( gsb_dirs_get_pixmaps_dir ( ), "gsb-scheduler-32.png", NULL );
2084 title = g_strdup ( _("Scheduler") );
2085 break;
2086 case GSB_PAYEES_PAGE :
2087 tmp_str = g_build_filename( gsb_dirs_get_pixmaps_dir ( ), "gsb-payees-32.png", NULL );
2088 title = g_strdup ( _("Payees") );
2089 break;
2090 case GSB_SIMULATOR_PAGE :
2091 tmp_str = g_build_filename( gsb_dirs_get_pixmaps_dir ( ), "gsb-ac-liability-32.png", NULL );
2092 title = g_strdup ( _("Credits simulator") );
2093 break;
2094 case GSB_CATEGORIES_PAGE :
2095 tmp_str = g_build_filename( gsb_dirs_get_pixmaps_dir ( ), "gsb-categories-32.png", NULL );
2096 title = g_strdup ( _("Categories") );
2097 break;
2098 case GSB_BUDGETARY_LINES_PAGE :
2099 tmp_str = g_build_filename( gsb_dirs_get_pixmaps_dir ( ), "gsb-budgetary_lines-32.png", NULL );
2100 title = g_strdup ( _("Budgetary lines") );
2101 break;
2102 case GSB_REPORTS_PAGE :
2103 tmp_str = g_build_filename( gsb_dirs_get_pixmaps_dir ( ), "gsb-reports-32.png", NULL );
2104 title = g_strdup ( _("Reports") );
2105 break;
2106 }
2107
2108 str_color = gsb_rgba_get_couleur_with_indice_to_str ("color_text", 0);
2109
2110 pixbuf = gdk_pixbuf_new_from_file ( tmp_str , NULL );
2111 gtk_tree_store_append ( GTK_TREE_STORE ( model ), &iter, NULL );
2112 gtk_tree_store_set( GTK_TREE_STORE ( navigation_model ), &iter,
2113 NAVIGATION_PIX, pixbuf,
2114 NAVIGATION_TEXT, title,
2115 NAVIGATION_PIX_VISIBLE, TRUE,
2116 NAVIGATION_FONT, 800,
2117 NAVIGATION_PAGE, type_page,
2118 NAVIGATION_ACCOUNT, -1,
2119 NAVIGATION_REPORT, -1,
2120 NAVIGATION_COLOR_TEXT, str_color,
2121 NAVIGATION_ORDRE, ordre,
2122 -1);
2123
2124 g_object_unref ( G_OBJECT ( pixbuf ) );
2125 g_free ( tmp_str );
2126 g_free ( title );
2127
2128 switch ( type_page )
2129 {
2130 case GSB_HOME_PAGE :
2131 gsb_gui_navigation_create_account_list ( GTK_TREE_MODEL( model ) );
2132 break;
2133 case GSB_REPORTS_PAGE :
2134 gsb_gui_navigation_create_report_list ( GTK_TREE_MODEL( model) );
2135 break;
2136 }
2137
2138 }
2139
2140
2141 /**
2142 * renvoie le path d'un item de la vue navigation
2143 *
2144 *
2145 */
gsb_gui_navigation_get_page_path(GtkTreeModel * model,gint type_page)2146 GtkTreePath *gsb_gui_navigation_get_page_path ( GtkTreeModel *model, gint type_page )
2147 {
2148 GtkTreeIter iter;
2149
2150 if ( gtk_tree_model_get_iter_first ( GTK_TREE_MODEL ( model ), &iter ) )
2151 {
2152 do
2153 {
2154 gint tmp_type_page;
2155 GtkTreePath *path = NULL;
2156
2157 gtk_tree_model_get ( GTK_TREE_MODEL( model ), &iter, NAVIGATION_PAGE, &tmp_type_page, -1 );
2158 if ( tmp_type_page == type_page)
2159 {
2160 path = gtk_tree_model_get_path ( GTK_TREE_MODEL ( model ), &iter );
2161 return path;
2162 }
2163 }
2164 while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL ( model ), &iter ) );
2165 }
2166
2167 return NULL;
2168 }
2169
2170
2171 /**
2172 * called when we press a button on the list
2173 *
2174 * \param tree_view
2175 * \param ev
2176 *
2177 * \return FALSE
2178 * */
gsb_gui_navigation_button_press(GtkWidget * tree_view,GdkEventButton * ev,gpointer null)2179 gboolean gsb_gui_navigation_button_press ( GtkWidget *tree_view,
2180 GdkEventButton *ev,
2181 gpointer null )
2182 {
2183 /* show the popup */
2184 if ( ev -> button == RIGHT_BUTTON )
2185 {
2186 GtkTreePath *path = NULL;
2187
2188 if ( gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW ( tree_view ), ev -> x, ev -> y, &path, NULL, NULL, NULL ) )
2189 {
2190 gsb_gui_navigation_context_menu ( tree_view, path );
2191 gtk_tree_path_free ( path );
2192
2193 update_gui ( );
2194
2195 return FALSE;
2196 }
2197 }
2198 if ( ev -> type == GDK_2BUTTON_PRESS )
2199 {
2200 GtkTreePath *path = NULL;
2201
2202 if ( gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW ( tree_view ), ev -> x, ev -> y, &path, NULL, NULL, NULL ) )
2203 {
2204 if ( gtk_tree_view_row_expanded ( GTK_TREE_VIEW ( tree_view ), path ) )
2205 gtk_tree_view_collapse_row ( GTK_TREE_VIEW ( tree_view ), path );
2206 else
2207 gtk_tree_view_expand_row ( GTK_TREE_VIEW ( tree_view ), path, FALSE );
2208
2209 gtk_tree_path_free ( path );
2210
2211 return FALSE;
2212 }
2213 }
2214
2215 return FALSE;
2216 }
2217
2218
2219 /**
2220 * Pop up a menu with several actions to apply to array_list.
2221 *
2222 * \param gtk_tree_view
2223 *
2224 */
gsb_gui_navigation_context_menu(GtkWidget * tree_view,GtkTreePath * path)2225 void gsb_gui_navigation_context_menu ( GtkWidget *tree_view,
2226 GtkTreePath *path )
2227 {
2228 GtkWidget *menu = NULL;
2229 GtkWidget *menu_item;
2230 GtkTreeModel *model;
2231 GtkTreeIter iter;
2232 gint type_page;
2233 gint account_number;
2234 gint report_number;
2235
2236 model = gtk_tree_view_get_model ( GTK_TREE_VIEW ( tree_view ) );
2237
2238 gtk_tree_model_get_iter ( model, &iter, path );
2239 gtk_tree_model_get ( model, &iter,
2240 NAVIGATION_PAGE, &type_page,
2241 NAVIGATION_ACCOUNT, &account_number,
2242 NAVIGATION_REPORT, &report_number,
2243 -1 );
2244
2245 switch ( type_page )
2246 {
2247 case GSB_HOME_PAGE :
2248 case GSB_ACCOUNT_PAGE :
2249 menu = gtk_menu_new ();
2250 menu_item = utils_menu_item_new_from_image_label ("gsb-new-file-16.png", _("New account"));
2251 g_signal_connect ( G_OBJECT ( menu_item ),
2252 "activate",
2253 G_CALLBACK ( gsb_assistant_account_run ),
2254 NULL );
2255 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2256 if ( account_number == -1 )
2257 break;
2258
2259 /* Separator */
2260 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), gtk_separator_menu_item_new() );
2261
2262 menu_item = utils_menu_item_new_from_image_label ("gtk-delete-16.png", _("Remove this account"));
2263 g_signal_connect ( G_OBJECT ( menu_item ),
2264 "activate",
2265 G_CALLBACK ( gsb_account_delete ),
2266 NULL );
2267 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2268
2269 break;
2270 case GSB_PAYEES_PAGE :
2271 menu = gtk_menu_new ();
2272 menu_item = utils_menu_item_new_from_image_label ("gsb-new-payee-16.png",_("New payee"));
2273 g_signal_connect ( G_OBJECT ( menu_item ),
2274 "activate",
2275 G_CALLBACK ( payees_new_payee ),
2276 NULL );
2277 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2278
2279 menu_item = utils_menu_item_new_from_image_label ("gtk-delete-16.png", _("Delete selected payee"));
2280 g_signal_connect ( G_OBJECT ( menu_item ),
2281 "activate",
2282 G_CALLBACK ( payees_delete_payee ),
2283 NULL );
2284 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2285
2286 if ( gtk_tree_selection_count_selected_rows ( gtk_tree_view_get_selection (
2287 GTK_TREE_VIEW ( payees_get_tree_view ( ) ) ) ) )
2288 gtk_widget_set_sensitive ( menu_item, TRUE );
2289 else
2290 gtk_widget_set_sensitive ( menu_item, FALSE );
2291
2292 menu_item = utils_menu_item_new_from_image_label ("gtk-edit-16.png", _("Edit selected payee"));
2293 g_signal_connect ( G_OBJECT ( menu_item ),
2294 "activate",
2295 G_CALLBACK ( payees_edit_payee ),
2296 NULL );
2297 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2298
2299 if ( gtk_tree_selection_count_selected_rows ( gtk_tree_view_get_selection (
2300 GTK_TREE_VIEW ( payees_get_tree_view ( ) ) ) ) )
2301 gtk_widget_set_sensitive ( menu_item, TRUE );
2302 else
2303 gtk_widget_set_sensitive ( menu_item, FALSE );
2304
2305 /* Separator */
2306 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), gtk_separator_menu_item_new() );
2307
2308 menu_item = utils_menu_item_new_from_image_label ("gsb-payees-manage-16.png", _("Manage payees"));
2309 g_signal_connect ( G_OBJECT ( menu_item ),
2310 "activate",
2311 G_CALLBACK ( payees_manage_payees ),
2312 NULL );
2313 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2314
2315 menu_item = utils_menu_item_new_from_image_label ("gtk-delete-16.png", _("Remove unused payees"));
2316 g_signal_connect ( G_OBJECT ( menu_item ),
2317 "activate",
2318 G_CALLBACK ( payees_remove_unused_payees ),
2319 NULL );
2320 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2321 break;
2322 case GSB_CATEGORIES_PAGE :
2323 menu = gtk_menu_new ();
2324 menu_item = utils_menu_item_new_from_image_label ("gsb-new-categ-16.png", _("New category"));
2325 g_signal_connect ( G_OBJECT ( menu_item ),
2326 "activate",
2327 G_CALLBACK ( categories_new_category ),
2328 NULL );
2329 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2330
2331 menu_item = utils_menu_item_new_from_image_label ("gtk-delete-16.png", _("Delete selected category") );
2332 g_signal_connect ( G_OBJECT ( menu_item ),
2333 "activate",
2334 G_CALLBACK ( categories_delete_category ),
2335 NULL );
2336 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2337
2338 if ( gtk_tree_selection_count_selected_rows ( gtk_tree_view_get_selection (
2339 GTK_TREE_VIEW ( categories_get_tree_view ( ) ) ) ) )
2340 gtk_widget_set_sensitive ( menu_item, TRUE );
2341 else
2342 gtk_widget_set_sensitive ( menu_item, FALSE );
2343
2344 menu_item = utils_menu_item_new_from_image_label ("gtk-edit-16.png", _("Edit selected category"));
2345 g_signal_connect ( G_OBJECT ( menu_item ),
2346 "activate",
2347 G_CALLBACK ( categories_edit_category ),
2348 NULL );
2349 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2350
2351 if ( gtk_tree_selection_count_selected_rows ( gtk_tree_view_get_selection (
2352 GTK_TREE_VIEW ( categories_get_tree_view ( ) ) ) ) )
2353 gtk_widget_set_sensitive ( menu_item, TRUE );
2354 else
2355 gtk_widget_set_sensitive ( menu_item, FALSE );
2356
2357 /* Separator */
2358 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), gtk_separator_menu_item_new() );
2359
2360 menu_item = utils_menu_item_new_from_image_label ("gsb-import-16.png", _("Import a file of categories (.cgsb)"));
2361 g_signal_connect ( G_OBJECT ( menu_item ),
2362 "activate",
2363 G_CALLBACK ( categories_importer_list ),
2364 NULL );
2365 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2366
2367 menu_item = utils_menu_item_new_from_image_label ("gsb-export-16.png", _("Export the list of categories (.cgsb)"));
2368 g_signal_connect ( G_OBJECT ( menu_item ),
2369 "activate",
2370 G_CALLBACK ( categories_exporter_list ),
2371 NULL );
2372 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2373 break;
2374 case GSB_BUDGETARY_LINES_PAGE :
2375 menu = gtk_menu_new ();
2376 menu_item = utils_menu_item_new_from_image_label ("gsb-new-ib-16.png", _("New budgetary line"));
2377 g_signal_connect ( G_OBJECT ( menu_item ),
2378 "activate",
2379 G_CALLBACK ( budgetary_lines_new_budgetary_line ),
2380 NULL );
2381 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2382
2383 menu_item = utils_menu_item_new_from_image_label ("gtk-delete-16.png", _("Delete selected budgetary line"));
2384 g_signal_connect ( G_OBJECT ( menu_item ),
2385 "activate",
2386 G_CALLBACK ( budgetary_lines_delete_budgetary_line ),
2387 NULL );
2388 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2389
2390 if ( gtk_tree_selection_count_selected_rows ( gtk_tree_view_get_selection (
2391 GTK_TREE_VIEW ( budgetary_lines_get_tree_view ( ) ) ) ) )
2392 gtk_widget_set_sensitive ( menu_item, TRUE );
2393 else
2394 gtk_widget_set_sensitive ( menu_item, FALSE );
2395
2396 menu_item = utils_menu_item_new_from_image_label ("gtk-edit-16.png", _("Edit selected budgetary line") );
2397 g_signal_connect ( G_OBJECT ( menu_item ),
2398 "activate",
2399 G_CALLBACK ( budgetary_lines_edit_budgetary_line ),
2400 NULL );
2401 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2402
2403 if ( gtk_tree_selection_count_selected_rows ( gtk_tree_view_get_selection (
2404 GTK_TREE_VIEW ( budgetary_lines_get_tree_view ( ) ) ) ) )
2405 gtk_widget_set_sensitive ( menu_item, TRUE );
2406 else
2407 gtk_widget_set_sensitive ( menu_item, FALSE );
2408
2409 /* Separator */
2410 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), gtk_separator_menu_item_new() );
2411
2412 menu_item = utils_menu_item_new_from_image_label ("gsb-import-16.png", _("Import a file of budgetary lines (.igsb)") );
2413 g_signal_connect ( G_OBJECT ( menu_item ),
2414 "activate",
2415 G_CALLBACK ( budgetary_lines_importer_list ),
2416 NULL );
2417 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2418
2419 menu_item = utils_menu_item_new_from_image_label ("gsb-export-16.png", _("Export the list of budgetary lines (.igsb)") );
2420 g_signal_connect ( G_OBJECT ( menu_item ),
2421 "activate",
2422 G_CALLBACK ( budgetary_lines_exporter_list ),
2423 NULL );
2424 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2425 break;
2426 case GSB_REPORTS_PAGE :
2427 menu = gtk_menu_new ();
2428 menu_item = utils_menu_item_new_from_image_label ("gsb-new-report-16.png", _("New report"));
2429 g_signal_connect ( G_OBJECT ( menu_item ),
2430 "activate",
2431 G_CALLBACK ( etats_onglet_ajoute_etat ),
2432 NULL );
2433 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2434 if ( report_number == -1 )
2435 break;
2436 /* Separator */
2437 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), gtk_separator_menu_item_new() );
2438
2439 menu_item = utils_menu_item_new_from_image_label ("gtk-delete-16.png", _("Remove this report"));
2440 g_signal_connect ( G_OBJECT ( menu_item ),
2441 "activate",
2442 G_CALLBACK ( etats_onglet_efface_etat ),
2443 NULL );
2444 gtk_menu_shell_append ( GTK_MENU_SHELL ( menu ), menu_item );
2445
2446 break;
2447 }
2448
2449 /* Finish all. */
2450 if ( menu )
2451 {
2452 gtk_widget_show_all ( menu );
2453
2454 #if GTK_CHECK_VERSION (3,22,0)
2455 gtk_menu_popup_at_pointer (GTK_MENU (menu), NULL);
2456 #else
2457 gtk_menu_popup ( GTK_MENU( menu ), NULL, NULL, NULL, NULL, 3, gtk_get_current_event_time ( ) );
2458 #endif
2459 }
2460 }
2461
2462
gsb_gui_navigation_activate_expander(GtkTreeView * tree_view,GtkTreeIter * iter,GtkTreePath * path,gpointer user_data)2463 void gsb_gui_navigation_activate_expander ( GtkTreeView *tree_view,
2464 GtkTreeIter *iter,
2465 GtkTreePath *path,
2466 gpointer user_data )
2467 {
2468 GtkTreeSelection *selection;
2469 GtkTreeModel *model;
2470 GtkTreeIter iter_selected;
2471 GtkTreePath *path_selected = NULL;
2472 gint type_page;
2473 gint etat_expander;
2474
2475 etat_expander = GPOINTER_TO_INT ( user_data );
2476 selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW ( tree_view ) );
2477 if ( gtk_tree_selection_get_selected ( selection, &model, &iter_selected ) )
2478 path_selected = gtk_tree_model_get_path ( model, &iter_selected);
2479
2480 gtk_tree_model_get ( model, iter, NAVIGATION_PAGE, &type_page, -1 );
2481
2482 switch ( type_page )
2483 {
2484 case GSB_HOME_PAGE :
2485 case GSB_ACCOUNT_PAGE :
2486 account_expander = etat_expander;
2487 break;
2488 case GSB_REPORTS_PAGE :
2489 report_expander = etat_expander;
2490 break;
2491 }
2492
2493 if ( etat_expander == 0 && path_selected == NULL )
2494 gtk_tree_selection_select_iter ( selection, iter );
2495 }
2496
2497
2498 /**
2499 * Cette fonction est destinée à gérer la sortie des préférences par annulation après
2500 * test d'un nombre d'opérations sélectionner trop important.
2501 *
2502 * \param
2503 *
2504 * \return
2505 **/
gsb_gui_navigation_select_reports_page(void)2506 void gsb_gui_navigation_select_reports_page (void)
2507 {
2508 GtkWidget *child;
2509 GtkWidget *notebook;
2510 GtkWidget *tree_view;
2511 GtkTreeIter iter;
2512 GtkTreePath *path;
2513 GtkTreeSelection *selection;
2514 gint current_page;
2515
2516 devel_debug (NULL);
2517 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (navigation_tree_view));
2518 if (!selection)
2519 return;
2520
2521 path = gsb_gui_navigation_get_page_path (navigation_model, GSB_REPORTS_PAGE);
2522
2523 gtk_tree_view_collapse_row (GTK_TREE_VIEW (navigation_tree_view), path);
2524 gtk_tree_selection_select_path (selection, path);
2525
2526 /* set report_number à -1 et déselectionne le rapport dans la liste */
2527 gsb_report_set_current (0);
2528 gtk_tree_model_get_iter (navigation_model, &iter, path);
2529 gtk_tree_store_set(GTK_TREE_STORE (navigation_model),
2530 &iter,
2531 NAVIGATION_REPORT, -1,
2532 -1);
2533
2534 notebook = etats_onglet_get_notebook_etats ();
2535 current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
2536 if (current_page != 1)
2537 gtk_notebook_set_current_page (GTK_NOTEBOOK (etats_onglet_get_notebook_etats ()), 1);
2538
2539 child = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), 1);
2540 tree_view = g_object_get_data (G_OBJECT (child), "tree_view");
2541 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
2542 gtk_tree_selection_unselect_all (selection);
2543
2544 gtk_tree_path_free (path);
2545 }
2546
2547 /**
2548 * En cas de changement de theme on revient sur la HOME PAGE
2549 *
2550 * \param
2551 *
2552 * \return
2553 **/
gsb_gui_navigation_update_home_page_from_theme(void)2554 void gsb_gui_navigation_update_home_page_from_theme (void)
2555 {
2556 GtkTreePath *path;
2557
2558 gsb_gui_navigation_set_selection (GSB_HOME_PAGE, 0, 0);
2559 path = gtk_tree_path_new_first ();
2560 gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (navigation_tree_view), path, NULL, TRUE, 0.0, 0.0);
2561 }
2562
2563 /**
2564 * met à jour l'affichage suite à modification des données de localisation
2565 *
2566 * \param type_maj 0 = ELEMENT_DATE, 1 = ELEMENT_CREDIT && ELEMENT_DEBIT
2567 *
2568 * \return
2569 **/
gsb_gui_navigation_update_localisation(gint type_maj)2570 void gsb_gui_navigation_update_localisation (gint type_maj)
2571 {
2572 gint current_page;
2573
2574 current_page = gsb_gui_navigation_get_current_page ();
2575
2576 /* update home page */
2577 if (current_page == GSB_HOME_PAGE)
2578 mise_a_jour_accueil (TRUE);
2579 else
2580 run.mise_a_jour_liste_comptes_accueil = TRUE;
2581
2582 /* update sheduled liste */
2583 gsb_scheduler_list_fill_list (gsb_scheduler_list_get_tree_view ());
2584 gsb_scheduler_list_set_background_color (gsb_scheduler_list_get_tree_view ());
2585 if (current_page == GSB_SCHEDULER_PAGE)
2586 gsb_scheduler_list_select (-1);
2587
2588 /* update transaction liste */
2589 if (type_maj == 0)
2590 {
2591 transaction_list_update_element (ELEMENT_DATE);
2592 }
2593 else
2594 {
2595 transaction_list_update_element (ELEMENT_CREDIT);
2596 transaction_list_update_element (ELEMENT_DEBIT);
2597 gsb_transactions_list_update_tree_view (gsb_gui_navigation_get_current_account (), FALSE);
2598 }
2599
2600 /* update home page */
2601 if (current_page == GSB_ACCOUNT_PAGE)
2602 {
2603 gint account_number;
2604 gint account_current_page;
2605 KindAccount kind;
2606
2607 account_number = gsb_gui_navigation_get_current_account ();
2608 account_current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (grisbi_win_get_account_page ()));
2609
2610 kind = gsb_data_account_get_kind (account_number);
2611 switch (kind)
2612 {
2613 case GSB_TYPE_BALANCE:
2614 break;
2615 case GSB_TYPE_BANK:
2616 case GSB_TYPE_CASH:
2617 if (account_current_page == 1 || account_current_page == 2)
2618 {
2619 gsb_data_account_set_bet_maj (account_number, BET_MAJ_ALL);
2620 bet_data_update_bet_module (account_number, -1);
2621 }
2622 break;
2623 case GSB_TYPE_LIABILITIES:
2624 if (account_current_page == 3)
2625 bet_finance_update_amortization_tab (account_number);
2626 break;
2627 case GSB_TYPE_ASSET:
2628 break;
2629 }
2630 }
2631
2632 /* update payees, categories and budgetary lines */
2633 if (current_page == GSB_PAYEES_PAGE)
2634 payees_fill_list ();
2635 else if (current_page == GSB_CATEGORIES_PAGE)
2636 categories_fill_list ();
2637 else if (current_page == GSB_BUDGETARY_LINES_PAGE)
2638 budgetary_lines_fill_list ();
2639
2640 /* update simulator page */
2641 if (current_page == GSB_SIMULATOR_PAGE)
2642 bet_finance_ui_switch_simulator_page ();
2643 }
2644
2645 /**
2646 *
2647 *
2648 * \param
2649 *
2650 * \return
2651 **/
2652 /* Local Variables: */
2653 /* c-basic-offset: 4 */
2654 /* End: */
2655