← Back to branch summary

~ubuntu-branches/debian/lenny/evolution/lenny

« back to all changes in this revision

Viewing changes to widgets/menus/gal-define-views-dialog.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-06-19 10:52:49 UTC
  • Revision ID: james.westby@ubuntu.com-20070619105249-g8exw8g89lmp94b6
Tags: upstream-2.11.4
Import upstream version 2.11.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
widgets/menus/gal-define-views-dialog.c
24
24
#include <config.h>
25
25
 
26
26
#include <gtk/gtk.h>
27
 
 
28
 
#include "table/e-table-scrolled.h"
 
27
#include <gtk/gtklabel.h>
29
28
#include <glib/gi18n.h>
 
29
 
30
30
#include "e-util/e-util.h"
31
31
#include "e-util/e-util-private.h"
32
32
 
49
49
        PROP_COLLECTION
50
50
};
51
51
 
 
52
enum {
 
53
        COL_GALVIEW_NAME,
 
54
        COL_GALVIEW_DATA
 
55
};
 
56
 
52
57
typedef struct {
53
58
        char         *title;
54
 
        ETableModel  *model;
 
59
 
 
60
        GtkTreeView *treeview;
 
61
        GtkTreeModel *model;
 
62
 
55
63
        GalDefineViewsDialog *names;
56
64
} GalDefineViewsDialogChild;
57
65
 
79
87
                                                              G_PARAM_READWRITE));
80
88
}
81
89
 
82
 
/* ETable creation */
83
 
#define SPEC "<ETableSpecification cursor-mode=\"line\" draw-grid=\"true\" selection-mode=\"single\" gettext-domain=\"" GETTEXT_PACKAGE "\">" \
84
 
             "<ETableColumn model_col= \"0\" _title=\"Name\" expansion=\"1.0\" minimum_width=\"18\" resizable=\"true\" cell=\"string\" compare=\"string\"/>" \
85
 
             "<ETableState> <column source=\"0\"/> <grouping> </grouping> </ETableState>" \
86
 
             "</ETableSpecification>"
87
 
 
88
 
/* For use from libglade. */
89
 
GtkWidget *gal_define_views_dialog_create_etable(char *name, char *string1, char *string2, int int1, int int2);
90
 
 
91
 
GtkWidget *
92
 
gal_define_views_dialog_create_etable(char *name, char *string1, char *string2, int int1, int int2)
93
 
{
94
 
        GtkWidget *table;
95
 
        ETableModel *model;
96
 
        model = gal_define_views_model_new();
97
 
        table = e_table_scrolled_new(model, NULL, SPEC, NULL);
98
 
        g_object_set_data(G_OBJECT (table), "GalDefineViewsDialog::model", model);
99
 
        return table;
100
 
}
101
 
 
102
90
/* Button callbacks */
103
91
 
104
92
static void
105
 
gdvd_button_new_dialog_callback(GtkWidget *widget, int id, GalDefineViewsDialog *dialog)
 
