← Back to branch summary

~ubuntu-branches/debian/jessie/file-roller/jessie

« back to all changes in this revision

Viewing changes to src/dlg-new.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson
  • Date: 2013-05-25 13:13:26 UTC
  • mfrom: (1.8.1) (5.1.10 experimental)
  • Revision ID: package-import@ubuntu.com-20130525131326-bm7bv6b4yig6820h
Tags: 3.8.2-1
* New upstream release.
* Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dlg-new.c
1
 
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2
 
 
3
 
/*
4
 
 *  File-Roller
5
 
 *
6
 
 *  Copyright (C) 2008 Free Software Foundation, Inc.
7
 
 *
8
 
 *  This program is free software; you can redistribute it and/or modify
9
 
 *  it under the terms of the GNU General Public License as published by
10
 
 *  the Free Software Foundation; either version 2 of the License, or
11
 
 *  (at your option) any later version.
12
 
 *
13
 
 *  This program is distributed in the hope that it will be useful,
14
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
 *  GNU General Public License for more details.
17
 
 *
18
 
 *  You should have received a copy of the GNU General Public License
19
 
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
 
 */
21
 
 
22
 
#include <config.h>
23
 
#include <string.h>
24
 
#include <math.h>
25
 
#include <unistd.h>
26
 
#include <gio/gio.h>
27
 
#include "dlg-new.h"
28
 
#include "file-utils.h"
29
 
#include "fr-stock.h"
30
 
#include "gtk-utils.h"
31
 
#include "fr-init.h"
32
 
#include "preferences.h"
33
 
 
34
 
 
35
 
#define GET_WIDGET(x) (_gtk_builder_get_widget (data->builder, (x)))
36
 
#define DEFAULT_EXTENSION ".tar.gz"
37
 
#define BAD_CHARS "/\\*"
38
 
#define MEGABYTE (1024 * 1024)
39
 
 
40
 
 
41
 
/* called when the main dialog is closed. */
42
 
static void
43
 
destroy_cb (GtkWidget  *widget,
44
 
            DlgNewData *data)
45
 
{
46
 
        g_object_unref (data->builder);
47
 
        g_free (data);
48
 
}
49
 
 
50
 
 
51
 
static void
52
 
update_sensitivity (DlgNewData *data)
53
 
{
54
 
        gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->n_encrypt_header_checkbutton), ! data->can_encrypt_header);
55
 
        gtk_widget_set_sensitive (data->n_encrypt_header_checkbutton, data->can_encrypt_header);
56
 
        gtk_widget_set_sensitive (data->n_volume_spinbutton, ! data->can_create_volumes || gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->n_volume_checkbutton)));
57
 
}
58
 
 
59
 
 
60
 
static void
61
 
update_sensitivity_for_ext (DlgNewData *data,
62
 
                            const char *ext)
63
 
{
64
 
        const char *mime_type;
65
 
        int         i;
66
 
 
67
 
        data->can_encrypt = FALSE;
68
 
        data->can_encrypt_header = FALSE;
69
 
        data->can_create_volumes = FALSE;
70
 
 
71
 
        mime_type = get_mime_type_from_extension (ext);
72
 
 
73
 
        if (mime_type == NULL) {
74
 
                gtk_widget_set_sensitive (data->n_password_entry, FALSE);
75
 
                gtk_widget_set_sensitive (data->n_password_label, FALSE);
76
 
                gtk_widget_set_sensitive (data->n_encrypt_header_checkbutton, FALSE);
77
 
                gtk_widget_set_sensitive (data->n_volume_box, FALSE);
78
 
                return;
79
 
        }
80
 
 
81
 
        for (i = 0; mime_type_desc[i].mime_type != NULL; i++) {
82
 
                if (strcmp (mime_type_desc[i].mime_type, mime_type) == 0) {
83
 
                        data->can_encrypt = mime_type_desc[i].capabilities & FR_COMMAND_CAN_ENCRYPT;
84
 
                        gtk_widget_set_sensitive (data->n_password_entry, data->can_encrypt);
85
 
                        gtk_widget_set_sensitive (data->n_password_label, data->can_encrypt);
86
 
 
87
 
                        data->can_encrypt_header = mime_type_desc[i].capabilities & FR_COMMAND_CAN_ENCRYPT_HEADER;
88
 
                        gtk_widget_set_sensitive (data->n_encrypt_header_checkbutton, data->can_encrypt_header);
89
 
 
90
 
                        data->can_create_volumes = mime_type_desc[i].capabilities & FR_COMMAND_CAN_CREATE_VOLUMES;
91
 
                        gtk_widget_set_sensitive (data->n_volume_box, data->can_create_volumes);
92
 
 
93
 
                        break;
94
 
                }
95
 
        }
96
 
 
97
 
        update_sensitivity (data);
98
 
}
99
 
 
100
 
 
101
 
