Make column selector UI like open actions
[claws.git] / src / prefs_summary_column.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2012 Hiroyuki Yamamoto and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  * 
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #include "claws-features.h"
23 #endif
24
25 #include "defs.h"
26
27 #include <glib.h>
28 #include <glib/gi18n.h>
29 #include <gtk/gtk.h>
30 #include <gdk/gdkkeysyms.h>
31
32 #include "prefs_gtk.h"
33 #include "prefs_common.h"
34 #include "prefs_summary_column.h"
35 #include "manage_window.h"
36 #include "summaryview.h"
37 #include "mainwindow.h"
38 #include "inc.h"
39 #include "gtkutils.h"
40 #include "utils.h"
41
42 static void prefs_summary_column_set_config(SummaryColumnState *state);
43
44 enum {
45         SUMCOL_NAME,
46         SUMCOL_TYPE,
47         N_SUMCOL_COLUMNS
48 };
49
50 #define TARGET_INFO_SUMCOL  (0xFEEDBABE)
51
52 static const GtkTargetEntry row_targets[] = {
53         { "PREFS_SUM_COL_MODEL_ROW", GTK_TARGET_SAME_APP, TARGET_INFO_SUMCOL }
54 };
55
56
57 static struct _SummaryColumnDialog
58 {
59         GtkWidget *window;
60
61         GtkWidget *stock_list_view;
62         GtkWidget *shown_list_view;
63
64         GtkWidget *add_btn;
65         GtkWidget *remove_btn;
66         GtkWidget *up_btn;
67         GtkWidget *down_btn;
68
69         GtkWidget *default_btn;
70
71         GtkWidget *ok_btn;
72         GtkWidget *cancel_btn;
73
74         gboolean finished;
75 } summary_col;
76
77 static const gchar *const col_name[N_SUMMARY_COLS] = {
78         N_("Mark"),             /* S_COL_MARK    */
79         N_("Status"),           /* S_COL_STATUS  */
80         N_("Attachment"),       /* S_COL_MIME    */
81         N_("Subject"),          /* S_COL_SUBJECT */
82         N_("From"),             /* S_COL_FROM    */
83         N_("To"),               /* S_COL_TO      */
84         N_("Date"),             /* S_COL_DATE    */
85         N_("Size"),             /* S_COL_SIZE    */
86         N_("Number"),           /* S_COL_NUMBER  */
87         N_("Score"),            /* S_COL_SCORE   */
88         N_("Locked"),           /* S_COL_LOCKED  */
89         N_("Tags"),             /* S_COL_TAGS  */
90 };
91
92 static SummaryColumnState default_state[N_SUMMARY_COLS] = {
93         { S_COL_MARK   , TRUE  },
94         { S_COL_STATUS , TRUE  },
95         { S_COL_MIME   , TRUE  },
96         { S_COL_SUBJECT, TRUE  },
97         { S_COL_FROM   , TRUE  },
98         { S_COL_TO     , FALSE },
99         { S_COL_DATE   , TRUE  },
100         { S_COL_SIZE   , TRUE  },
101         { S_COL_NUMBER , FALSE },
102         { S_COL_SCORE  , FALSE },
103         { S_COL_LOCKED , FALSE },
104         { S_COL_TAGS   , FALSE },
105 };
106
107 static void prefs_summary_column_create (void);
108
109 static void prefs_summary_column_set_dialog     (SummaryColumnState *state);
110 static void prefs_summary_column_set_view       (void);
111
112 /* callback functions */
113 static void prefs_summary_column_add    (void);
114 static void prefs_summary_column_remove (void);
115
116 static void prefs_summary_column_up     (void);
117 static void prefs_summary_column_down   (void);
118
119 static void prefs_summary_column_set_to_default (void);
120
121 static void prefs_summary_column_ok     (void);
122 static void prefs_summary_column_cancel (void);
123
124 static gint prefs_summary_column_delete_event   (GtkWidget      *widget,
125                                                  GdkEventAny    *event,
126                                                  gpointer        data);
127 static gboolean prefs_summary_column_key_pressed(GtkWidget      *widget,
128                                                  GdkEventKey    *event,
129                                                  gpointer        data);
130
131 static GtkListStore *prefs_summary_column_create_store  (void);
132
133 static void prefs_summary_column_insert_column  (GtkListStore *store,
134                                                  gint row,
135                                                  const gchar *name,
136                                                  SummaryColumnType type);
137                                                
138 static SummaryColumnType prefs_summary_column_get_column        (GtkWidget *list, 
139                                                                  gint row);
140
141 static GtkWidget *prefs_summary_column_list_view_create (const gchar *name);
142
143 static void prefs_filtering_create_list_view_columns    (GtkWidget *list_view, 
144                                                          const gchar *name);
145
146 static void drag_data_get       (GtkTreeView *tree_view, 
147                                  GdkDragContext *context, 
148                                  GtkSelectionData *data, 
149                                  guint info, 
150                                  guint time, 
151                                  GtkTreeModel *model);
152                           
153 static void drag_data_received  (GtkTreeView *tree_view, 
154                                  GdkDragContext *context,
155                                  gint x, gint y, 
156                                  GtkSelectionData *data,
157                                  guint info, 
158                                  guint time, 
159                                  GtkTreeModel *model);
160
161 static void prefs_summary_column_shown_set_btn_sensitivity(void);
162 static void prefs_summary_column_shown_set_active(const gboolean active);
163 static void prefs_summary_column_stock_set_active(const gboolean active);
164 static void prefs_summary_column_shown_sel_changed(void);
165 static void prefs_summary_column_stock_sel_changed(void);
166
167 void prefs_summary_column_open(void)
168 {
169         inc_lock();
170
171         if (!summary_col.window)
172                 prefs_summary_column_create();
173
174         manage_window_set_transient(GTK_WINDOW(summary_col.window));
175         gtk_widget_grab_focus(summary_col.ok_btn);
176
177         prefs_summary_column_set_dialog(NULL);
178
179         gtk_widget_show(summary_col.window);
180         gtk_window_set_modal(GTK_WINDOW(summary_col.window), TRUE);
181
182         summary_col.finished = FALSE;
183         while (summary_col.finished == FALSE)
184                 gtk_main_iteration();
185
186         gtk_widget_hide(summary_col.window);
187         gtk_window_set_modal(GTK_WINDOW(summary_col.window), FALSE);
188         inc_unlock();
189 }
190
191 static void prefs_summary_column_create(void)
192 {
193         GtkWidget *window;
194         GtkWidget *vbox;
195
196         GtkWidget *label_hbox;
197         GtkWidget *label;
198
199         GtkWidget *vbox1;
200
201         GtkWidget *hbox1;
202         GtkWidget *clist_hbox;
203         GtkWidget *scrolledwin;
204         GtkWidget *stock_list_view;
205         GtkWidget *shown_list_view;
206
207         GtkWidget *btn_vbox;
208         GtkWidget *add_btn;
209         GtkWidget *remove_btn;
210         GtkWidget *up_btn;
211         GtkWidget *down_btn;
212
213         GtkWidget *btn_hbox;
214         GtkWidget *default_btn;
215         GtkWidget *confirm_area;
216         GtkWidget *ok_btn;
217         GtkWidget *cancel_btn;
218
219         debug_print("Creating summary column setting window...\n");
220
221         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_summary_column");
222         gtk_container_set_border_width(GTK_CONTAINER(window), 8);
223         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
224         gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
225         gtk_window_set_title(GTK_WINDOW(window),
226                              _("Message list columns configuration"));
227         g_signal_connect(G_OBJECT(window), "delete_event",
228                          G_CALLBACK(prefs_summary_column_delete_event),
229                          NULL);
230         g_signal_connect(G_OBJECT(window), "key_press_event",
231                          G_CALLBACK(prefs_summary_column_key_pressed),
232                          NULL);
233
234         vbox = gtk_vbox_new(FALSE, 6);
235         gtk_widget_show(vbox);
236         gtk_container_add(GTK_CONTAINER(window), vbox);
237
238         label_hbox = gtk_hbox_new(FALSE, 0);
239         gtk_widget_show(label_hbox);
240         gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4);
241
242         label = gtk_label_new
243                 (_("Select columns to be displayed in the message list. You can modify\n"
244                    "the order by using the Up / Down buttons or by dragging the items."));
245         gtk_widget_show(label);
246         gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4);
247         gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
248
249         vbox1 = gtk_vbox_new(FALSE, VSPACING);
250         gtk_widget_show(vbox1);
251         gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
252         gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2);
253
254         hbox1 = gtk_hbox_new(FALSE, 8);
255         gtk_widget_show(hbox1);
256         gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);
257
258         clist_hbox = gtk_hbox_new(FALSE, 8);
259         gtk_widget_show(clist_hbox);
260         gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);
261
262         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
263         gtk_widget_set_size_request(scrolledwin, 180, 210);
264         gtk_widget_show(scrolledwin);
265         gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
266         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
267                                        GTK_POLICY_AUTOMATIC,
268                                        GTK_POLICY_AUTOMATIC);
269         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
270                                            GTK_SHADOW_IN);
271
272         stock_list_view = prefs_summary_column_list_view_create
273                                 (_("Hidden columns"));
274         g_signal_connect(G_OBJECT(stock_list_view), "cursor-changed",
275                            G_CALLBACK(prefs_summary_column_stock_sel_changed),
276                            NULL);
277         gtk_widget_show(stock_list_view);
278         gtk_container_add(GTK_CONTAINER(scrolledwin), stock_list_view);
279
280         /* add/remove button */
281         btn_vbox = gtk_vbox_new(FALSE, 8);
282         gtk_widget_show(btn_vbox);
283         gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);
284
285         add_btn = gtk_button_new_from_stock(GTK_STOCK_ADD);
286         gtk_widget_show(add_btn);
287         gtk_box_pack_start(GTK_BOX(btn_vbox), add_btn, FALSE, TRUE, 0);
288
289         g_signal_connect(G_OBJECT(add_btn), "clicked",
290                          G_CALLBACK(prefs_summary_column_add), NULL);
291
292         remove_btn = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
293         gtk_widget_show(remove_btn);
294         gtk_box_pack_start(GTK_BOX(btn_vbox), remove_btn, FALSE, TRUE, 0);
295
296         g_signal_connect(G_OBJECT(remove_btn), "clicked",
297                          G_CALLBACK(prefs_summary_column_remove), NULL);
298
299         clist_hbox = gtk_hbox_new(FALSE, 8);
300         gtk_widget_show(clist_hbox);
301         gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);
302
303         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
304         gtk_widget_set_size_request(scrolledwin, 180, 210);
305         gtk_widget_show(scrolledwin);
306         gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
307         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
308                                        GTK_POLICY_AUTOMATIC,
309                                        GTK_POLICY_AUTOMATIC);
310         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
311                                            GTK_SHADOW_IN);
312
313         shown_list_view = prefs_summary_column_list_view_create
314                                 (_("Displayed columns"));
315         g_signal_connect(G_OBJECT(shown_list_view), "cursor-changed",
316                            G_CALLBACK(prefs_summary_column_shown_sel_changed),
317                            NULL);
318         gtk_widget_show(shown_list_view);
319         gtk_container_add(GTK_CONTAINER(scrolledwin), shown_list_view);
320
321         /* up/down button */
322         btn_vbox = gtk_vbox_new(FALSE, 8);
323         gtk_widget_show(btn_vbox);
324         gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);
325
326         up_btn = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
327         gtk_widget_show(up_btn);
328         gtk_box_pack_start(GTK_BOX(btn_vbox), up_btn, FALSE, TRUE, 0);
329
330         down_btn = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
331         gtk_widget_show(down_btn);
332         gtk_box_pack_start(GTK_BOX(btn_vbox), down_btn, FALSE, TRUE, 0);
333
334         g_signal_connect(G_OBJECT(up_btn), "clicked",
335                          G_CALLBACK(prefs_summary_column_up), NULL);
336         g_signal_connect(G_OBJECT(down_btn), "clicked",
337                          G_CALLBACK(prefs_summary_column_down), NULL);
338
339         btn_hbox = gtk_hbox_new(FALSE, 8);
340         gtk_widget_show(btn_hbox);
341         gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0);
342
343         btn_vbox = gtk_vbox_new(FALSE, 0);
344         gtk_widget_show(btn_vbox);
345         gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0);
346
347         default_btn = gtk_button_new_with_label(_(" Use default "));
348         gtk_widget_show(default_btn);
349         gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0);
350         g_signal_connect(G_OBJECT(default_btn), "clicked",
351                          G_CALLBACK(prefs_summary_column_set_to_default),
352                          NULL);
353
354         gtkut_stock_button_set_create(&confirm_area,
355                                       &cancel_btn, GTK_STOCK_CANCEL,
356                                       &ok_btn, GTK_STOCK_OK,
357                                       NULL, NULL);
358         gtk_widget_show(confirm_area);
359         gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
360         gtk_widget_grab_default(ok_btn);
361
362         g_signal_connect(G_OBJECT(ok_btn), "clicked",
363                          G_CALLBACK(prefs_summary_column_ok), NULL);
364         g_signal_connect(G_OBJECT(cancel_btn), "clicked",
365                          G_CALLBACK(prefs_summary_column_cancel), NULL);
366
367
368         summary_col.window      = window;
369         summary_col.add_btn     = add_btn;
370         summary_col.remove_btn  = remove_btn;
371         summary_col.up_btn      = up_btn;
372         summary_col.down_btn    = down_btn;
373         summary_col.ok_btn      = ok_btn;
374         summary_col.cancel_btn  = cancel_btn;
375         summary_col.stock_list_view = stock_list_view;
376         summary_col.shown_list_view = shown_list_view;
377         
378         prefs_summary_column_shown_set_active(FALSE);
379         prefs_summary_column_stock_set_active(FALSE);
380 }
381
382 SummaryColumnState *prefs_summary_column_get_config(void)
383 {
384         static SummaryColumnState state[N_SUMMARY_COLS];
385         SummaryColumnType type;
386         gint pos;
387
388         for (pos = 0; pos < N_SUMMARY_COLS; pos++)
389                 state[pos].type = -1;
390
391         for (type = 0; type < N_SUMMARY_COLS; type++) {
392                 pos = prefs_common.summary_col_pos[type];
393                 if (pos < 0 || pos >= N_SUMMARY_COLS ||
394                     state[pos].type != -1) {
395                         g_warning("Wrong column position");
396                         prefs_summary_column_set_config(default_state);
397                         return default_state;
398                 }
399
400                 state[pos].type = type;
401                 state[pos].visible = prefs_common.summary_col_visible[type];
402         }
403
404         return state;
405 }
406
407 static void prefs_summary_column_set_config(SummaryColumnState *state)
408 {
409         SummaryColumnType type;
410         gint pos;
411
412         for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
413                 type = state[pos].type;
414                 prefs_common.summary_col_visible[type] = state[pos].visible;
415                 prefs_common.summary_col_pos[type] = pos;
416         }
417 }
418
419 static void prefs_summary_column_set_dialog(SummaryColumnState *state)
420 {
421         GtkListStore *stock_store, *shown_store;
422         gint pos;
423         SummaryColumnType type;
424         gchar *name;
425
426         stock_store = GTK_LIST_STORE(gtk_tree_view_get_model
427                         (GTK_TREE_VIEW(summary_col.stock_list_view)));
428         shown_store = GTK_LIST_STORE(gtk_tree_view_get_model
429                         (GTK_TREE_VIEW(summary_col.shown_list_view)));
430
431         gtk_list_store_clear(stock_store);
432         gtk_list_store_clear(shown_store);
433
434         if (!state)
435                 state = prefs_summary_column_get_config();
436
437         for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
438                 type = state[pos].type;
439                 name = gettext(col_name[type]);
440
441                 if (state[pos].visible)
442                         prefs_summary_column_insert_column(shown_store,
443                                                            -1, name,
444                                                            type);
445                 else
446                         prefs_summary_column_insert_column(stock_store,
447                                                             -1, name,
448                                                             type);
449         }
450 }
451
452 static void prefs_summary_column_set_view(void)
453 {
454         gint stock_n_rows, shown_n_rows;
455         SummaryColumnState state[N_SUMMARY_COLS];
456         SummaryColumnType type;
457         gint row, pos = 0;
458
459         stock_n_rows = gtk_tree_model_iter_n_children
460                 (gtk_tree_view_get_model(GTK_TREE_VIEW
461                         (summary_col.stock_list_view)), NULL);
462         shown_n_rows = gtk_tree_model_iter_n_children
463                 (gtk_tree_view_get_model(GTK_TREE_VIEW
464                         (summary_col.shown_list_view)), NULL);
465
466         cm_return_if_fail
467                 (stock_n_rows + shown_n_rows == N_SUMMARY_COLS);
468
469         for (row = 0; row < stock_n_rows; row++) {
470                 type = prefs_summary_column_get_column
471                         (summary_col.stock_list_view, row);
472                 state[row].type = type;
473                 state[row].visible = FALSE;
474         }
475
476         pos = row;
477         for (row = 0; row < shown_n_rows; row++) {
478                 type = prefs_summary_column_get_column
479                         (summary_col.shown_list_view, row);
480                 state[pos + row].type = type;
481                 state[pos + row].visible = TRUE;
482         }
483
484         prefs_summary_column_set_config(state);
485         main_window_set_summary_column();
486 }
487
488 static void prefs_summary_column_add(void)
489 {
490         GtkListStore *stock_store, *shown_store;
491         GtkTreeIter stock_sel, shown_sel, shown_add;
492         gboolean shown_sel_valid;
493         gchar *name;
494         SummaryColumnType type;
495         
496         stock_store = GTK_LIST_STORE(gtk_tree_view_get_model
497                 (GTK_TREE_VIEW(summary_col.stock_list_view)));
498         shown_store = GTK_LIST_STORE(gtk_tree_view_get_model
499                 (GTK_TREE_VIEW(summary_col.shown_list_view)));
500         
501         if (!gtk_tree_selection_get_selected
502                 (gtk_tree_view_get_selection
503                         (GTK_TREE_VIEW(summary_col.stock_list_view)),
504                  NULL,
505                  &stock_sel))
506                 return;
507
508         shown_sel_valid = gtk_tree_selection_get_selected
509                 (gtk_tree_view_get_selection
510                         (GTK_TREE_VIEW(summary_col.shown_list_view)),
511                  NULL,
512                  &shown_sel);
513                          
514         gtk_tree_model_get(GTK_TREE_MODEL(stock_store), &stock_sel,
515                            SUMCOL_TYPE, &type,
516                            -1);
517                         
518         gtk_list_store_remove(stock_store, &stock_sel);
519
520         gtk_list_store_insert_after(shown_store, &shown_add, 
521                                     shown_sel_valid ? &shown_sel : NULL);
522
523         name = gettext(col_name[type]);                             
524                                     
525         gtk_list_store_set(shown_store, &shown_add,
526                            SUMCOL_NAME, name,
527                            SUMCOL_TYPE, type,
528                            -1);
529         
530         gtk_tree_selection_select_iter(gtk_tree_view_get_selection
531                 (GTK_TREE_VIEW(summary_col.shown_list_view)),
532                  &shown_add);
533         prefs_summary_column_shown_set_active(TRUE);
534         prefs_summary_column_stock_set_active(FALSE);
535 }
536
537 static void prefs_summary_column_remove(void)
538 {
539         GtkListStore *stock_store, *shown_store;
540         GtkTreeIter shown_sel, stock_sel, stock_add;
541         gboolean stock_sel_valid;
542         gchar *name;
543         SummaryColumnType type;
544         
545         stock_store = GTK_LIST_STORE(gtk_tree_view_get_model
546                 (GTK_TREE_VIEW(summary_col.stock_list_view)));
547         shown_store = GTK_LIST_STORE(gtk_tree_view_get_model
548                 (GTK_TREE_VIEW(summary_col.shown_list_view)));
549                 
550         if (!gtk_tree_selection_get_selected
551                 (gtk_tree_view_get_selection
552                         (GTK_TREE_VIEW(summary_col.shown_list_view)),
553                  NULL,
554                  &shown_sel))
555                 return;
556
557         stock_sel_valid = gtk_tree_selection_get_selected
558                 (gtk_tree_view_get_selection
559                         (GTK_TREE_VIEW(summary_col.stock_list_view)),
560                  NULL,
561                  &stock_sel);
562         
563         gtk_tree_model_get(GTK_TREE_MODEL(shown_store), &shown_sel,
564                            SUMCOL_TYPE, &type,
565                            -1);
566                         
567         gtk_list_store_remove(shown_store, &shown_sel);
568
569         gtk_list_store_insert_after(stock_store, &stock_add, 
570                                     stock_sel_valid ? &stock_sel : NULL);
571
572         name = gettext(col_name[type]);                             
573                                     
574         gtk_list_store_set(stock_store, &stock_add,
575                            SUMCOL_NAME, name,
576                            SUMCOL_TYPE, type,
577                            -1);
578         
579         gtk_tree_selection_select_iter(gtk_tree_view_get_selection
580                 (GTK_TREE_VIEW(summary_col.stock_list_view)),
581                 &stock_add);
582         prefs_summary_column_shown_set_active(FALSE);
583         prefs_summary_column_stock_set_active(TRUE);
584 }
585
586 static void prefs_summary_column_up(void)
587 {
588         GtkTreePath *prev, *sel;
589         GtkTreeIter isel;
590         GtkListStore *shown_store;
591         GtkTreeIter iprev;
592         
593         if (!gtk_tree_selection_get_selected
594                 (gtk_tree_view_get_selection
595                         (GTK_TREE_VIEW(summary_col.shown_list_view)),
596                  NULL,
597                  &isel))
598                 return;
599
600         shown_store = GTK_LIST_STORE(gtk_tree_view_get_model
601                 (GTK_TREE_VIEW(summary_col.shown_list_view)));
602
603         sel = gtk_tree_model_get_path(GTK_TREE_MODEL(shown_store), 
604                                       &isel);
605         if (!sel)
606                 return;
607
608         prev = gtk_tree_path_copy(sel);         
609         if (!gtk_tree_path_prev(prev)) {
610                 gtk_tree_path_free(prev);
611                 gtk_tree_path_free(sel);
612                 return;
613         }
614
615         gtk_tree_model_get_iter(GTK_TREE_MODEL(shown_store),
616                                 &iprev, prev);
617         gtk_tree_path_free(sel);
618         gtk_tree_path_free(prev);
619
620         gtk_list_store_swap(shown_store, &iprev, &isel);
621         prefs_summary_column_shown_set_btn_sensitivity();
622 }
623
624 static void prefs_summary_column_down(void)
625 {
626         GtkListStore *shown_store;
627         GtkTreeIter next, sel;
628         
629         if (!gtk_tree_selection_get_selected
630                 (gtk_tree_view_get_selection
631                         (GTK_TREE_VIEW(summary_col.shown_list_view)),
632                  NULL,
633                  &sel))
634                 return;
635
636         shown_store = GTK_LIST_STORE(gtk_tree_view_get_model
637                 (GTK_TREE_VIEW(summary_col.shown_list_view)));
638
639         next = sel;
640         if (!gtk_tree_model_iter_next(GTK_TREE_MODEL(shown_store), &next)) 
641                 return;
642
643         gtk_list_store_swap(shown_store, &next, &sel);
644         prefs_summary_column_shown_set_btn_sensitivity();
645 }
646
647 static void prefs_summary_column_set_to_default(void)
648 {
649         prefs_summary_column_set_dialog(default_state);
650         prefs_summary_column_shown_set_active(FALSE);
651         prefs_summary_column_stock_set_active(FALSE);
652 }
653
654 static void prefs_summary_column_ok(void)
655 {
656         if (!summary_col.finished) {
657                 summary_col.finished = TRUE;
658                 prefs_summary_column_set_view();
659         }
660 }
661
662 static void prefs_summary_column_cancel(void)
663 {
664         summary_col.finished = TRUE;
665 }
666
667 static gint prefs_summary_column_delete_event(GtkWidget *widget,
668                                               GdkEventAny *event,
669                                               gpointer data)
670 {
671         summary_col.finished = TRUE;
672         return TRUE;
673 }
674
675 static gboolean prefs_summary_column_key_pressed(GtkWidget *widget,
676                                                  GdkEventKey *event,
677                                                  gpointer data)
678 {
679         if (event && event->keyval == GDK_KEY_Escape)
680                 summary_col.finished = TRUE;
681         return FALSE;
682 }
683
684 static GtkListStore *prefs_summary_column_create_store(void)
685 {
686         return gtk_list_store_new(N_SUMCOL_COLUMNS,
687                                   G_TYPE_STRING,
688                                   G_TYPE_INT,
689                                   -1);
690 }
691
692 static void prefs_summary_column_insert_column(GtkListStore *store,
693                                                gint row,
694                                                const gchar *name,
695                                                SummaryColumnType type)
696 {
697         GtkTreeIter iter;
698
699         if (row >= 0) {
700                 if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(store),
701                                                    &iter, NULL, row))
702                         row = -1;                                                  
703         }
704         if (row < 0) {
705                 /* add new */
706                 gtk_list_store_append(store, &iter);
707                 gtk_list_store_set(store, &iter,
708                                    SUMCOL_NAME, name,
709                                    SUMCOL_TYPE, type,
710                                    -1);
711                 return;
712         } else {
713                 /* change existing */
714                 gtk_list_store_set(store, &iter, 
715                                    SUMCOL_NAME, name,
716                                    SUMCOL_TYPE, type,
717                                    -1);
718         }
719 }
720
721 /*!
722  *\brief        Return the columnn type for a row
723  */
724 static SummaryColumnType prefs_summary_column_get_column(GtkWidget *list, gint row)
725 {       
726         GtkTreeView *list_view = GTK_TREE_VIEW(list);
727         GtkTreeModel *model = gtk_tree_view_get_model(list_view);
728         GtkTreeIter iter;
729         SummaryColumnType result;
730
731         if (!gtk_tree_model_iter_nth_child(model, &iter, NULL, row))
732                 return -1;
733         
734         gtk_tree_model_get(model, &iter, 
735                            SUMCOL_TYPE, &result,
736                            -1);
737         
738         return result;
739 }
740
741 static GtkWidget *prefs_summary_column_list_view_create(const gchar *name)
742 {
743         GtkWidget *list_view;
744         GtkTreeSelection *selector;
745         GtkTreeModel *model;
746
747         model = GTK_TREE_MODEL(prefs_summary_column_create_store());
748         list_view = gtk_tree_view_new_with_model(model);
749         g_object_unref(G_OBJECT(model));
750         
751         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view),
752                                      prefs_common.use_stripes_everywhere);
753         
754         selector = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view));
755         gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE);
756
757         prefs_filtering_create_list_view_columns(GTK_WIDGET(list_view), name);
758
759         gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(list_view),
760                                                GDK_BUTTON1_MASK,
761                                                row_targets,
762                                                G_N_ELEMENTS(row_targets), 
763                                                GDK_ACTION_MOVE);
764                                             
765         gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(list_view), 
766                                              row_targets, 
767                                              G_N_ELEMENTS(row_targets), 
768                                              GDK_ACTION_MOVE);
769                 
770         g_signal_connect(G_OBJECT(list_view), "drag_data_get",
771                          G_CALLBACK(drag_data_get),
772                          model);
773
774         g_signal_connect(G_OBJECT(list_view), "drag_data_received",
775                          G_CALLBACK(drag_data_received),
776                          model);
777
778         return list_view;
779 }
780
781 static void prefs_filtering_create_list_view_columns(GtkWidget *list_view, 
782                                                      const gchar *name)
783 {
784         GtkTreeViewColumn *column;
785         GtkCellRenderer *renderer;
786
787         renderer = gtk_cell_renderer_text_new();
788         column = gtk_tree_view_column_new_with_attributes
789                 (name, renderer, "text", SUMCOL_NAME, NULL);
790         gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);          
791 }
792
793 static void drag_data_get(GtkTreeView *tree_view, GdkDragContext *context, 
794                           GtkSelectionData *data, guint info, 
795                           guint time, GtkTreeModel *model)
796 {
797         GtkTreeIter iter;
798         SummaryColumnType type;
799         GtkTreeModel *source_model;
800
801         if (info != TARGET_INFO_SUMCOL) 
802                 return;
803
804         if (!gtk_tree_selection_get_selected
805                         (gtk_tree_view_get_selection(tree_view),
806                          &source_model, &iter)) 
807                 return;                  
808         
809         gtk_tree_model_get(source_model, &iter, 
810                            SUMCOL_TYPE, &type,
811                            -1);
812
813         /* send the type */
814         gtk_selection_data_set(data, gtk_selection_data_get_target(data), 8,
815                 (gchar *) &type, sizeof type);
816 }
817
818 static void drag_data_received(GtkTreeView *tree_view, GdkDragContext *context,
819                                gint x, gint y, GtkSelectionData *data,
820                                guint info, guint time, GtkTreeModel *model)
821 {
822         GtkWidget *source;
823         GtkTreePath *dst = NULL, *sel = NULL;
824         GtkTreeIter isel, idst;
825         GtkTreeViewDropPosition pos;
826         SummaryColumnType type;
827         GtkTreeModel *sel_model;
828         gchar *name;
829         
830         source = gtk_drag_get_source_widget(context);
831         
832         if (source == GTK_WIDGET(tree_view)) {
833         
834                 /*
835                  * Same widget: re-order
836                  */
837                  
838                 gtk_tree_selection_get_selected(gtk_tree_view_get_selection(tree_view),
839                                            NULL, &isel);
840                 sel = gtk_tree_model_get_path(model, &isel);
841                 gtk_tree_view_get_dest_row_at_pos(tree_view, x, y,
842                                                   &dst, &pos);
843
844                 /* NOTE: dst is invalid if selection beyond last row, in that
845                  * case move beyond last one (XXX_move_before(..., NULL)) */                                              
846
847                 if (dst)                                                  
848                         gtk_tree_model_get_iter(model, &idst, dst);
849                 else 
850                         gtk_list_store_move_before(GTK_LIST_STORE(model),
851                                                    &isel,
852                                                    NULL);
853
854                 /* we do not drag if no valid dst and sel, and when
855                  * dst and sel are the same (moving after or before
856                  * itself doesn't change order...) */
857                 if ((dst && sel) && gtk_tree_path_compare(sel, dst) != 0) {
858                         if (pos == GTK_TREE_VIEW_DROP_BEFORE
859                         ||  pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)
860                                 gtk_list_store_move_before(GTK_LIST_STORE(model),
861                                                            &isel,
862                                                            &idst);
863                         else
864                                 gtk_list_store_move_after(GTK_LIST_STORE(model),
865                                                           &isel,
866                                                           &idst);
867                         
868                 } 
869                 gtk_tree_path_free(dst);                                          
870                 gtk_tree_path_free(sel);
871                 gtk_drag_finish(context, TRUE, FALSE, time);
872                 
873         } else if (source == summary_col.stock_list_view 
874         ||         source == summary_col.shown_list_view) {
875         
876                 /*
877                  * Other widget: change and update
878                  */
879
880                 
881                 /* get source information and remove */
882                 gtk_tree_selection_get_selected(gtk_tree_view_get_selection(
883                                                 GTK_TREE_VIEW(source)),
884                                                 &sel_model, &isel);
885                 type = *((gint *) gtk_selection_data_get_data(data));
886                 name = gettext(col_name[type]);
887                 gtk_list_store_remove(GTK_LIST_STORE(sel_model), &isel);
888
889                 /* get insertion position */
890                 gtk_tree_view_get_dest_row_at_pos(tree_view, x, y, &dst, &pos);
891
892                 /* NOTE: dst is invalid if insertion point beyond last row, 
893                  * just append to list in that case (XXX_store_append()) */
894
895                 if (dst) {
896                         gtk_tree_model_get_iter(model, &idst, dst);
897
898                         if (pos == GTK_TREE_VIEW_DROP_BEFORE
899                         ||  pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)
900                                 gtk_list_store_insert_before(GTK_LIST_STORE(model),
901                                                              &isel,
902                                                              &idst);
903                         else
904                                 gtk_list_store_insert_after(GTK_LIST_STORE(model),
905                                                             &isel,
906                                                             &idst);
907                 } else
908                         gtk_list_store_append(GTK_LIST_STORE(model),
909                                               &isel);
910                 
911                 gtk_list_store_set(GTK_LIST_STORE(model), &isel,
912                                    SUMCOL_NAME, name,
913                                    SUMCOL_TYPE, type, -1);
914                 gtk_tree_path_free(dst);
915                 gtk_drag_finish(context, TRUE, FALSE, time);
916         }
917
918         prefs_summary_column_shown_set_active(FALSE);
919         prefs_summary_column_stock_set_active(FALSE);
920         
921         /* XXXX: should we call gtk_drag_finish() for other code paths? */
922 }
923
924 static void prefs_summary_column_shown_set_btn_sensitivity(void)
925 {
926         GtkTreeModel *model = GTK_TREE_MODEL(gtk_tree_view_get_model(
927                 GTK_TREE_VIEW(summary_col.shown_list_view)));
928         GtkTreeSelection *selection = gtk_tree_view_get_selection(
929                 GTK_TREE_VIEW(summary_col.shown_list_view));
930         GtkTreeIter iter;
931         GtkTreePath *path;
932         
933         if(!gtk_tree_selection_get_selected(selection, NULL, &iter)) {
934                 gtk_widget_set_sensitive(summary_col.remove_btn, FALSE);
935                 gtk_widget_set_sensitive(summary_col.up_btn, FALSE);
936                 gtk_widget_set_sensitive(summary_col.down_btn, FALSE);
937                 return;
938         }
939         
940         path = gtk_tree_model_get_path(model, &iter);
941
942         gtk_widget_set_sensitive(summary_col.up_btn, gtk_tree_path_prev(path));
943         gtk_widget_set_sensitive(summary_col.down_btn,
944                                  gtk_tree_model_iter_next(model, &iter));
945         gtk_tree_path_free(path);
946 }
947
948 static void prefs_summary_column_shown_set_active(const gboolean active)
949 {
950         GtkTreeSelection *selection = NULL;
951         
952         gtk_widget_set_sensitive(summary_col.remove_btn, active);
953         
954         if(active == FALSE) {
955                 selection = gtk_tree_view_get_selection(
956                         GTK_TREE_VIEW(summary_col.shown_list_view));
957                 gtk_tree_selection_unselect_all(selection);
958                 
959                 gtk_widget_set_sensitive(summary_col.up_btn, FALSE);
960                 gtk_widget_set_sensitive(summary_col.down_btn, FALSE);
961         } else {
962                 prefs_summary_column_shown_set_btn_sensitivity();
963         }
964 }
965
966 static void prefs_summary_column_stock_set_active(const gboolean active)
967 {
968         GtkTreeSelection *selection = NULL;
969         
970         gtk_widget_set_sensitive(summary_col.add_btn, active);
971         
972         if(active == FALSE) {
973                 selection = gtk_tree_view_get_selection(
974                         GTK_TREE_VIEW(summary_col.stock_list_view));
975                 gtk_tree_selection_unselect_all(selection);
976         }
977 }
978
979 static void prefs_summary_column_stock_sel_changed(void)
980 {
981         GtkTreeSelection *selection = gtk_tree_view_get_selection(
982                 GTK_TREE_VIEW(summary_col.stock_list_view));
983         prefs_summary_column_stock_set_active(
984                 (selection != NULL) ? TRUE : FALSE);
985         prefs_summary_column_shown_set_active(
986                 (selection != NULL) ? FALSE : TRUE);
987 }
988
989 static void prefs_summary_column_shown_sel_changed(void)
990 {
991         GtkTreeSelection *selection = gtk_tree_view_get_selection(
992                 GTK_TREE_VIEW(summary_col.shown_list_view));
993         prefs_summary_column_shown_set_active(
994                 (selection != NULL) ? TRUE : FALSE);
995         prefs_summary_column_stock_set_active(
996                 (selection != NULL) ? FALSE : TRUE);
997 }