93
gdvd_button_new_dialog_callback (GtkWidget *widget, int id, GalDefineViewsDialog *dialog)
106
94
{
107
95
        gchar *name;
 
96
        GtkTreeIter iter;
108
97
        GalView *view;
 
98
        GalViewCollectionItem *item;
109
99
        GalViewFactory *factory;
 
100
 
110
101
        switch (id) {
111
102
        case GTK_RESPONSE_OK:
112
 
                g_object_get(widget,
 
103
                g_object_get (widget,
113
104
                             "name", &name,
114
105
                             "factory", &factory,
115
106
                             NULL);
 
107
 
116
108
                if (name && factory) {
117
109
                        g_strchomp(name);
118
110
                        if (*name != '\0') {
119
 
                                view = gal_view_factory_new_view(factory, name);
120
 
                                gal_define_views_model_append(GAL_DEFINE_VIEWS_MODEL(dialog->model), view);
121
 
                                gal_view_edit(view, GTK_WINDOW (dialog));
122
 
                                g_object_unref(view);
 
111
                                view = gal_view_factory_new_view (factory, name);
 
112
                                gal_view_collection_append(dialog->collection, view);
 
113
 
 
114
                                item = dialog->collection->view_data[dialog->collection->view_count-1];
 
115
                                gtk_list_store_append (GTK_LIST_STORE (dialog->model), &iter);
 
116
                                gtk_list_store_set (GTK_LIST_STORE (dialog->model), &iter,
 
117
                                                    COL_GALVIEW_NAME, name,
 
118
                                                    COL_GALVIEW_DATA, item, 
 
119
                                                    -1);
 
120
 
 
121
                                gal_view_edit (view, GTK_WINDOW (dialog));
 
122
                                g_object_unref (view);
123
123
                        }
124
124
                }
125
 
                g_object_unref(factory);
126
 
                g_free(name);
 
125
                g_object_unref (factory);
 
126
                g_free (name);
127
127
                break;
128
128
        }
129
129
        gtk_widget_destroy (widget);
132
132
static void
133
133
gdvd_button_new_callback(GtkWidget *widget, GalDefineViewsDialog *dialog)
134
134
{
135
 
        GtkWidget *view_new_dialog = gal_view_new_dialog_new(dialog->collection);
 
135
        GtkWidget *view_new_dialog = gal_view_new_dialog_new (dialog->collection);
136
136
        gtk_window_set_transient_for (GTK_WINDOW (view_new_dialog), GTK_WINDOW (dialog));
137
 
        g_signal_connect(view_new_dialog, "response",
138
 
                         G_CALLBACK(gdvd_button_new_dialog_callback), dialog);
139
 
        gtk_widget_show(view_new_dialog);
 
137
        g_signal_connect (view_new_dialog, "response",
 
138
                         G_CALLBACK (gdvd_button_new_dialog_callback), dialog);
 
139
        gtk_widget_show (view_new_dialog);
140
140
}
141
141
 
142
142
static void
143
143
gdvd_button_modify_callback(GtkWidget *widget, GalDefineViewsDialog *dialog)
144
144
{
145
 
        int row;
146
 
        GtkWidget *scrolled;
147
 
        ETable *etable;
148
 
 
149
 
        scrolled = glade_xml_get_widget(dialog->gui, "custom-table");
150
 
        etable = e_table_scrolled_get_table(E_TABLE_SCROLLED(scrolled));
151
 
        row = e_table_get_cursor_row (E_TABLE(etable));
152
 
 
153
 
        if (row != -1) {
154
 
                GalView *view;
155
 
                view = gal_define_views_model_get_view(GAL_DEFINE_VIEWS_MODEL(dialog->model),
156
 
                                                       row);
157
 
                gal_view_edit(view, GTK_WINDOW (dialog));
 
145
        GtkTreeIter iter;
 
146
        GalViewCollectionItem *item;
 
147
 
 
148
        if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (dialog->treeview),
 
149
                                         &dialog->model,
 
150
                                         &iter)) {
 
151
                gtk_tree_model_get (dialog->model, &iter, COL_GALVIEW_DATA, &item, -1);
 
152
                gal_view_edit (item->view, GTK_WINDOW (dialog));
158
153
        }
159
154
}
160
155
 
162
157
gdvd_button_delete_callback(GtkWidget *widget, GalDefineViewsDialog *dialog)
163
158
{
164
159
        int row;
165
 
        GtkWidget *scrolled;
166
 
        ETable *etable;
167
 
 
168
 
        scrolled = glade_xml_get_widget(dialog->gui, "custom-table");
169
 
        etable = e_table_scrolled_get_table(E_TABLE_SCROLLED(scrolled));
170
 
        row = e_table_get_cursor_row (E_TABLE(etable));
171
 
 
172
 
        if (row != -1) {
173
 
                gal_define_views_model_delete_view(GAL_DEFINE_VIEWS_MODEL(dialog->model),
174
 
                                                   row);
 
160
        GtkTreeIter iter;
 
161
        GtkTreePath *path;
 
162
        GtkTreeSelection *selection;
 
163
        GalViewCollectionItem *item;
 
164
 
 
165
        selection = gtk_tree_view_get_selection (dialog->treeview);
 
166
 
 
167
        if (gtk_tree_selection_get_selected (selection,
 
168
                                         &dialog->model,
 
169
                                         &iter)) {
 
170
                gtk_tree_model_get (dialog->model, &iter, COL_GALVIEW_DATA, &item, -1);
 
171
 
 
172
                for (row=0; row<dialog->collection->view_count; row++) {
 
173
                        if (item == dialog->collection->view_data[row]) {
 
174
                                gal_view_collection_delete_view (dialog->collection, row);
 
175
                                path = gtk_tree_model_get_path (dialog->model, &iter);
 
176
                                gtk_list_store_remove (GTK_LIST_STORE (dialog->model), &iter);
 
177
                                
 
178
                                if (gtk_tree_path_prev (path)) {
 
179
                                        gtk_tree_model_get_iter (dialog->model, &iter, path);
 
180
                                } else {
 
181
                                        gtk_tree_model_get_iter_first (dialog->model, &iter);
 
182
                                }
 
183
 
 
184
                                gtk_tree_selection_select_iter (selection, &iter);
 
185
                                break;
 
186
                        }
 
187
                }
175
188
        }
176
 
 
177
189
}
178
190
 
179
191
#if 0
195
207
 
196
208
}
197
209
#endif
 
210
 
 
211
static void
 
212
gdvd_cursor_changed_callback (GtkWidget *widget, GalDefineViewsDialog *dialog)
 
213
{
 
214
        GtkWidget *button;
 
215
        GtkTreeIter iter;
 
216
        GalViewCollectionItem *item;
 
217
 
 
218
        if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (dialog->treeview),
 
219
                                         &dialog->model,
 
220
                                         &iter)) {
 
221
                gtk_tree_model_get (dialog->model, &iter, COL_GALVIEW_DATA, &item, -1);
 
222
 
 
223
                button = glade_xml_get_widget (dialog->gui, "button-delete");
 
224
                gtk_widget_set_sensitive (GTK_WIDGET (button), !item->built_in);
 
225
 
 
226
                button = glade_xml_get_widget (dialog->gui, "button-modify");
 
227
                gtk_widget_set_sensitive (GTK_WIDGET (button), !item->built_in);
 
228
        }
 