static int
102
 
get_archive_type (DlgNewData *data)
103
 
{
104
 
        const char *uri;
105
 
        const char *ext;
106
 
 
107
 
        uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog));
108
 
        if (uri == NULL)
109
 
                return -1;
110
 
 
111
 
        ext = get_archive_filename_extension (uri);
112
 
        if (ext == NULL) {
113
 
                int idx;
114
 
 
115
 
                idx = egg_file_format_chooser_get_format (EGG_FILE_FORMAT_CHOOSER (data->format_chooser), uri);
116
 
                /*idx = gtk_combo_box_get_active (GTK_COMBO_BOX (data->n_archive_type_combo_box)) - 1;*/
117
 
                if (idx >= 0)
118
 
                        return data->supported_types[idx];
119
 
 
120
 
                ext = DEFAULT_EXTENSION;
121
 
        }
122
 
 
123
 
        return get_mime_type_index (get_mime_type_from_extension (ext));
124
 
}
125
 
 
126
 
 
127
 
/* FIXME
128
 
static void
129
 
archive_type_combo_box_changed_cb (GtkComboBox *combo_box,
130
 
                                   DlgNewData  *data)
131
 
{
132
 
        const char *uri;
133
 
        const char *ext;
134
 
        int         idx;
135
 
 
136
 
        uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog));
137
 
 
138
 
        ext = get_archive_filename_extension (uri);
139
 
        idx = gtk_combo_box_get_active (GTK_COMBO_BOX (data->n_archive_type_combo_box)) - 1;
140
 
        if ((ext == NULL) && (idx >= 0))
141
 
                ext = mime_type_desc[data->supported_types[idx]].default_ext;
142
 
 
143
 
        update_sensitivity_for_ext (data, ext);
144
 
 
145
 
        if ((idx >= 0) && (uri != NULL)) {
146
 
                const char *new_ext;
147
 
                const char *basename;
148
 
                char       *basename_noext;
149
 
                char       *new_basename;
150
 
                char       *new_basename_uft8;
151
 
 
152
 
                new_ext = mime_type_desc[data->supported_types[idx]].default_ext;
153
 
                basename = file_name_from_path (uri);
154
 
                if (g_str_has_suffix (basename, ext))
155
 
                        basename_noext = g_strndup (basename, strlen (basename) - strlen (ext));
156
 
                else
157
 
                        basename_noext = g_strdup (basename);
158
 
                new_basename = g_strconcat (basename_noext, new_ext, NULL);
159
 
                new_basename_uft8 = g_uri_unescape_string (new_basename, NULL);
160
 
 
161
 
                gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (data->dialog), new_basename_uft8);
162
 
                update_sensitivity_for_ext (data, new_ext);
163
 
 
164
 
                g_free (new_basename_uft8);
165
 
                g_free (new_basename);
166
 
                g_free (basename_noext);
167
 
        }
168
 
}
169
 
*/
170
 
 
171
 
 
172
 
static void
173
 
password_entry_changed_cb (GtkEditable *editable,
174
 
                           gpointer     user_data)
175
 
{
176
 
        update_sensitivity ((DlgNewData *) user_data);
177
 
}
178
 
 
179
 
 
180
 
static void
181
 
volume_toggled_cb (GtkToggleButton *toggle_button,
182
 
                   gpointer         user_data)
183
 
{
184
 
        update_sensitivity ((DlgNewData *) user_data);
185
 
}
186
 
 
187
 
 
188
 
static void
189
 
format_chooser_selection_changed_cb (EggFileFormatChooser *format_chooser,
190
 
                                     DlgNewData           *data)
191
 
{
192
 
        const char *uri;
193
 
        const char *ext;
194
 
        int         n_format;
195
 
 
196
 
        uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog));
197
 
        if (uri == NULL)
198
 
                return;
199
 
 
200
 
        ext = get_archive_filename_extension (uri);
201
 
        n_format = egg_file_format_chooser_get_format (EGG_FILE_FORMAT_CHOOSER (data->format_chooser), uri);
202
 
        if (ext == NULL)
203
 
                ext = mime_type_desc[data->supported_types[n_format - 1]].default_ext;
204
 
 
205
 
        update_sensitivity_for_ext (data, ext);
206
 
 
207
 
        if (uri != NULL) {
208
 
                const char *new_ext;
209
 
                const char *basename;
210
 
                char       *basename_noext;
211
 
                char       *new_basename;
212
 
                char       *new_basename_uft8;
213
 
 
214
 
                new_ext = mime_type_desc[data->supported_types[n_format - 1]].default_ext;
215
 
                basename = file_name_from_path (uri);
216
 
                if (g_str_has_suffix (basename, ext))
217
 
                        basename_noext = g_strndup (basename, strlen (basename) - strlen (ext));
218
 
                else
219
 
                        basename_noext = g_strdup (basename);
220
 
                new_basename = g_strconcat (basename_noext, new_ext, NULL);
221
 
                new_basename_uft8 = g_uri_unescape_string (new_basename, NULL);
222
 
 
223
 
                gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (data->dialog), new_basename_uft8);
224
 
                update_sensitivity_for_ext (data, new_ext);
225
 
 
226
 
                g_free (new_basename_uft8);
227
 
                g_free (new_basename);
228
 
                g_free (basename_noext);
229
 
        }
230
 
}
231
 
 
232
 
 
233
 
static char *
234
 
get_icon_name_for_type (const char *mime_type)
235
 
{
236
 
        char *name = NULL;
237
 
 
238
 
        if (mime_type != NULL) {
239
 
                char *s;
240
 
 
241
 
                name = g_strconcat ("gnome-mime-", mime_type, NULL);
242
 
                for (s = name; *s; ++s)
243
 
                        if (! g_ascii_isalpha (*s))
244
 
                                *s = '-';
245
 
        }
246
 
 
247
 
        if ((name == NULL) || ! gtk_icon_theme_has_icon (gtk_icon_theme_get_default (), name)) {
248
 
                g_free (name);
249
 
                name = g_strdup ("package-x-generic");
250
 
        }
251
 
 
252
 
        return name;
253
 
}
254
 
 
255
 
 
256
 
static void
257
 
options_expander_unmap_cb (GtkWidget *widget,
258
 
                           gpointer   user_data)
259
 
{
260
 
        egg_file_format_chooser_emit_size_changed ((EggFileFormatChooser *) user_data);
261
 
}
262
 
 
263
 
 
264
 
static DlgNewData *
265
 
dlg_new_archive (FrWindow  *window,
266
 
                int        *supported_types,
267
 
                const char *default_name)
268
 
{
269
 
        DlgNewData    *data;
270
 
        GtkWidget     *n_new_button;
271
 
        GSettings     *settings;
272
 
        /*char          *default_ext;*/
273
 
        int            i;
274
 
 
275
 
        data = g_new0 (DlgNewData, 1);
276
 
 
277
 
        data->builder = _gtk_builder_new_from_file ("new.ui");
278
 
        if (data->builder == NULL) {
279
 
                g_free (data);
280
 
                return NULL;
281
 
        }
282
 
 
283
 
        data->window = window;
284
 
        data->supported_types = supported_types;
285
 
        sort_mime_types_by_description (data->supported_types);
286
 
 
287
 
        /* Get the widgets. */
288
 
 
289
 
        data->dialog = _gtk_builder_get_widget (data->builder, "filechooserdialog");
290
 
 
291
 
        data->n_password_entry = _gtk_builder_get_widget (data->builder, "n_password_entry");
292
 
        data->n_password_label = _gtk_builder_get_widget (data->builder, "n_password_label");
293
 
        data->n_other_options_expander = _gtk_builder_get_widget (data->builder, "n_other_options_expander");
294
 
        data->n_encrypt_header_checkbutton = _gtk_builder_get_widget (data->builder, "n_encrypt_header_checkbutton");
295
 
 
296
 
        data->n_volume_checkbutton = _gtk_builder_get_widget (data->builder, "n_volume_checkbutton");
297
 
        data->n_volume_spinbutton = _gtk_builder_get_widget (data->builder, "n_volume_spinbutton");
298
 
        data->n_volume_box = _gtk_builder_get_widget (data->builder, "n_volume_box");
299
 
 
300
 
        n_new_button = _gtk_builder_get_widget (data->builder, "n_new_button");
301
 
 
302
 
        /* Set widgets data. */
303
 
 
304
 
        gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK);
305
 
        gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (data->dialog), fr_window_get_open_default_dir (window));
306
 
 
307
 
        if (default_name != NULL)
308
 
                gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (data->dialog), default_name);