229
}
198
230
 
199
231
static void
200
232
gdvd_connect_signal(GalDefineViewsDialog *dialog, char *widget_name, char *signal, GCallback handler)
201
233
{
202
234
        GtkWidget *widget;
203
235
 
204
 
        widget = glade_xml_get_widget(dialog->gui, widget_name);
 
236
        widget = glade_xml_get_widget (dialog->gui, widget_name);
205
237
 
206
238
        if (widget)
207
 
                g_signal_connect(widget, signal, handler, dialog);
208
 
}
209
 
 
210
 
static void
211
 
etable_selection_change_forall_cb (int row, GalDefineViewsDialog *dialog)
212
 
{
213
 
        if (row != -1) {
214
 
                GalViewCollectionItem *item = gal_view_collection_get_view_item (dialog->collection, row);
215
 
 
216
 
                if (item) {
217
 
                        gtk_widget_set_sensitive (glade_xml_get_widget (dialog->gui, "button-delete"),
218
 
                                                  !item->built_in);
219
 
                        if (GAL_VIEW_GET_CLASS (item->view)->edit)
220
 
                                gtk_widget_set_sensitive (glade_xml_get_widget (dialog->gui, "button-modify"),
221
 
                                                !item->built_in);
222
 
                        else
223
 
                                gtk_widget_set_sensitive (glade_xml_get_widget (dialog->gui, "button-modify"),
224
 
                                                FALSE);
225
 
                }
226
 
        }
227
 
}
228
 
 
229
 
static void
230
 
etable_selection_change (ETable *etable, GalDefineViewsDialog *dialog)
231
 
{
232
 
        e_table_selected_row_foreach (etable, (EForeachFunc) etable_selection_change_forall_cb, dialog);
 
239
                g_signal_connect (widget, signal, handler, dialog);
233
240
}
234
241
 
235
242
static void
243
250
{
244
251
        GladeXML *gui;
245
252
        GtkWidget *widget;
246
 
        GtkWidget *etable;
 
253
 
247
254
        gchar *filename = g_build_filename (EVOLUTION_GLADEDIR,
248
255
                                            "gal-define-views.glade",
249
256
                                            NULL);
258
265
        if (!widget) {
259
266
                return;
260
267
        }
261
 
        g_object_ref(widget);
 
268
 
 
269
        g_object_ref (widget);
262
270
        gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
263
 
        gtk_window_set_default_size(GTK_WINDOW(dialog), 360, 270);
264
 
        gtk_container_set_border_width(GTK_CONTAINER(dialog), 6);
265
 
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), widget, TRUE, TRUE, 0);
 
271
        gtk_window_set_default_size (GTK_WINDOW (dialog), 360, 270);
 
272
        gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
 
273
        gtk_container_set_border_width (GTK_CONTAINER (widget), 6);
 
274
        gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), widget, TRUE, TRUE, 0);
266
275
        g_object_unref(widget);
267
276
 
268
277
        gtk_dialog_add_buttons (GTK_DIALOG (dialog),
269
278
                                GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
270
279
                                NULL);
271
280
 
 
281
        dialog->treeview = GTK_TREE_VIEW (glade_xml_get_widget (dialog->gui, "treeview1"));
 
282
        gtk_tree_view_set_reorderable (GTK_TREE_VIEW (dialog->treeview), FALSE);
 
283
        gtk_tree_view_set_headers_visible (dialog->treeview, TRUE);
 
284
 
 
285
        gtk_window_set_policy (GTK_WINDOW (dialog), FALSE, TRUE, FALSE);
 
286
 