309
 
 
310
 
        /**/
311
 
 
312
 
        gtk_button_set_use_stock (GTK_BUTTON (n_new_button), TRUE);
313
 
        gtk_button_set_label (GTK_BUTTON (n_new_button), FR_STOCK_CREATE_ARCHIVE);
314
 
        gtk_expander_set_expanded (GTK_EXPANDER (data->n_other_options_expander), FALSE);
315
 
 
316
 
        settings = g_settings_new (FILE_ROLLER_SCHEMA_GENERAL);
317
 
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->n_encrypt_header_checkbutton), g_settings_get_boolean (settings, PREF_GENERAL_ENCRYPT_HEADER));
318
 
        g_object_unref (settings);
319
 
 
320
 
        settings = g_settings_new (FILE_ROLLER_SCHEMA_BATCH_ADD);
321
 
        gtk_spin_button_set_value (GTK_SPIN_BUTTON (data->n_volume_spinbutton), (double) g_settings_get_int (settings, PREF_BATCH_ADD_VOLUME_SIZE) / MEGABYTE);
322
 
        g_object_unref (settings);
323
 
 
324
 
        /* format chooser */
325
 
 
326
 
        data->format_chooser = (EggFileFormatChooser *) egg_file_format_chooser_new ();
327
 
        for (i = 0; data->supported_types[i] != -1; i++) {
328
 
                int   idx = data->supported_types[i];
329
 
                char *exts[4];
330
 
                int   e;
331
 
                int   n_exts;
332
 
                char *icon_name;
333
 
 
334
 
                n_exts = 0;
335
 
                for (e = 0; (n_exts < 4) && file_ext_type[e].ext != NULL; e++) {
336
 
                        if (strcmp (file_ext_type[e].ext, mime_type_desc[idx].default_ext) == 0)
337
 
                                continue;
338
 
                        if (strcmp (file_ext_type[e].mime_type, mime_type_desc[idx].mime_type) == 0)
339
 
                                exts[n_exts++] = file_ext_type[e].ext;
340
 
                }
341
 
                while (n_exts < 4)
342
 
                        exts[n_exts++] = NULL;
343
 
 
344
 
                /* g_print ("%s => %s, %s, %s, %s\n", mime_type_desc[idx].mime_type, exts[0], exts[1], exts[2], exts[3]); */
345
 
 
346
 
                icon_name = get_icon_name_for_type (mime_type_desc[idx].mime_type);
347
 
                egg_file_format_chooser_add_format (data->format_chooser,
348
 
                                                    0,
349
 
                                                    _(mime_type_desc[idx].name),
350
 
                                                    icon_name,
351
 
                                                    mime_type_desc[idx].default_ext,
352
 
                                                    exts[0],
353
 
                                                    exts[1],
354
 
                                                    exts[2],
355
 
                                                    exts[3],
356
 
                                                    NULL);
357
 
 
358
 
                g_free (icon_name);
359
 
        }
360
 
        egg_file_format_chooser_set_format (data->format_chooser, 0);
361
 
        gtk_widget_show (GTK_WIDGET (data->format_chooser));
362
 
        gtk_box_pack_start (GTK_BOX (GET_WIDGET ("format_chooser_box")), GTK_WIDGET (data->format_chooser), TRUE, TRUE, 0);
363
 
 
364
 
        gtk_widget_set_vexpand (GET_WIDGET ("extra_widget"), FALSE);
365
 
 
366
 
        /* Set the signals handlers. */
367
 
 
368
 
        /*g_signal_connect (G_OBJECT (data->dialog),
369
 
                          "response",
370
 
                          G_CALLBACK (new_file_response_cb),
371
 
                          data);*/
372
 
 
373
 
        g_signal_connect (G_OBJECT (data->dialog),
374
 
                          "destroy",
375
 
                          G_CALLBACK (destroy_cb),
376
 
                          data);
377
 
 
378
 
        /*
379
 
        g_signal_connect_swapped (G_OBJECT (cancel_button),
380
 
                                  "clicked",
381
 
                                  G_CALLBACK (gtk_widget_destroy),
382
 
                                  G_OBJECT (data->dialog));
383
 
        g_signal_connect (G_OBJECT (add_button),
384
 
                          "clicked",
385
 
                          G_CALLBACK (add_clicked_cb),
386
 
                          data);*/
387
 
 
388
 
        /* FIXME g_signal_connect (G_OBJECT (data->n_archive_type_combo_box),
389
 
                          "changed",
390
 
                          G_CALLBACK (archive_type_combo_box_changed_cb),
391
 
                          data); */
392
 
        g_signal_connect (G_OBJECT (data->n_password_entry),
393
 
                          "changed",
394
 
                          G_CALLBACK (password_entry_changed_cb),
395
 
                          data);
396
 
        g_signal_connect (G_OBJECT (data->n_volume_checkbutton),
397
 
                          "toggled",
398
 
                          G_CALLBACK (volume_toggled_cb),
399
 
                          data);
400
 
        g_signal_connect (G_OBJECT (data->format_chooser),
401
 
                          "selection-changed",
402
 
                          G_CALLBACK (format_chooser_selection_changed_cb),
403
 
                          data);
404
 
        g_signal_connect_after (GET_WIDGET ("other_oprtions_alignment"),
405
 
                                "unmap",
406
 
                                G_CALLBACK (options_expander_unmap_cb),
407
 
                                data->format_chooser);
408
 
 
409
 
        /* Run dialog. */
410
 
 
411
 
        update_sensitivity (data);
412
 
 
413
 
        gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE);
414
 
        gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (data->window));
415
 
        /*gtk_window_present (GTK_WINDOW (data->dialog));*/
416
 
 
417
 
        return data;
418
 
}
419
 
 
420
 
 
421
 
DlgNewData *
422
 
dlg_new (FrWindow *window)
423
 
{
424
 
        DlgNewData *data;
425
 
 
426
 
        data = dlg_new_archive (window, create_type, NULL);
427
 
        gtk_window_set_title (GTK_WINDOW (data->dialog), C_("File", "New"));
428
 
 
429
 
        return data;
430
 
}
431
 
 
432
 
 
433
 
DlgNewData *
434
 
dlg_save_as (FrWindow   *window,
435
 
             const char *default_name)
436
 
{
437
 
        DlgNewData *data;
438
 
 
439
 
        data = dlg_new_archive (window, save_type, default_name);
440
 
        gtk_window_set_title (GTK_WINDOW (data->dialog), C_("File", "Save"));
441
 
 
442
 
        return data;
443
 
}
444
 
 
445
 
 
446
 
const char *
447
 
dlg_new_data_get_password (DlgNewData *data)
448
 
{
449
 
        const char *password = NULL;
450
 
        int         idx;
451
 
 
452
 
        idx = get_archive_type (data);
453
 
        if (idx < 0)
454
 
                return NULL;
455
 
 
456
 
        if (mime_type_desc[idx].capabilities & FR_COMMAND_CAN_ENCRYPT)
457
 
                password = (char*) gtk_entry_get_text (GTK_ENTRY (data->n_password_entry));
458
 
 
459
 
        return password;
460
 
}
461
 
 
462
 
 
463
 
gboolean
464
 
dlg_new_data_get_encrypt_header (DlgNewData *data)
465
 
{
466
 
        gboolean encrypt_header = FALSE;
467
 
        int      idx;
468
 
 
469
 
        idx = get_archive_type (data);
470
 
        if (idx < 0)
471
 
                return FALSE;
472
 
 
473
 
        if (mime_type_desc[idx].capabilities & FR_COMMAND_CAN_ENCRYPT) {
474
 
                const char *password = gtk_entry_get_text (GTK_ENTRY (data->n_password_entry));
475
 
                if (password != NULL) {
476
 
                        if (strcmp (password, "") != 0) {
477
 
                                if (mime_type_desc[idx].capabilities & FR_COMMAND_CAN_ENCRYPT_HEADER)
478
 
                                        encrypt_header = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->n_encrypt_header_checkbutton));
479
 
                        }
480
 
                }
481
 
        }
482
 
 
483
 
        return encrypt_header;
484
 
}
485
 
 
486
 
 
487
 
int
488
 
dlg_new_data_get_volume_size (DlgNewData *data)
489
 
{
490
 
        guint volume_size = 0;
491
 
        int   idx;
492
 
 
493
 
        idx = get_archive_type (data);
494
 
        if (idx < 0)
495
 
                return 0;
496
 
 
497
 
        if ((mime_type_desc[idx].capabilities & FR_COMMAND_CAN_CREATE_VOLUMES)
498
 
            && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->n_volume_checkbutton)))
499
 
        {
500
 
                double value;
501
 
 
502
 
                value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (data->n_volume_spinbutton));
503
 
                volume_size = floor (value * MEGABYTE);
504
 
 
505
 
        }
506
 
 
507
 
        return volume_size;
508
 
}