272
287
        gdvd_connect_signal(dialog, "button-new",    "clicked", G_CALLBACK(gdvd_button_new_callback));
273
288
        gdvd_connect_signal(dialog, "button-modify", "clicked", G_CALLBACK(gdvd_button_modify_callback));
274
289
        gdvd_connect_signal(dialog, "button-delete", "clicked", G_CALLBACK(gdvd_button_delete_callback));
275
290
#if 0
276
291
        gdvd_connect_signal(dialog, "button-copy",   "clicked", G_CALLBACK(gdvd_button_copy_callback));
277
292
#endif
278
 
 
279
 
        dialog->model = NULL;
280
 
        etable = glade_xml_get_widget(dialog->gui, "custom-table");
281
 
        if (etable) {
282
 
                dialog->model = g_object_get_data(G_OBJECT (etable), "GalDefineViewsDialog::model");
283
 
                g_object_set(dialog->model,
284
 
                             "collection", dialog->collection,
285
 
                             NULL);
286
 
                g_signal_connect (e_table_scrolled_get_table (E_TABLE_SCROLLED (etable)),
287
 
                                  "selection_change",
288
 
                                  G_CALLBACK (etable_selection_change), dialog);
289
 
                gtk_widget_show_all (etable);
290
 
        }
291
 
 
292
 
        gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, TRUE, FALSE);
293
 
 
 
293
        gdvd_connect_signal(dialog, "treeview1", "cursor-changed", G_CALLBACK(gdvd_cursor_changed_callback));
294
294
        g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), NULL);
295
295
 
 
296
        gtk_widget_show (GTK_WIDGET (dialog));
296
297
}
297
298
 
298
299
static void
312
313
gal_define_views_dialog_set_collection(GalDefineViewsDialog *dialog,
313
314
                                       GalViewCollection *collection)
314
315
{
 
316
        int i;
 
317
        GtkListStore *store;
 
318
        GtkCellRenderer *renderer;
315
319
        dialog->collection = collection;
316
 
        if (dialog->model) {
317
 
                g_object_set(dialog->model,
318
 
                             "collection", collection,
319
 
                             NULL);
 
320
 
 
321
        store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
 
322
 
 
323
        for (i=0; i<collection->view_count; i++) {
 
324
                GalViewCollectionItem *item = collection->view_data[i];
 
325
                GtkTreeIter iter;
 
326
 
 
327
                /* hide built in views */
 
328
                /*if (item->built_in == 1)
 
329
                        continue;*/
 
330
        
 
331
                char *title = NULL;
 
332
                title = e_str_without_underscores (item->title);
 
333
 
 
334
                gtk_list_store_append (store, &iter);
 
335
                gtk_list_store_set (store, &iter,
 
336
                                    COL_GALVIEW_NAME, title,
 
337
                                    COL_GALVIEW_DATA, item,
 
338
                                    -1);
 
339
 
 
340
                g_free (title);
320
341
        }
 
342
 
 
343
        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
 
344
                                              COL_GALVIEW_NAME, GTK_SORT_ASCENDING);
 
345
 
 
346
        /* attaching treeview to model */
 
347
        gtk_tree_view_set_model (dialog->treeview, GTK_TREE_MODEL (store));
 
348
        gtk_tree_view_set_search_column (dialog->treeview, COL_GALVIEW_NAME);
 
349
 
 
350
        dialog->model = GTK_TREE_MODEL (store);
 
351
 
 
352
        renderer = gtk_cell_renderer_text_new ();
 
353
        gtk_tree_view_insert_column_with_attributes (dialog->treeview,
 
354
                                                    COL_GALVIEW_NAME, _("Name"),
 
355
                                                    renderer, "text", COL_GALVIEW_NAME,
 
356
                                                    NULL);
 
357
        
 
358
        /* set sort column */
 
359
        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dialog->model),
 
360
                                              COL_GALVIEW_NAME, GTK_SORT_ASCENDING);
 
361
 
321
362
        if (dialog->gui) {
322
363
                GtkWidget *widget = glade_xml_get_widget(dialog->gui, "label-views");
323
364
                if (widget && GTK_IS_LABEL (widget)) {
349
390
gal_define_views_dialog_new (GalViewCollection *collection)
350
391
{
351
392
        GtkWidget *widget = g_object_new (GAL_DEFINE_VIEWS_DIALOG_TYPE, NULL);
352
 
        gal_define_views_dialog_set_collection(GAL_DEFINE_VIEWS_DIALOG (widget), collection);
 
393
        gal_define_views_dialog_set_collection (GAL_DEFINE_VIEWS_DIALOG (widget), collection);
353
394
        return widget;
354
395
}
355
396