Mercurial > geeqie
annotate src/utilops.c @ 1685:47b191b77e07
Revert "Add pgettext for some ambiguous strings"
Now there should be all ambiguous strings gone. This reverts commit 1628
With that commit also all ambiguous strings should be solved.
author | mow |
---|---|
date | Tue, 30 Jun 2009 19:53:55 +0000 |
parents | 349ebc02b8e2 |
children | 0e235874877e |
rev | line source |
---|---|
1 | 1 /* |
196 | 2 * Geeqie |
67
f63ecca6c087
Fri Oct 13 05:22:43 2006 John Ellis <johne@verizon.net>
gqview
parents:
66
diff
changeset
|
3 * (C) 2006 John Ellis |
1284 | 4 * Copyright (C) 2008 - 2009 The Geeqie Team |
1 | 5 * |
6 * Author: John Ellis | |
7 * | |
9 | 8 * This software is released under the GNU General Public License (GNU GPL). |
9 * Please read the included file COPYING for more information. | |
10 * This software comes with no warranty of any kind, use at your own risk! | |
1 | 11 */ |
12 | |
9 | 13 |
281 | 14 #include "main.h" |
9 | 15 #include "utilops.h" |
16 | |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
17 #include "cache.h" |
9 | 18 #include "cache_maint.h" |
19 #include "collect.h" | |
20 #include "dupe.h" | |
586 | 21 #include "filedata.h" |
22 #include "filefilter.h" | |
9 | 23 #include "image.h" |
24 #include "img-view.h" | |
25 #include "layout.h" | |
26 #include "search.h" | |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
27 #include "thumb_standard.h" |
597 | 28 #include "trash.h" |
9 | 29 #include "ui_bookmark.h" |
30 #include "ui_fileops.h" | |
31 #include "ui_misc.h" | |
32 #include "ui_tabcomp.h" | |
140 | 33 #include "editors.h" |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
34 #include "metadata.h" |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
35 #include "exif.h" |
9 | 36 |
1594 | 37 #define DIALOG_WIDTH 750 |
38 | |
39 | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
40 static GdkPixbuf *file_util_get_error_icon(FileData *fd, GtkWidget *widget); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
41 |
9 | 42 /* |
43 *-------------------------------------------------------------------------- | |
44 * Adds 1 or 2 images (if 2, side by side) to a GenericDialog | |
45 *-------------------------------------------------------------------------- | |
46 */ | |
47 | |
48 #define DIALOG_DEF_IMAGE_DIM_X 200 | |
49 #define DIALOG_DEF_IMAGE_DIM_Y 150 | |
50 | |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
51 static void generic_dialog_add_image(GenericDialog *gd, GtkWidget *box, |
138 | 52 FileData *fd1, const gchar *header1, |
53 FileData *fd2, const gchar *header2, | |
1452 | 54 gboolean show_filename) |
9 | 55 { |
56 ImageWindow *imd; | |
57 GtkWidget *hbox = NULL; | |
58 GtkWidget *vbox; | |
59 GtkWidget *label = NULL; | |
60 | |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
61 if (!box) box = gd->vbox; |
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
62 |
138 | 63 if (fd2) |
9 | 64 { |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
65 hbox = pref_box_new(box, TRUE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE); |
9 | 66 } |
67 | |
68 /* image 1 */ | |
69 | |
70 vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP); | |
71 if (hbox) | |
72 { | |
73 GtkWidget *sep; | |
74 | |
75 gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0); | |
76 | |
77 sep = gtk_vseparator_new(); | |
78 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0); | |
79 gtk_widget_show(sep); | |
80 } | |
81 else | |
82 { | |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
83 gtk_box_pack_start(GTK_BOX(box), vbox, TRUE, TRUE, PREF_PAD_GAP); |
9 | 84 } |
85 gtk_widget_show(vbox); | |
86 | |
87 if (header1) | |
88 { | |
89 GtkWidget *head; | |
90 | |
91 head = pref_label_new(vbox, header1); | |
92 pref_label_bold(head, TRUE, FALSE); | |
93 gtk_misc_set_alignment(GTK_MISC(head), 0.0, 0.5); | |
94 } | |
95 | |
96 imd = image_new(FALSE); | |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
97 g_object_set(G_OBJECT(imd->pr), "zoom_expand", FALSE, NULL); |
9 | 98 gtk_widget_set_size_request(imd->widget, DIALOG_DEF_IMAGE_DIM_X, DIALOG_DEF_IMAGE_DIM_Y); |
99 gtk_box_pack_start(GTK_BOX(vbox), imd->widget, TRUE, TRUE, 0); | |
138 | 100 image_change_fd(imd, fd1, 0.0); |
9 | 101 gtk_widget_show(imd->widget); |
102 | |
103 if (show_filename) | |
104 { | |
138 | 105 label = pref_label_new(vbox, (fd1 == NULL) ? "" : fd1->name); |
9 | 106 } |
107 | |
108 /* only the first image is stored (for use in gd_image_set) */ | |
109 g_object_set_data(G_OBJECT(gd->dialog), "img_image", imd); | |
110 g_object_set_data(G_OBJECT(gd->dialog), "img_label", label); | |
442 | 111 |
9 | 112 |
113 /* image 2 */ | |
114 | |
138 | 115 if (hbox && fd2) |
9 | 116 { |
117 vbox = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP); | |
118 | |
119 if (header2) | |
120 { | |
121 GtkWidget *head; | |
122 | |
123 head = pref_label_new(vbox, header2); | |
124 pref_label_bold(head, TRUE, FALSE); | |
125 gtk_misc_set_alignment(GTK_MISC(head), 0.0, 0.5); | |
126 } | |
127 | |
128 imd = image_new(FALSE); | |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
129 g_object_set(G_OBJECT(imd->pr), "zoom_expand", FALSE, NULL); |
9 | 130 gtk_widget_set_size_request(imd->widget, DIALOG_DEF_IMAGE_DIM_X, DIALOG_DEF_IMAGE_DIM_Y); |
131 gtk_box_pack_start(GTK_BOX(vbox), imd->widget, TRUE, TRUE, 0); | |
138 | 132 image_change_fd(imd, fd2, 0.0); |
9 | 133 gtk_widget_show(imd->widget); |
134 | |
138 | 135 pref_label_new(vbox, fd2->name); |
9 | 136 } |
137 } | |
138 | |
138 | 139 static void generic_dialog_image_set(GenericDialog *gd, FileData *fd) |
9 | 140 { |
141 ImageWindow *imd; | |
142 GtkWidget *label; | |
442 | 143 |
9 | 144 imd = g_object_get_data(G_OBJECT(gd->dialog), "img_image"); |
145 label = g_object_get_data(G_OBJECT(gd->dialog), "img_label"); | |
146 | |
147 if (!imd) return; | |
148 | |
138 | 149 image_change_fd(imd, fd, 0.0); |
150 if (label) gtk_label_set_text(GTK_LABEL(label), fd->name); | |
9 | 151 } |
152 | |
153 /* | |
154 *-------------------------------------------------------------------------- | |
155 * Wrappers to aid in setting additional dialog properties (unde mouse, etc.) | |
156 *-------------------------------------------------------------------------- | |
157 */ | |
158 | |
159 GenericDialog *file_util_gen_dlg(const gchar *title, | |
1175
2518a4a73d89
Rename wmsubclass and name to role, which corresponds better to the purpose of the parameter as it ends to be passed to gtk_window_set_role().
zas_
parents:
1174
diff
changeset
|
160 const gchar *role, |
1452 | 161 GtkWidget *parent, gboolean auto_close, |
9 | 162 void (*cancel_cb)(GenericDialog *, gpointer), gpointer data) |
163 { | |
164 GenericDialog *gd; | |
165 | |
1175
2518a4a73d89
Rename wmsubclass and name to role, which corresponds better to the purpose of the parameter as it ends to be passed to gtk_window_set_role().
zas_
parents:
1174
diff
changeset
|
166 gd = generic_dialog_new(title, role, parent, auto_close, cancel_cb, data); |
318 | 167 if (options->place_dialogs_under_mouse) |
9 | 168 { |
169 gtk_window_set_position(GTK_WINDOW(gd->dialog), GTK_WIN_POS_MOUSE); | |
170 } | |
171 | |
172 return gd; | |
173 } | |
174 | |
175 FileDialog *file_util_file_dlg(const gchar *title, | |
1175
2518a4a73d89
Rename wmsubclass and name to role, which corresponds better to the purpose of the parameter as it ends to be passed to gtk_window_set_role().
zas_
parents:
1174
diff
changeset
|
176 const gchar *role, |
9 | 177 GtkWidget *parent, |
178 void (*cancel_cb)(FileDialog *, gpointer), gpointer data) | |
179 { | |
138 | 180 FileDialog *fdlg; |
181 | |
1175
2518a4a73d89
Rename wmsubclass and name to role, which corresponds better to the purpose of the parameter as it ends to be passed to gtk_window_set_role().
zas_
parents:
1174
diff
changeset
|
182 fdlg = file_dialog_new(title, role, parent, cancel_cb, data); |
318 | 183 if (options->place_dialogs_under_mouse) |
9 | 184 { |
138 | 185 gtk_window_set_position(GTK_WINDOW(GENERIC_DIALOG(fdlg)->dialog), GTK_WIN_POS_MOUSE); |
9 | 186 } |
187 | |
138 | 188 return fdlg; |
9 | 189 } |
190 | |
191 /* this warning dialog is copied from SLIK's ui_utildg.c, | |
192 * because it does not have a mouse center option, | |
193 * and we must center it before show, implement it here. | |
194 */ | |
195 static void file_util_warning_dialog_ok_cb(GenericDialog *gd, gpointer data) | |
196 { | |
197 /* no op */ | |
198 } | |
199 | |
200 GenericDialog *file_util_warning_dialog(const gchar *heading, const gchar *message, | |
201 const gchar *icon_stock_id, GtkWidget *parent) | |
202 { | |
203 GenericDialog *gd; | |
204 | |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
205 gd = file_util_gen_dlg(heading, "warning", parent, TRUE, NULL, NULL); |
9 | 206 generic_dialog_add_message(gd, icon_stock_id, heading, message); |
207 generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, file_util_warning_dialog_ok_cb, TRUE); | |
318 | 208 if (options->place_dialogs_under_mouse) |
9 | 209 { |
210 gtk_window_set_position(GTK_WINDOW(gd->dialog), GTK_WIN_POS_MOUSE); | |
211 } | |
212 gtk_widget_show(gd->dialog); | |
213 | |
214 return gd; | |
215 } | |
1 | 216 |
42
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
217 static gint filename_base_length(const gchar *name) |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
218 { |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
219 gint n; |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
220 |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
221 if (!name) return 0; |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
222 |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
223 n = strlen(name); |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
224 |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
225 if (filter_name_exists(name)) |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
226 { |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
227 const gchar *ext; |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
228 |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
229 ext = extension_from_path(name); |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
230 if (ext) n -= strlen(ext); |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
231 } |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
232 |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
233 return n; |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
234 } |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
235 |
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
236 |
753 | 237 |
140 | 238 |
753 | 239 typedef enum { |
240 UTILITY_TYPE_COPY, | |
241 UTILITY_TYPE_MOVE, | |
242 UTILITY_TYPE_RENAME, | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
243 UTILITY_TYPE_RENAME_FOLDER, |
753 | 244 UTILITY_TYPE_EDITOR, |
245 UTILITY_TYPE_FILTER, | |
246 UTILITY_TYPE_DELETE, | |
247 UTILITY_TYPE_DELETE_LINK, | |
901 | 248 UTILITY_TYPE_DELETE_FOLDER, |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
249 UTILITY_TYPE_CREATE_FOLDER, |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
250 UTILITY_TYPE_WRITE_METADATA |
753 | 251 } UtilityType; |
252 | |
253 typedef enum { | |
254 UTILITY_PHASE_START = 0, | |
255 UTILITY_PHASE_ENTERING, | |
256 UTILITY_PHASE_CHECKED, | |
257 UTILITY_PHASE_DONE, | |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
258 UTILITY_PHASE_CANCEL, |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
259 UTILITY_PHASE_DISCARD |
753 | 260 } UtilityPhase; |
261 | |
262 enum { | |
263 UTILITY_RENAME = 0, | |
264 UTILITY_RENAME_AUTO, | |
265 UTILITY_RENAME_FORMATTED | |
266 }; | |
267 | |
268 typedef struct _UtilityDataMessages UtilityDataMessages; | |
269 struct _UtilityDataMessages { | |
270 gchar *title; | |
271 gchar *question; | |
272 gchar *desc_flist; | |
273 gchar *desc_source_fd; | |
274 gchar *fail; | |
275 }; | |
276 | |
277 typedef struct _UtilityData UtilityData; | |
278 | |
279 struct _UtilityData { | |
280 UtilityType type; | |
281 UtilityPhase phase; | |
282 | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
283 FileData *dir_fd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
284 GList *content_list; |
753 | 285 GList *flist; |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
286 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
287 FileData *sel_fd; |
753 | 288 |
289 GtkWidget *parent; | |
290 GenericDialog *gd; | |
291 FileDialog *fdlg; | |
292 | |
1523 | 293 guint update_idle_id; /* event source id */ |
294 guint perform_idle_id; /* event source id */ | |
1221 | 295 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
296 gboolean with_sidecars; /* operate on grouped or single files; TRUE = use file_data_sc_, FALSE = use file_data_ functions */ |
753 | 297 |
298 /* alternative dialog parts */ | |
299 GtkWidget *notebook; | |
300 | |
301 UtilityDataMessages messages; | |
302 | |
303 /* helper entries for various modes */ | |
304 GtkWidget *rename_entry; | |
305 GtkWidget *rename_label; | |
306 GtkWidget *auto_entry_front; | |
307 GtkWidget *auto_entry_end; | |
308 GtkWidget *auto_spin_start; | |
309 GtkWidget *auto_spin_pad; | |
310 GtkWidget *format_entry; | |
311 GtkWidget *format_spin; | |
312 | |
313 GtkWidget *listview; | |
314 | |
315 | |
316 gchar *dest_path; | |
317 | |
318 /* data for the operation itself, internal or external */ | |
755 | 319 gboolean external; /* TRUE for external command, FALSE for internal */ |
753 | 320 |
1272 | 321 gchar *external_command; |
753 | 322 gpointer resume_data; |
1231 | 323 |
324 FileUtilDoneFunc done_func; | |
1563 | 325 void (*details_func)(UtilityData *ud, FileData *fd); |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
326 gboolean (*finalize_func)(FileData *fd); |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
327 gboolean (*discard_func)(FileData *fd); |
1231 | 328 gpointer done_data; |
753 | 329 }; |
330 | |
331 enum { | |
332 UTILITY_COLUMN_FD = 0, | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
333 UTILITY_COLUMN_PIXBUF, |
753 | 334 UTILITY_COLUMN_PATH, |
335 UTILITY_COLUMN_NAME, | |
336 UTILITY_COLUMN_SIDECARS, | |
337 UTILITY_COLUMN_DEST_PATH, | |
338 UTILITY_COLUMN_DEST_NAME, | |
339 UTILITY_COLUMN_COUNT | |
340 }; | |
341 | |
342 #define UTILITY_LIST_MIN_WIDTH 250 | |
343 #define UTILITY_LIST_MIN_HEIGHT 150 | |
344 | |
345 /* thumbnail spec has a max depth of 4 (.thumb??/fail/appname/??.png) */ | |
346 #define UTILITY_DELETE_MAX_DEPTH 5 | |
347 | |
348 static UtilityData *file_util_data_new(UtilityType type) | |
136 | 349 { |
753 | 350 UtilityData *ud; |
351 | |
352 ud = g_new0(UtilityData, 1); | |
1367
fe4da037be21
When g_new0() is used, drop redundant initializations to NULL, FALSE or 0, second pass.
zas_
parents:
1289
diff
changeset
|
353 |
753 | 354 ud->type = type; |
355 ud->phase = UTILITY_PHASE_START; | |
1367
fe4da037be21
When g_new0() is used, drop redundant initializations to NULL, FALSE or 0, second pass.
zas_
parents:
1289
diff
changeset
|
356 |
753 | 357 return ud; |
358 } | |
359 | |
360 static void file_util_data_free(UtilityData *ud) | |
361 { | |
362 if (!ud) return; | |
363 | |
1523 | 364 if (ud->update_idle_id) g_source_remove(ud->update_idle_id); |
365 if (ud->perform_idle_id) g_source_remove(ud->perform_idle_id); | |
753 | 366 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
367 file_data_unref(ud->dir_fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
368 filelist_free(ud->content_list); |
753 | 369 filelist_free(ud->flist); |
370 | |
371 if (ud->gd) generic_dialog_close(ud->gd); | |
372 | |
373 g_free(ud->dest_path); | |
1272 | 374 g_free(ud->external_command); |
753 | 375 |
376 g_free(ud); | |
377 } | |
378 | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
379 static GtkTreeViewColumn *file_util_dialog_add_list_column(GtkWidget *view, const gchar *text, gboolean image, gint n) |
753 | 380 { |
381 GtkTreeViewColumn *column; | |
382 GtkCellRenderer *renderer; | |
383 | |
384 column = gtk_tree_view_column_new(); | |
385 gtk_tree_view_column_set_title(column, text); | |
386 gtk_tree_view_column_set_min_width(column, 4); | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
387 if (image) |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
388 { |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
389 gtk_tree_view_column_set_min_width(column, 20); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
390 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
391 renderer = gtk_cell_renderer_pixbuf_new(); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
392 gtk_tree_view_column_pack_start(column, renderer, TRUE); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
393 gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", n); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
394 } |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
395 else |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
396 { |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
397 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
398 renderer = gtk_cell_renderer_text_new(); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
399 gtk_tree_view_column_pack_start(column, renderer, TRUE); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
400 gtk_tree_view_column_add_attribute(column, renderer, "text", n); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
401 } |
753 | 402 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column); |
403 | |
404 return column; | |
405 } | |
406 | |
407 static void file_util_dialog_list_select(GtkWidget *view, gint n) | |
408 { | |
409 GtkTreeModel *store; | |
410 GtkTreeIter iter; | |
411 GtkTreeSelection *selection; | |
412 | |
413 store = gtk_tree_view_get_model(GTK_TREE_VIEW(view)); | |
414 if (gtk_tree_model_iter_nth_child(store, &iter, NULL, n)) | |
140 | 415 { |
753 | 416 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); |
417 gtk_tree_selection_select_iter(selection, &iter); | |
418 } | |
419 } | |
420 | |
1452 | 421 static GtkWidget *file_util_dialog_add_list(GtkWidget *box, GList *list, gboolean full_paths, gboolean with_sidecars) |
753 | 422 { |
423 GtkWidget *scrolled; | |
424 GtkWidget *view; | |
425 GtkListStore *store; | |
426 | |
427 scrolled = gtk_scrolled_window_new(NULL, NULL); | |
428 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); | |
429 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), | |
430 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); | |
431 gtk_box_pack_start(GTK_BOX(box), scrolled, TRUE, TRUE, 0); | |
432 gtk_widget_show(scrolled); | |
433 | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
434 store = gtk_list_store_new(UTILITY_COLUMN_COUNT, G_TYPE_POINTER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); |
753 | 435 view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); |
436 g_object_unref(store); | |
437 | |
438 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), TRUE); | |
439 gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view), FALSE); | |
440 | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
441 file_util_dialog_add_list_column(view, "", TRUE, UTILITY_COLUMN_PIXBUF); |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
442 |
753 | 443 if (full_paths) |
444 { | |
1685 | 445 file_util_dialog_add_list_column(view, _("Path"), FALSE, UTILITY_COLUMN_PATH); |
140 | 446 } |
138 | 447 else |
448 { | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
449 file_util_dialog_add_list_column(view, _("Name"), FALSE, UTILITY_COLUMN_NAME); |
138 | 450 } |
451 | |
753 | 452 gtk_widget_set_size_request(view, UTILITY_LIST_MIN_WIDTH, UTILITY_LIST_MIN_HEIGHT); |
453 gtk_container_add(GTK_CONTAINER(scrolled), view); | |
454 gtk_widget_show(view); | |
136 | 455 |
140 | 456 while (list) |
457 { | |
458 FileData *fd = list->data; | |
753 | 459 GtkTreeIter iter; |
460 gchar *sidecars; | |
461 | |
1211 | 462 sidecars = with_sidecars ? file_data_sc_list_to_string(fd) : NULL; |
1224 | 463 GdkPixbuf *icon = file_util_get_error_icon(fd, view); |
753 | 464 gtk_list_store_append(store, &iter); |
757 | 465 gtk_list_store_set(store, &iter, |
466 UTILITY_COLUMN_FD, fd, | |
1224 | 467 UTILITY_COLUMN_PIXBUF, icon, |
757 | 468 UTILITY_COLUMN_PATH, fd->path, |
469 UTILITY_COLUMN_NAME, fd->name, | |
470 UTILITY_COLUMN_SIDECARS, sidecars, | |
471 UTILITY_COLUMN_DEST_PATH, fd->change ? fd->change->dest : "error", | |
472 UTILITY_COLUMN_DEST_NAME, fd->change ? filename_from_path(fd->change->dest) : "error", | |
473 -1); | |
753 | 474 g_free(sidecars); |
475 | |
140 | 476 list = list->next; |
477 } | |
753 | 478 |
479 return view; | |
480 } | |
481 | |
482 | |
1221 | 483 static gboolean file_util_perform_ci_internal(gpointer data); |
753 | 484 void file_util_dialog_run(UtilityData *ud); |
1405 | 485 static gint file_util_perform_ci_cb(gpointer resume_data, EditorFlags flags, GList *list, gpointer data); |
753 | 486 |
487 /* call file_util_perform_ci_internal or start_editor_from_filelist_full */ | |
488 | |
489 | |
490 static void file_util_resume_cb(GenericDialog *gd, gpointer data) | |
491 { | |
492 UtilityData *ud = data; | |
493 if (ud->external) | |
494 editor_resume(ud->resume_data); | |
495 else | |
496 file_util_perform_ci_internal(ud); | |
497 } | |
498 | |
499 static void file_util_abort_cb(GenericDialog *gd, gpointer data) | |
500 { | |
501 UtilityData *ud = data; | |
502 if (ud->external) | |
503 editor_skip(ud->resume_data); | |
504 else | |
505 file_util_perform_ci_cb(NULL, EDITOR_ERROR_SKIPPED, ud->flist, ud); | |
140 | 506 |
507 } | |
508 | |
509 | |
1405 | 510 static gint file_util_perform_ci_cb(gpointer resume_data, EditorFlags flags, GList *list, gpointer data) |
1 | 511 { |
753 | 512 UtilityData *ud = data; |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1367
diff
changeset
|
513 gint ret = EDITOR_CB_CONTINUE; |
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1367
diff
changeset
|
514 |
753 | 515 ud->resume_data = resume_data; |
497 | 516 |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1367
diff
changeset
|
517 if (EDITOR_ERRORS_BUT_SKIPPED(flags)) |
140 | 518 { |
757 | 519 GString *msg = g_string_new(editor_get_error_str(flags)); |
520 GenericDialog *d; | |
521 g_string_append(msg, "\n"); | |
522 g_string_append(msg, ud->messages.fail); | |
523 g_string_append(msg, "\n"); | |
524 while (list) | |
525 { | |
526 FileData *fd = list->data; | |
442 | 527 |
757 | 528 g_string_append(msg, fd->path); |
529 g_string_append(msg, "\n"); | |
530 list = list->next; | |
531 } | |
532 if (resume_data) | |
533 { | |
534 g_string_append(msg, _("\n Continue multiple file operation?")); | |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
535 d = file_util_gen_dlg(ud->messages.fail, "dlg_confirm", |
757 | 536 NULL, TRUE, |
537 file_util_abort_cb, ud); | |
140 | 538 |
757 | 539 generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, NULL, msg->str); |
140 | 540 |
757 | 541 generic_dialog_add_button(d, GTK_STOCK_GO_FORWARD, _("Co_ntinue"), |
542 file_util_resume_cb, TRUE); | |
543 gtk_widget_show(d->dialog); | |
544 ret = EDITOR_CB_SUSPEND; | |
545 } | |
546 else | |
547 { | |
548 file_util_warning_dialog(ud->messages.fail, msg->str, GTK_STOCK_DIALOG_ERROR, NULL); | |
549 } | |
550 g_string_free(msg, TRUE); | |
140 | 551 } |
442 | 552 |
553 | |
753 | 554 while (list) /* be careful, file_util_perform_ci_internal can pass ud->flist as list */ |
140 | 555 { |
753 | 556 FileData *fd = list->data; |
995 | 557 list = list->next; |
753 | 558 |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1367
diff
changeset
|
559 if (!EDITOR_ERRORS(flags)) /* files were successfully deleted, call the maint functions */ |
761 | 560 { |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
561 if (ud->with_sidecars) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
562 file_data_sc_apply_ci(fd); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
563 else |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
564 file_data_apply_ci(fd); |
761 | 565 } |
753 | 566 |
567 ud->flist = g_list_remove(ud->flist, fd); | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
568 |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
569 if (ud->finalize_func) |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
570 { |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
571 ud->finalize_func(fd); |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
572 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
573 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
574 if (ud->with_sidecars) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
575 file_data_sc_free_ci(fd); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
576 else |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
577 file_data_free_ci(fd); |
753 | 578 file_data_unref(fd); |
140 | 579 } |
753 | 580 |
581 if (!resume_data) /* end of the list */ | |
582 { | |
583 ud->phase = UTILITY_PHASE_DONE; | |
584 file_util_dialog_run(ud); | |
585 } | |
586 | |
140 | 587 return ret; |
588 } | |
589 | |
143
0d1bf3ac6cd8
improved FileDataChangeInfo structure, check for another file operation in progress
nadvornik
parents:
140
diff
changeset
|
590 |
753 | 591 /* |
756 | 592 * Perform the operation described by FileDataChangeInfo on all files in the list |
753 | 593 * it is an alternative to start_editor_from_filelist_full, it should use similar interface |
995 | 594 */ |
143
0d1bf3ac6cd8
improved FileDataChangeInfo structure, check for another file operation in progress
nadvornik
parents:
140
diff
changeset
|
595 |
1 | 596 |
1221 | 597 static gboolean file_util_perform_ci_internal(gpointer data) |
753 | 598 { |
1221 | 599 UtilityData *ud = data; |
600 | |
1523 | 601 if (!ud->perform_idle_id) |
1289
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
602 { |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
603 /* this function was called directly |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
604 just setup idle callback and wait until we are called again |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
605 */ |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
606 |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
607 /* this is removed when ud is destroyed */ |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
608 ud->perform_idle_id = g_idle_add(file_util_perform_ci_internal, ud); |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
609 return TRUE; |
deb0876c29d2
force at least one idle call before writting metadata
nadvornik
parents:
1284
diff
changeset
|
610 } |
1221 | 611 |
612 g_assert(ud->flist); | |
753 | 613 |
1221 | 614 if (ud->flist) |
1 | 615 { |
753 | 616 gint ret; |
617 | |
618 /* take a single entry each time, this allows better control over the operation */ | |
619 GList *single_entry = g_list_append(NULL, ud->flist->data); | |
620 gboolean last = !ud->flist->next; | |
1405 | 621 EditorFlags status = EDITOR_ERROR_STATUS; |
757 | 622 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
623 if (ud->with_sidecars ? file_data_sc_perform_ci(single_entry->data) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
624 : file_data_perform_ci(single_entry->data)) |
757 | 625 status = 0; /* OK */ |
626 | |
627 ret = file_util_perform_ci_cb(GINT_TO_POINTER(!last), status, single_entry, ud); | |
753 | 628 g_list_free(single_entry); |
629 | |
1221 | 630 if (ret == EDITOR_CB_SUSPEND || last) return FALSE; |
753 | 631 |
632 if (ret == EDITOR_CB_SKIP) | |
633 { | |
634 file_util_perform_ci_cb(NULL, EDITOR_ERROR_SKIPPED, ud->flist, ud); | |
1221 | 635 return FALSE; |
753 | 636 } |
1 | 637 } |
1221 | 638 |
639 return TRUE; | |
1 | 640 } |
641 | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
642 static void file_util_perform_ci_dir(UtilityData *ud, gboolean internal, gboolean ext_result) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
643 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
644 switch (ud->type) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
645 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
646 case UTILITY_TYPE_DELETE_LINK: |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
647 { |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
648 g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
649 if ((internal && file_data_perform_ci(ud->dir_fd)) || |
897 | 650 (!internal && ext_result)) |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
651 { |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
652 file_data_apply_ci(ud->dir_fd); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
653 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
654 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
655 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
656 gchar *text; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
657 |
901 | 658 text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path); |
659 file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL); | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
660 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
661 } |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
662 file_data_free_ci(ud->dir_fd); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
663 break; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
664 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
665 case UTILITY_TYPE_DELETE_FOLDER: |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
666 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
667 FileData *fail = NULL; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
668 GList *work; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
669 work = ud->content_list; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
670 while (work) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
671 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
672 FileData *fd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
673 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
674 fd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
675 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
676 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
677 if (!fail) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
678 { |
897 | 679 if ((internal && file_data_sc_perform_ci(fd)) || |
680 (!internal && ext_result)) | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
681 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
682 file_data_sc_apply_ci(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
683 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
684 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
685 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
686 if (internal) fail = file_data_ref(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
687 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
688 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
689 file_data_sc_free_ci(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
690 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
691 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
692 if (!fail) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
693 { |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
694 g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars |
897 | 695 if ((internal && file_data_sc_perform_ci(ud->dir_fd)) || |
696 (!internal && ext_result)) | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
697 { |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
698 file_data_apply_ci(ud->dir_fd); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
699 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
700 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
701 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
702 fail = file_data_ref(ud->dir_fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
703 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
704 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
705 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
706 if (fail) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
707 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
708 gchar *text; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
709 GenericDialog *gd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
710 |
901 | 711 text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path); |
712 gd = file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL); | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
713 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
714 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
715 if (fail != ud->dir_fd) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
716 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
717 pref_spacer(gd->vbox, PREF_PAD_GROUP); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
718 text = g_strdup_printf(_("Removal of folder contents failed at this file:\n\n%s"), |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
719 fail->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
720 pref_label_new(gd->vbox, text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
721 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
722 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
723 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
724 file_data_unref(fail); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
725 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
726 break; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
727 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
728 case UTILITY_TYPE_RENAME_FOLDER: |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
729 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
730 FileData *fail = NULL; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
731 GList *work; |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
732 g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
733 |
897 | 734 if ((internal && file_data_sc_perform_ci(ud->dir_fd)) || |
735 (!internal && ext_result)) | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
736 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
737 file_data_sc_apply_ci(ud->dir_fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
738 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
739 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
740 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
741 fail = file_data_ref(ud->dir_fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
742 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
743 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
744 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
745 work = ud->content_list; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
746 while (work) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
747 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
748 FileData *fd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
749 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
750 fd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
751 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
752 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
753 if (!fail) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
754 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
755 file_data_sc_apply_ci(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
756 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
757 file_data_sc_free_ci(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
758 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
759 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
760 if (fail) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
761 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
762 gchar *text; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
763 GenericDialog *gd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
764 |
901 | 765 text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path); |
766 gd = file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL); | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
767 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
768 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
769 file_data_unref(fail); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
770 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
771 break; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
772 } |
901 | 773 case UTILITY_TYPE_CREATE_FOLDER: |
774 { | |
775 if ((internal && mkdir_utf8(ud->dir_fd->path, 0755)) || | |
776 (!internal && ext_result)) | |
777 { | |
974
c466b8fabcc3
update the FileData structure when a new folder is created
nadvornik
parents:
947
diff
changeset
|
778 file_data_check_changed_files(ud->dir_fd); /* this will update the FileData and send notification */ |
901 | 779 } |
780 else | |
781 { | |
782 gchar *text; | |
783 GenericDialog *gd; | |
784 | |
785 text = g_strdup_printf("%s:\n\n%s", ud->messages.fail, ud->dir_fd->path); | |
786 gd = file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL); | |
787 g_free(text); | |
788 } | |
789 | |
790 break; | |
791 } | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
792 default: |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
793 g_warning("unhandled operation"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
794 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
795 ud->phase = UTILITY_PHASE_DONE; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
796 file_util_dialog_run(ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
797 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
798 |
1405 | 799 static gint file_util_perform_ci_dir_cb(gpointer resume_data, EditorFlags flags, GList *list, gpointer data) |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
800 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
801 UtilityData *ud = data; |
1400
67573155210c
Add helper macros EDITOR_ERRORS() and EDITOR_ERRORS_BUT_SKIPPED() to clean up the code a bit. Minor tidy up.
zas_
parents:
1367
diff
changeset
|
802 file_util_perform_ci_dir(ud, FALSE, !EDITOR_ERRORS_BUT_SKIPPED(flags)); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
803 return EDITOR_CB_CONTINUE; /* does not matter, there was just single directory */ |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
804 } |
9 | 805 |
753 | 806 void file_util_perform_ci(UtilityData *ud) |
807 { | |
808 switch (ud->type) | |
809 { | |
810 case UTILITY_TYPE_COPY: | |
1272 | 811 ud->external_command = g_strdup(CMD_COPY); |
753 | 812 break; |
813 case UTILITY_TYPE_MOVE: | |
1272 | 814 ud->external_command = g_strdup(CMD_MOVE); |
753 | 815 break; |
816 case UTILITY_TYPE_RENAME: | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
817 case UTILITY_TYPE_RENAME_FOLDER: |
1272 | 818 ud->external_command = g_strdup(CMD_RENAME); |
753 | 819 break; |
820 case UTILITY_TYPE_DELETE: | |
821 case UTILITY_TYPE_DELETE_LINK: | |
822 case UTILITY_TYPE_DELETE_FOLDER: | |
1272 | 823 ud->external_command = g_strdup(CMD_DELETE); |
753 | 824 break; |
901 | 825 case UTILITY_TYPE_CREATE_FOLDER: |
1272 | 826 ud->external_command = g_strdup(CMD_FOLDER); |
901 | 827 break; |
753 | 828 case UTILITY_TYPE_FILTER: |
829 case UTILITY_TYPE_EDITOR: | |
1272 | 830 g_assert(ud->external_command != NULL); /* it should be already set */ |
753 | 831 break; |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
832 case UTILITY_TYPE_WRITE_METADATA: |
1272 | 833 ud->external_command = NULL; |
753 | 834 } |
9 | 835 |
766
7148e125bf23
Check for existing editor command using is_valid_editor_command().
zas_
parents:
761
diff
changeset
|
836 if (is_valid_editor_command(ud->external_command)) |
9 | 837 { |
1405 | 838 EditorFlags flags; |
757 | 839 |
753 | 840 ud->external = TRUE; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
841 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
842 if (ud->dir_fd) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
843 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
844 flags = start_editor_from_file_full(ud->external_command, ud->dir_fd, file_util_perform_ci_dir_cb, ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
845 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
846 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
847 { |
1618
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
848 if (editor_blocks_file(ud->external_command)) |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
849 { |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
850 DEBUG_1("Starting %s and waiting for results", ud->external_command); |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
851 flags = start_editor_from_filelist_full(ud->external_command, ud->flist, NULL, file_util_perform_ci_cb, ud); |
1618
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
852 } |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
853 else |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
854 { |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
855 /* start the editor without callback and finish the operation internally */ |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
856 DEBUG_1("Starting %s and finishing the operation", ud->external_command); |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
857 flags = start_editor_from_filelist(ud->external_command, ud->flist); |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
858 file_util_perform_ci_internal(ud); |
552648eff4f2
do not block the files sent to external editors like gimp
nadvornik
parents:
1594
diff
changeset
|
859 } |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
860 } |
757 | 861 |
862 if (flags) | |
9 | 863 { |
753 | 864 gchar *text = g_strdup_printf(_("%s\nUnable to start external command.\n"), editor_get_error_str(flags)); |
865 file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL); | |
866 g_free(text); | |
9 | 867 } |
868 } | |
869 else | |
870 { | |
753 | 871 ud->external = FALSE; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
872 if (ud->dir_fd) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
873 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
874 file_util_perform_ci_dir(ud, TRUE, FALSE); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
875 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
876 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
877 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
878 file_util_perform_ci_internal(ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
879 } |
1 | 880 } |
881 } | |
882 | |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
883 static GdkPixbuf *file_util_get_error_icon(FileData *fd, GtkWidget *widget) |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
884 { |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
885 static GdkPixbuf *pb_warning; |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
886 static GdkPixbuf *pb_error; |
932 | 887 static GdkPixbuf *pb_apply; |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
888 gint error; |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
889 |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
890 if (!pb_warning) |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
891 { |
995 | 892 pb_warning = gtk_widget_render_icon(widget, GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU, NULL); |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
893 } |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
894 |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
895 if (!pb_error) |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
896 { |
995 | 897 pb_error = gtk_widget_render_icon(widget, GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_MENU, NULL); |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
898 } |
932 | 899 |
900 if (!pb_apply) | |
901 { | |
995 | 902 pb_apply = gtk_widget_render_icon(widget, GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU, NULL); |
932 | 903 } |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
904 |
928 | 905 error = file_data_sc_verify_ci(fd); |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
906 |
932 | 907 if (!error) return pb_apply; |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
908 |
995 | 909 if (error & CHANGE_ERROR_MASK) |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
910 { |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
911 return pb_error; |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
912 } |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
913 else |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
914 { |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
915 return pb_warning; |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
916 } |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
917 } |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
918 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
919 static void file_util_check_resume_cb(GenericDialog *gd, gpointer data) |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
920 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
921 UtilityData *ud = data; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
922 ud->phase = UTILITY_PHASE_CHECKED; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
923 file_util_dialog_run(ud); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
924 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
925 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
926 static void file_util_check_abort_cb(GenericDialog *gd, gpointer data) |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
927 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
928 UtilityData *ud = data; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
929 ud->phase = UTILITY_PHASE_START; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
930 file_util_dialog_run(ud); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
931 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
932 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
933 void file_util_check_ci(UtilityData *ud) |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
934 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
935 gint error = CHANGE_OK; |
928 | 936 gchar *desc = NULL; |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
937 |
1637 | 938 if (ud->type != UTILITY_TYPE_CREATE_FOLDER && |
939 ud->type != UTILITY_TYPE_RENAME_FOLDER) | |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
940 { |
935 | 941 if (ud->dest_path && !isdir(ud->dest_path)) |
942 { | |
943 error = CHANGE_GENERIC_ERROR; | |
944 desc = g_strdup_printf(_("%s is not a directory"), ud->dest_path); | |
945 } | |
946 else if (ud->dir_fd) | |
947 { | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
948 g_assert(ud->dir_fd->sidecar_files == NULL); // directories should not have sidecars |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
949 error = file_data_verify_ci(ud->dir_fd); |
935 | 950 if (error) desc = file_data_get_error_string(error); |
951 } | |
952 else | |
953 { | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
954 error = file_data_verify_ci_list(ud->flist, &desc, ud->with_sidecars); |
935 | 955 } |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
956 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
957 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
958 if (!error) |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
959 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
960 ud->phase = UTILITY_PHASE_CHECKED; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
961 file_util_dialog_run(ud); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
962 return; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
963 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
964 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
965 if (!(error & CHANGE_ERROR_MASK)) |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
966 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
967 /* just a warning */ |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
968 GenericDialog *d; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
969 |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
970 d = file_util_gen_dlg(ud->messages.title, "dlg_confirm", |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
971 ud->parent, TRUE, |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
972 file_util_check_abort_cb, ud); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
973 |
928 | 974 generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, _("Really continue?"), desc); |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
975 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
976 generic_dialog_add_button(d, GTK_STOCK_GO_FORWARD, _("Co_ntinue"), |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
977 file_util_check_resume_cb, TRUE); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
978 gtk_widget_show(d->dialog); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
979 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
980 else |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
981 { |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
982 /* fatal error */ |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
983 GenericDialog *d; |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
984 |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
985 d = file_util_gen_dlg(ud->messages.title, "dlg_confirm", |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
986 ud->parent, TRUE, |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
987 file_util_check_abort_cb, ud); |
937 | 988 generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, _("This operation can't continue:"), desc); |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
989 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
990 gtk_widget_show(d->dialog); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
991 } |
928 | 992 g_free(desc); |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
993 } |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
994 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
995 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
996 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
997 |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
998 |
757 | 999 static void file_util_cancel_cb(GenericDialog *gd, gpointer data) |
753 | 1000 { |
1001 UtilityData *ud = data; | |
1002 | |
1003 generic_dialog_close(gd); | |
1 | 1004 |
753 | 1005 ud->gd = NULL; |
1006 | |
1007 ud->phase = UTILITY_PHASE_CANCEL; | |
1008 file_util_dialog_run(ud); | |
1 | 1009 } |
1010 | |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1011 static void file_util_discard_cb(GenericDialog *gd, gpointer data) |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1012 { |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1013 UtilityData *ud = data; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1014 |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1015 generic_dialog_close(gd); |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1016 |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1017 ud->gd = NULL; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1018 |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1019 ud->phase = UTILITY_PHASE_DISCARD; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1020 file_util_dialog_run(ud); |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1021 } |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1022 |
757 | 1023 static void file_util_ok_cb(GenericDialog *gd, gpointer data) |
1 | 1024 { |
753 | 1025 UtilityData *ud = data; |
1026 | |
1027 generic_dialog_close(gd); | |
1028 | |
1029 ud->gd = NULL; | |
138 | 1030 |
753 | 1031 file_util_dialog_run(ud); |
1 | 1032 } |
1033 | |
757 | 1034 static void file_util_fdlg_cancel_cb(FileDialog *fdlg, gpointer data) |
1 | 1035 { |
753 | 1036 UtilityData *ud = data; |
675 | 1037 |
753 | 1038 file_dialog_close(fdlg); |
9 | 1039 |
753 | 1040 ud->fdlg = NULL; |
1041 | |
1042 ud->phase = UTILITY_PHASE_CANCEL; | |
1043 file_util_dialog_run(ud); | |
1044 } | |
9 | 1045 |
900 | 1046 static void file_util_dest_folder_update_path(UtilityData *ud) |
753 | 1047 { |
1048 g_free(ud->dest_path); | |
900 | 1049 ud->dest_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(ud->fdlg->entry))); |
753 | 1050 |
1051 switch (ud->type) | |
1 | 1052 { |
753 | 1053 case UTILITY_TYPE_COPY: |
1054 file_data_sc_update_ci_copy_list(ud->flist, ud->dest_path); | |
1055 case UTILITY_TYPE_MOVE: | |
1056 file_data_sc_update_ci_move_list(ud->flist, ud->dest_path); | |
1057 break; | |
1058 case UTILITY_TYPE_FILTER: | |
1059 case UTILITY_TYPE_EDITOR: | |
1060 file_data_sc_update_ci_unspecified_list(ud->flist, ud->dest_path); | |
1061 break; | |
901 | 1062 case UTILITY_TYPE_CREATE_FOLDER: |
1063 file_data_unref(ud->dir_fd); | |
1064 ud->dir_fd = file_data_new_simple(ud->dest_path); | |
1065 break; | |
753 | 1066 case UTILITY_TYPE_DELETE: |
1067 case UTILITY_TYPE_DELETE_LINK: | |
1068 case UTILITY_TYPE_DELETE_FOLDER: | |
1069 case UTILITY_TYPE_RENAME: | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1070 case UTILITY_TYPE_RENAME_FOLDER: |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1071 case UTILITY_TYPE_WRITE_METADATA: |
753 | 1072 g_warning("unhandled operation"); |
1 | 1073 } |
1074 } | |
1075 | |
900 | 1076 static void file_util_fdlg_ok_cb(FileDialog *fdlg, gpointer data) |
1077 { | |
1078 UtilityData *ud = data; | |
1079 | |
1080 file_util_dest_folder_update_path(ud); | |
946 | 1081 if (isdir(ud->dest_path)) file_dialog_sync_history(fdlg, TRUE); |
900 | 1082 file_dialog_close(fdlg); |
1083 | |
1084 ud->fdlg = NULL; | |
1085 | |
1086 file_util_dialog_run(ud); | |
1087 } | |
1088 | |
1089 | |
1090 static void file_util_dest_folder_entry_cb(GtkWidget *entry, gpointer data) | |
1091 { | |
1092 UtilityData *ud = data; | |
1093 file_util_dest_folder_update_path(ud); | |
1094 } | |
1 | 1095 |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1096 /* format: * = filename without extension, ## = number position, extension is kept */ |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1097 static gchar *file_util_rename_multiple_auto_format_name(const gchar *format, const gchar *name, gint n) |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1098 { |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1099 gchar *new_name; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1100 gchar *parsed; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1101 const gchar *ext; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1102 gchar *middle; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1103 gchar *tmp; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1104 gchar *pad_start; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1105 gchar *pad_end; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1106 gint padding; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1107 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1108 if (!format || !name) return NULL; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1109 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1110 tmp = g_strdup(format); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1111 pad_start = strchr(tmp, '#'); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1112 if (pad_start) |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1113 { |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1114 pad_end = pad_start; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1115 padding = 0; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1116 while (*pad_end == '#') |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1117 { |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1118 pad_end++; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1119 padding++; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1120 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1121 *pad_start = '\0'; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1122 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1123 parsed = g_strdup_printf("%s%0*d%s", tmp, padding, n, pad_end); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1124 g_free(tmp); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1125 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1126 else |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1127 { |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1128 parsed = tmp; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1129 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1130 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1131 ext = extension_from_path(name); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1132 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1133 middle = strchr(parsed, '*'); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1134 if (middle) |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1135 { |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1136 gchar *base; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1137 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1138 *middle = '\0'; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1139 middle++; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1140 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1141 base = remove_extension_from_path(name); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1142 new_name = g_strconcat(parsed, base, middle, ext, NULL); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1143 g_free(base); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1144 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1145 else |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1146 { |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1147 new_name = g_strconcat(parsed, ext, NULL); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1148 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1149 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1150 g_free(parsed); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1151 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1152 return new_name; |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1153 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1154 |
9 | 1155 |
753 | 1156 static void file_util_rename_preview_update(UtilityData *ud) |
1 | 1157 { |
9 | 1158 GtkTreeModel *store; |
753 | 1159 GtkTreeSelection *selection; |
9 | 1160 GtkTreeIter iter; |
1161 const gchar *front; | |
1162 const gchar *end; | |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1163 const gchar *format; |
1452 | 1164 gboolean valid; |
9 | 1165 gint start_n; |
1166 gint padding; | |
1167 gint n; | |
753 | 1168 gint mode; |
9 | 1169 |
753 | 1170 mode = gtk_notebook_get_current_page(GTK_NOTEBOOK(ud->notebook)); |
9 | 1171 |
753 | 1172 if (mode == UTILITY_RENAME) |
1173 { | |
1174 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview)); | |
1175 if (gtk_tree_selection_get_selected(selection, &store, &iter)) | |
1176 { | |
1177 FileData *fd; | |
1178 const gchar *dest = gtk_entry_get_text(GTK_ENTRY(ud->rename_entry)); | |
1179 | |
1180 gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &fd, -1); | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1181 g_assert(ud->with_sidecars); /* sidecars must be renamed too, it would break the pairing otherwise */ |
753 | 1182 file_data_sc_update_ci_rename(fd, dest); |
995 | 1183 gtk_list_store_set(GTK_LIST_STORE(store), &iter, |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
1184 UTILITY_COLUMN_PIXBUF, file_util_get_error_icon(fd, ud->listview), |
995 | 1185 UTILITY_COLUMN_DEST_PATH, fd->change->dest, |
1186 UTILITY_COLUMN_DEST_NAME, filename_from_path(fd->change->dest), | |
753 | 1187 -1); |
1188 } | |
1189 return; | |
1190 } | |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1191 |
753 | 1192 |
1193 front = gtk_entry_get_text(GTK_ENTRY(ud->auto_entry_front)); | |
1194 end = gtk_entry_get_text(GTK_ENTRY(ud->auto_entry_end)); | |
1195 padding = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ud->auto_spin_pad)); | |
1196 | |
1197 format = gtk_entry_get_text(GTK_ENTRY(ud->format_entry)); | |
1198 | |
1199 if (mode == UTILITY_RENAME_FORMATTED) | |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1200 { |
753 | 1201 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ud->format_spin)); |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1202 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1203 else |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1204 { |
753 | 1205 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ud->auto_spin_start)); |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1206 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1207 |
753 | 1208 store = gtk_tree_view_get_model(GTK_TREE_VIEW(ud->listview)); |
9 | 1209 n = start_n; |
1210 valid = gtk_tree_model_get_iter_first(store, &iter); | |
1211 while (valid) | |
1212 { | |
1213 gchar *dest; | |
753 | 1214 FileData *fd; |
1215 gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &fd, -1); | |
9 | 1216 |
753 | 1217 if (mode == UTILITY_RENAME_FORMATTED) |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1218 { |
138 | 1219 dest = file_util_rename_multiple_auto_format_name(format, fd->name, n); |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1220 } |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1221 else |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1222 { |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1223 dest = g_strdup_printf("%s%0*d%s", front, padding, n, end); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1224 } |
753 | 1225 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1226 g_assert(ud->with_sidecars); /* sidecars must be renamed too, it would break the pairing otherwise */ |
753 | 1227 file_data_sc_update_ci_rename(fd, dest); |
995 | 1228 gtk_list_store_set(GTK_LIST_STORE(store), &iter, |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
1229 UTILITY_COLUMN_PIXBUF, file_util_get_error_icon(fd, ud->listview), |
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
1230 UTILITY_COLUMN_DEST_PATH, fd->change->dest, |
753 | 1231 UTILITY_COLUMN_DEST_NAME, filename_from_path(fd->change->dest), |
1232 -1); | |
9 | 1233 g_free(dest); |
1234 | |
1235 n++; | |
1236 valid = gtk_tree_model_iter_next(store, &iter); | |
1237 } | |
1238 | |
1 | 1239 } |
1240 | |
753 | 1241 static void file_util_rename_preview_entry_cb(GtkWidget *entry, gpointer data) |
9 | 1242 { |
753 | 1243 UtilityData *ud = data; |
1244 file_util_rename_preview_update(ud); | |
1245 } | |
9 | 1246 |
753 | 1247 static void file_util_rename_preview_adj_cb(GtkWidget *spin, gpointer data) |
1248 { | |
1249 UtilityData *ud = data; | |
1250 file_util_rename_preview_update(ud); | |
1251 } | |
9 | 1252 |
753 | 1253 static gboolean file_util_rename_idle_cb(gpointer data) |
1254 { | |
1255 UtilityData *ud = data; | |
1256 | |
1257 file_util_rename_preview_update(ud); | |
1258 | |
1523 | 1259 ud->update_idle_id = 0; |
9 | 1260 return FALSE; |
1261 } | |
1262 | |
753 | 1263 static void file_util_rename_preview_order_cb(GtkTreeModel *treemodel, GtkTreePath *tpath, |
1452 | 1264 GtkTreeIter *iter, gpointer data) |
9 | 1265 { |
753 | 1266 UtilityData *ud = data; |
9 | 1267 |
1523 | 1268 if (ud->update_idle_id) return; |
757 | 1269 |
1270 ud->update_idle_id = g_idle_add(file_util_rename_idle_cb, ud); | |
9 | 1271 } |
1272 | |
753 | 1273 |
1274 static gboolean file_util_preview_cb(GtkTreeSelection *selection, GtkTreeModel *store, | |
1452 | 1275 GtkTreePath *tpath, gboolean path_currently_selected, |
1276 gpointer data) | |
9 | 1277 { |
753 | 1278 UtilityData *ud = data; |
1279 GtkTreeIter iter; | |
1280 FileData *fd = NULL; | |
1281 | |
1282 if (path_currently_selected || | |
1283 !gtk_tree_model_get_iter(store, &iter, tpath)) return TRUE; | |
1284 | |
1285 gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &fd, -1); | |
1286 generic_dialog_image_set(ud->gd, fd); | |
1287 | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1288 ud->sel_fd = fd; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1289 |
753 | 1290 if (ud->type == UTILITY_TYPE_RENAME) |
1291 { | |
1292 const gchar *name = filename_from_path(fd->change->dest); | |
757 | 1293 |
753 | 1294 gtk_widget_grab_focus(ud->rename_entry); |
1295 gtk_label_set_text(GTK_LABEL(ud->rename_label), fd->name); | |
1296 g_signal_handlers_block_by_func(ud->rename_entry, G_CALLBACK(file_util_rename_preview_entry_cb), ud); | |
1297 gtk_entry_set_text(GTK_ENTRY(ud->rename_entry), name); | |
1298 gtk_editable_select_region(GTK_EDITABLE(ud->rename_entry), 0, filename_base_length(name)); | |
1299 g_signal_handlers_unblock_by_func(ud->rename_entry, G_CALLBACK(file_util_rename_preview_entry_cb), ud); | |
1300 } | |
1301 | |
1302 return TRUE; | |
9 | 1303 } |
1304 | |
753 | 1305 |
1306 | |
1307 static void box_append_safe_delete_status(GenericDialog *gd) | |
9 | 1308 { |
753 | 1309 GtkWidget *label; |
1310 gchar *buf; | |
1311 | |
1312 buf = file_util_safe_delete_status(); | |
1313 label = pref_label_new(gd->vbox, buf); | |
1314 g_free(buf); | |
1315 | |
1316 gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); | |
1317 gtk_widget_set_sensitive(label, FALSE); | |
9 | 1318 } |
1319 | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1320 static void file_util_details_cb(GenericDialog *gd, gpointer data) |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1321 { |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1322 UtilityData *ud = data; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1323 if (ud->details_func && ud->sel_fd) |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1324 { |
1563 | 1325 ud->details_func(ud, ud->sel_fd); |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1326 } |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1327 } |
753 | 1328 |
1329 static void file_util_dialog_init_simple_list(UtilityData *ud) | |
1 | 1330 { |
753 | 1331 GtkWidget *box; |
1332 GtkTreeSelection *selection; | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1333 gchar *dir_msg; |
757 | 1334 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1335 const gchar *stock_id; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1336 |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1337 /* FIXME: use ud->stock_id */ |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1338 if (ud->type == UTILITY_TYPE_DELETE || |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1339 ud->type == UTILITY_TYPE_DELETE_LINK || |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1340 ud->type == UTILITY_TYPE_DELETE_FOLDER) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1341 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1342 stock_id = GTK_STOCK_DELETE; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1343 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1344 else |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1345 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1346 stock_id = GTK_STOCK_OK; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1347 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1348 |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
1349 ud->gd = file_util_gen_dlg(ud->messages.title, "dlg_confirm", |
757 | 1350 ud->parent, FALSE, file_util_cancel_cb, ud); |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1351 if (ud->discard_func) generic_dialog_add_button(ud->gd, GTK_STOCK_REVERT_TO_SAVED, _("Discard changes"), file_util_discard_cb, FALSE); |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1352 if (ud->details_func) generic_dialog_add_button(ud->gd, GTK_STOCK_INFO, _("File details"), file_util_details_cb, FALSE); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1353 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1354 generic_dialog_add_button(ud->gd, stock_id, NULL, file_util_ok_cb, TRUE); |
753 | 1355 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1356 if (ud->dir_fd) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1357 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1358 dir_msg = g_strdup_printf("%s\n\n%s\n", ud->messages.desc_source_fd, ud->dir_fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1359 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1360 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1361 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1362 dir_msg = g_strdup(""); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1363 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1364 |
753 | 1365 box = generic_dialog_add_message(ud->gd, GTK_STOCK_DIALOG_QUESTION, |
757 | 1366 ud->messages.question, |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1367 dir_msg); |
753 | 1368 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1369 g_free(dir_msg); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1370 |
753 | 1371 box = pref_group_new(box, TRUE, ud->messages.desc_flist, GTK_ORIENTATION_HORIZONTAL); |
1372 | |
1211 | 1373 ud->listview = file_util_dialog_add_list(box, ud->flist, FALSE, ud->with_sidecars); |
1374 if (ud->with_sidecars) file_util_dialog_add_list_column(ud->listview, _("Sidecars"), FALSE, UTILITY_COLUMN_SIDECARS); | |
9 | 1375 |
1224 | 1376 if (ud->type == UTILITY_TYPE_WRITE_METADATA) file_util_dialog_add_list_column(ud->listview, _("Write to file"), FALSE, UTILITY_COLUMN_DEST_NAME); |
1377 | |
753 | 1378 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview)); |
1379 gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); | |
1380 gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, NULL); | |
1381 | |
1382 generic_dialog_add_image(ud->gd, box, NULL, NULL, NULL, NULL, FALSE); | |
1383 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1384 if (ud->type == UTILITY_TYPE_DELETE || |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1385 ud->type == UTILITY_TYPE_DELETE_LINK || |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1386 ud->type == UTILITY_TYPE_DELETE_FOLDER) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1387 box_append_safe_delete_status(ud->gd); |
753 | 1388 |
1389 gtk_widget_show(ud->gd->dialog); | |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1390 |
753 | 1391 file_util_dialog_list_select(ud->listview, 0); |
1392 } | |
1393 | |
1394 static void file_util_dialog_init_dest_folder(UtilityData *ud) | |
1395 { | |
1396 FileDialog *fdlg; | |
1397 GtkWidget *label; | |
1398 const gchar *stock_id; | |
1399 | |
995 | 1400 if (ud->type == UTILITY_TYPE_COPY) |
9 | 1401 { |
753 | 1402 stock_id = GTK_STOCK_COPY; |
1403 } | |
1404 else | |
1405 { | |
1406 stock_id = GTK_STOCK_OK; | |
9 | 1407 } |
1408 | |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
1409 fdlg = file_util_file_dlg(ud->messages.title, "dlg_dest_folder", ud->parent, |
757 | 1410 file_util_fdlg_cancel_cb, ud); |
753 | 1411 |
1412 ud->fdlg = fdlg; | |
1413 | |
1414 generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, ud->messages.question, NULL); | |
1415 | |
1416 label = pref_label_new(GENERIC_DIALOG(fdlg)->vbox, _("Choose the destination folder.")); | |
1417 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); | |
1418 pref_spacer(GENERIC_DIALOG(fdlg)->vbox, 0); | |
1419 | |
1420 file_dialog_add_button(fdlg, stock_id, ud->messages.title, file_util_fdlg_ok_cb, TRUE); | |
1421 | |
1422 file_dialog_add_path_widgets(fdlg, NULL, ud->dest_path, "move_copy", NULL, NULL); | |
1423 | |
1424 g_signal_connect(G_OBJECT(fdlg->entry), "changed", | |
1425 G_CALLBACK(file_util_dest_folder_entry_cb), ud); | |
1426 | |
1427 gtk_widget_show(GENERIC_DIALOG(fdlg)->dialog); | |
9 | 1428 } |
1429 | |
753 | 1430 |
1452 | 1431 static GtkWidget *furm_simple_vlabel(GtkWidget *box, const gchar *text, gboolean expand) |
9 | 1432 { |
1433 GtkWidget *vbox; | |
1434 GtkWidget *label; | |
1435 | |
1436 vbox = gtk_vbox_new(FALSE, 0); | |
1437 gtk_box_pack_start(GTK_BOX(box), vbox, expand, expand, 0); | |
1438 gtk_widget_show(vbox); | |
1439 | |
1440 label = gtk_label_new(text); | |
1441 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); | |
1442 gtk_widget_show(label); | |
1443 | |
1444 return vbox; | |
1445 } | |
1446 | |
753 | 1447 |
1448 static void file_util_dialog_init_source_dest(UtilityData *ud) | |
9 | 1449 { |
753 | 1450 GtkTreeModel *store; |
9 | 1451 GtkTreeSelection *selection; |
753 | 1452 GtkWidget *box; |
9 | 1453 GtkWidget *hbox; |
1454 GtkWidget *box2; | |
1455 GtkWidget *table; | |
1456 GtkWidget *combo; | |
753 | 1457 GtkWidget *page; |
1 | 1458 |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
1459 ud->gd = file_util_gen_dlg(ud->messages.title, "dlg_confirm", |
757 | 1460 ud->parent, FALSE, file_util_cancel_cb, ud); |
138 | 1461 |
753 | 1462 box = generic_dialog_add_message(ud->gd, NULL, ud->messages.question, NULL); |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1463 |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1464 if (ud->discard_func) generic_dialog_add_button(ud->gd, GTK_STOCK_REVERT_TO_SAVED, _("Discard changes"), file_util_discard_cb, FALSE); |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1465 if (ud->details_func) generic_dialog_add_button(ud->gd, GTK_STOCK_INFO, _("File details"), file_util_details_cb, FALSE); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1466 |
753 | 1467 generic_dialog_add_button(ud->gd, GTK_STOCK_OK, ud->messages.title, file_util_ok_cb, TRUE); |
9 | 1468 |
753 | 1469 box = pref_group_new(box, TRUE, ud->messages.desc_flist, GTK_ORIENTATION_HORIZONTAL); |
9 | 1470 |
1211 | 1471 ud->listview = file_util_dialog_add_list(box, ud->flist, FALSE, ud->with_sidecars); |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
1472 file_util_dialog_add_list_column(ud->listview, _("Sidecars"), FALSE, UTILITY_COLUMN_SIDECARS); |
442 | 1473 |
924
96a1f535ce89
indicate check warnings and errors in delete and rename dialogs
nadvornik
parents:
921
diff
changeset
|
1474 file_util_dialog_add_list_column(ud->listview, _("New name"), FALSE, UTILITY_COLUMN_DEST_NAME); |
1 | 1475 |
753 | 1476 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview)); |
1477 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE); | |
1478 gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, NULL); | |
9 | 1479 |
1480 | |
753 | 1481 // column = file_util_rename_multiple_add_column(rd, _("Preview"), RENAME_COLUMN_PREVIEW); |
1482 // gtk_tree_view_column_set_visible(column, FALSE); | |
442 | 1483 |
753 | 1484 gtk_tree_view_set_reorderable(GTK_TREE_VIEW(ud->listview), TRUE); |
1485 | |
1486 store = gtk_tree_view_get_model(GTK_TREE_VIEW(ud->listview)); | |
9 | 1487 g_signal_connect(G_OBJECT(store), "row_changed", |
753 | 1488 G_CALLBACK(file_util_rename_preview_order_cb), ud); |
1489 gtk_widget_set_size_request(ud->listview, 300, 150); | |
1 | 1490 |
753 | 1491 generic_dialog_add_image(ud->gd, box, NULL, NULL, NULL, NULL, FALSE); |
9 | 1492 |
753 | 1493 // gtk_container_add(GTK_CONTAINER(scrolled), view); |
1494 gtk_widget_show(ud->gd->dialog); | |
9 | 1495 |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1496 |
753 | 1497 ud->notebook = gtk_notebook_new(); |
1498 | |
1499 gtk_box_pack_start(GTK_BOX(ud->gd->vbox), ud->notebook, FALSE, FALSE, 0); | |
1500 gtk_widget_show(ud->notebook); | |
1501 | |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1502 |
753 | 1503 page = gtk_vbox_new(FALSE, PREF_PAD_GAP); |
1504 gtk_notebook_append_page(GTK_NOTEBOOK(ud->notebook), page, gtk_label_new(_("Manual rename"))); | |
1505 gtk_widget_show(page); | |
1506 | |
1507 table = pref_table_new(page, 2, 2, FALSE, FALSE); | |
9 | 1508 |
1509 pref_table_label(table, 0, 0, _("Original name:"), 1.0); | |
753 | 1510 ud->rename_label = pref_table_label(table, 1, 0, "", 0.0); |
9 | 1511 |
1512 pref_table_label(table, 0, 1, _("New name:"), 1.0); | |
1513 | |
753 | 1514 ud->rename_entry = gtk_entry_new(); |
1515 gtk_table_attach(GTK_TABLE(table), ud->rename_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); | |
1516 generic_dialog_attach_default(GENERIC_DIALOG(ud->gd), ud->rename_entry); | |
1517 gtk_widget_grab_focus(ud->rename_entry); | |
1518 | |
1519 g_signal_connect(G_OBJECT(ud->rename_entry), "changed", | |
1520 G_CALLBACK(file_util_rename_preview_entry_cb), ud); | |
42
606fcf461a68
Sat May 14 13:04:23 2005 John Ellis <johne@verizon.net>
gqview
parents:
15
diff
changeset
|
1521 |
753 | 1522 gtk_widget_show(ud->rename_entry); |
9 | 1523 |
753 | 1524 page = gtk_vbox_new(FALSE, PREF_PAD_GAP); |
1525 gtk_notebook_append_page(GTK_NOTEBOOK(ud->notebook), page, gtk_label_new(_("Auto rename"))); | |
1526 gtk_widget_show(page); | |
9 | 1527 |
753 | 1528 |
1529 hbox = pref_box_new(page, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP); | |
9 | 1530 |
1531 box2 = furm_simple_vlabel(hbox, _("Begin text"), TRUE); | |
1532 | |
753 | 1533 combo = history_combo_new(&ud->auto_entry_front, "", "numerical_rename_prefix", -1); |
1534 g_signal_connect(G_OBJECT(ud->auto_entry_front), "changed", | |
1535 G_CALLBACK(file_util_rename_preview_entry_cb), ud); | |
9 | 1536 gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0); |
1537 gtk_widget_show(combo); | |
442 | 1538 |
9 | 1539 box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE); |
1540 | |
753 | 1541 ud->auto_spin_start = pref_spin_new(box2, NULL, NULL, |
80
a10fc0308c12
Thu Oct 19 07:42:38 2006 John Ellis <johne@verizon.net>
gqview
parents:
71
diff
changeset
|
1542 0.0, 1000000.0, 1.0, 0, 1.0, |
753 | 1543 G_CALLBACK(file_util_rename_preview_adj_cb), ud); |
9 | 1544 |
1545 box2 = furm_simple_vlabel(hbox, _("End text"), TRUE); | |
1546 | |
753 | 1547 combo = history_combo_new(&ud->auto_entry_end, "", "numerical_rename_suffix", -1); |
1548 g_signal_connect(G_OBJECT(ud->auto_entry_end), "changed", | |
1549 G_CALLBACK(file_util_rename_preview_entry_cb), ud); | |
9 | 1550 gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0); |
1551 gtk_widget_show(combo); | |
1552 | |
753 | 1553 ud->auto_spin_pad = pref_spin_new(page, _("Padding:"), NULL, |
9 | 1554 1.0, 8.0, 1.0, 0, 1.0, |
753 | 1555 G_CALLBACK(file_util_rename_preview_adj_cb), ud); |
9 | 1556 |
753 | 1557 page = gtk_vbox_new(FALSE, PREF_PAD_GAP); |
1558 gtk_notebook_append_page(GTK_NOTEBOOK(ud->notebook), page, gtk_label_new(_("Formatted rename"))); | |
1559 gtk_widget_show(page); | |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1560 |
753 | 1561 hbox = pref_box_new(page, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP); |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1562 |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1563 box2 = furm_simple_vlabel(hbox, _("Format (* = original name, ## = numbers)"), TRUE); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1564 |
753 | 1565 combo = history_combo_new(&ud->format_entry, "", "auto_rename_format", -1); |
1566 g_signal_connect(G_OBJECT(ud->format_entry), "changed", | |
1567 G_CALLBACK(file_util_rename_preview_entry_cb), ud); | |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1568 gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1569 gtk_widget_show(combo); |
442 | 1570 |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1571 box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE); |
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1572 |
753 | 1573 ud->format_spin = pref_spin_new(box2, NULL, NULL, |
80
a10fc0308c12
Thu Oct 19 07:42:38 2006 John Ellis <johne@verizon.net>
gqview
parents:
71
diff
changeset
|
1574 0.0, 1000000.0, 1.0, 0, 1.0, |
753 | 1575 G_CALLBACK(file_util_rename_preview_adj_cb), ud); |
66
ebbff299ad0d
Fri Sep 1 02:12:45 2006 John Ellis <johne@verizon.net>
gqview
parents:
44
diff
changeset
|
1576 |
753 | 1577 // gtk_combo_box_set_active(GTK_COMBO_BOX(ud->combo_type), 0); /* callback will take care of the rest */ |
138 | 1578 |
753 | 1579 file_util_dialog_list_select(ud->listview, 0); |
1 | 1580 } |
1581 | |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1582 static void file_util_finalize_all(UtilityData *ud) |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1583 { |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1584 GList *work = ud->flist; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1585 |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1586 if (ud->phase == UTILITY_PHASE_CANCEL) return; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1587 if (ud->phase == UTILITY_PHASE_DONE && !ud->finalize_func) return; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1588 if (ud->phase == UTILITY_PHASE_DISCARD && !ud->discard_func) return; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1589 |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1590 while (work) |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1591 { |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1592 FileData *fd = work->data; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1593 work = work->next; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1594 if (ud->phase == UTILITY_PHASE_DONE) ud->finalize_func(fd); |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1595 else if (ud->phase == UTILITY_PHASE_DISCARD) ud->discard_func(fd); |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1596 } |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1597 } |
9 | 1598 |
1563 | 1599 static gboolean file_util_exclude_fd(UtilityData *ud, FileData *fd) |
1600 { | |
1601 GtkTreeModel *store; | |
1602 GtkTreeIter iter; | |
1603 gboolean valid; | |
1604 | |
1605 if (!g_list_find(ud->flist, fd)) return FALSE; | |
1606 | |
1607 store = gtk_tree_view_get_model(GTK_TREE_VIEW(ud->listview)); | |
1608 valid = gtk_tree_model_get_iter_first(store, &iter); | |
1609 while (valid) | |
1610 { | |
1611 FileData *store_fd; | |
1612 gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &store_fd, -1); | |
1613 | |
1614 if (store_fd == fd) | |
1615 { | |
1616 gtk_list_store_remove(GTK_LIST_STORE(store), &iter); | |
1617 break; | |
1618 } | |
1619 valid = gtk_tree_model_iter_next(store, &iter); | |
1620 } | |
1621 | |
1622 ud->flist = g_list_remove(ud->flist, fd); | |
1623 | |
1624 if (ud->with_sidecars) | |
1625 file_data_sc_free_ci(fd); | |
1626 else | |
1627 file_data_free_ci(fd); | |
1628 | |
1629 file_data_unref(fd); | |
1630 return TRUE; | |
1631 } | |
1632 | |
753 | 1633 void file_util_dialog_run(UtilityData *ud) |
1 | 1634 { |
753 | 1635 switch (ud->phase) |
1636 { | |
1637 case UTILITY_PHASE_START: | |
1638 /* create the dialogs */ | |
1639 switch (ud->type) | |
1640 { | |
1641 case UTILITY_TYPE_DELETE: | |
1642 case UTILITY_TYPE_DELETE_LINK: | |
1643 case UTILITY_TYPE_DELETE_FOLDER: | |
1644 case UTILITY_TYPE_EDITOR: | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1645 case UTILITY_TYPE_WRITE_METADATA: |
753 | 1646 file_util_dialog_init_simple_list(ud); |
1647 break; | |
1648 case UTILITY_TYPE_RENAME: | |
1649 file_util_dialog_init_source_dest(ud); | |
1650 break; | |
1651 case UTILITY_TYPE_COPY: | |
1652 case UTILITY_TYPE_MOVE: | |
1653 case UTILITY_TYPE_FILTER: | |
901 | 1654 case UTILITY_TYPE_CREATE_FOLDER: |
753 | 1655 file_util_dialog_init_dest_folder(ud); |
1656 break; | |
934 | 1657 case UTILITY_TYPE_RENAME_FOLDER: |
1658 ud->phase = UTILITY_PHASE_CANCEL; /* FIXME - not handled for now */ | |
1659 file_util_dialog_run(ud); | |
1660 return; | |
753 | 1661 } |
1662 ud->phase = UTILITY_PHASE_ENTERING; | |
1663 break; | |
1664 case UTILITY_PHASE_ENTERING: | |
914
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
1665 file_util_check_ci(ud); |
9427c91951e8
basic infrastructure for early error and dangerous operations checking
nadvornik
parents:
908
diff
changeset
|
1666 break; |
753 | 1667 |
1668 ud->phase = UTILITY_PHASE_CHECKED; | |
1669 case UTILITY_PHASE_CHECKED: | |
1670 file_util_perform_ci(ud); | |
1671 break; | |
1672 case UTILITY_PHASE_CANCEL: | |
1673 case UTILITY_PHASE_DONE: | |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1674 case UTILITY_PHASE_DISCARD: |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1675 |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
1676 file_util_finalize_all(ud); |
1231 | 1677 |
1562 | 1678 /* both DISCARD and DONE finishes the operation for good */ |
1231 | 1679 if (ud->done_func) |
1562 | 1680 ud->done_func((ud->phase != UTILITY_PHASE_CANCEL), ud->dest_path, ud->done_data); |
1231 | 1681 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1682 if (ud->with_sidecars) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1683 file_data_sc_free_ci_list(ud->flist); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1684 else |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1685 file_data_free_ci_list(ud->flist); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1686 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1687 /* directory content is always handled including sidecars */ |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
1688 file_data_sc_free_ci_list(ud->content_list); |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1689 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1690 if (ud->dir_fd) file_data_free_ci(ud->dir_fd); |
753 | 1691 file_util_data_free(ud); |
1692 break; | |
1693 } | |
1 | 1694 } |
1695 | |
753 | 1696 |
1697 | |
1698 | |
757 | 1699 static void file_util_warn_op_in_progress(const gchar *title) |
1700 { | |
1701 file_util_warning_dialog(title, _("Another operation in progress.\n"), GTK_STOCK_DIALOG_ERROR, NULL); | |
1702 } | |
9 | 1703 |
1563 | 1704 static void file_util_details_dialog_close_cb(GtkWidget *widget, gpointer data) |
1705 { | |
1706 gtk_widget_destroy(data); | |
1707 | |
1708 } | |
1709 | |
1710 static void file_util_details_dialog_destroy_cb(GtkWidget *widget, gpointer data) | |
1711 { | |
1712 UtilityData *ud = data; | |
1713 g_signal_handlers_disconnect_by_func(ud->gd->dialog, G_CALLBACK(file_util_details_dialog_close_cb), widget); | |
1714 } | |
1715 | |
1716 | |
1717 static void file_util_details_dialog_ok_cb(GenericDialog *gd, gpointer data) | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1718 { |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1719 /* no op */ |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1720 } |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1721 |
1564 | 1722 static void file_util_details_dialog_exclude(GenericDialog *gd, gpointer data, gboolean discard) |
1563 | 1723 { |
1724 UtilityData *ud = data; | |
1725 FileData *fd = g_object_get_data(G_OBJECT(gd->dialog), "file_data"); | |
1726 | |
1727 if (!fd) return; | |
1728 file_util_exclude_fd(ud, fd); | |
1729 | |
1730 if (discard && ud->discard_func) ud->discard_func(fd); | |
1731 | |
1732 /* all files were excluded, this has the same effect as pressing the cancel button in the confirmation dialog*/ | |
1733 if (!ud->flist) | |
1734 { | |
1735 /* both dialogs will be closed anyway, the signals would cause duplicate calls */ | |
1736 g_signal_handlers_disconnect_by_func(ud->gd->dialog, G_CALLBACK(file_util_details_dialog_close_cb), gd->dialog); | |
1737 g_signal_handlers_disconnect_by_func(gd->dialog, G_CALLBACK(file_util_details_dialog_destroy_cb), ud); | |
1738 | |
1739 file_util_cancel_cb(ud->gd, ud); | |
1740 } | |
1741 } | |
1742 | |
1564 | 1743 static void file_util_details_dialog_exclude_cb(GenericDialog *gd, gpointer data) |
1563 | 1744 { |
1564 | 1745 file_util_details_dialog_exclude(gd, data, FALSE); |
1746 } | |
1747 | |
1748 static void file_util_details_dialog_discard_cb(GenericDialog *gd, gpointer data) | |
1749 { | |
1750 file_util_details_dialog_exclude(gd, data, TRUE); | |
1563 | 1751 } |
1752 | |
1565 | 1753 static gchar *file_util_details_get_message(UtilityData *ud, FileData *fd, const gchar **stock_id) |
1754 { | |
1755 GString *message = g_string_new(""); | |
1756 gint error; | |
1757 g_string_append_printf(message, _("File: '%s'\n"), fd->path); | |
1758 | |
1759 if (ud->with_sidecars && fd->sidecar_files) | |
1760 { | |
1761 GList *work = fd->sidecar_files; | |
1762 g_string_append(message, _("with sidecar files:\n")); | |
1763 | |
1764 while (work) | |
1765 { | |
1766 FileData *sfd = work->data; | |
1767 work =work->next; | |
1768 g_string_append_printf(message, _(" '%s'\n"), sfd->path); | |
1769 } | |
1770 } | |
1771 | |
1772 g_string_append(message, _("\nStatus: ")); | |
1773 | |
1774 error = ud->with_sidecars ? file_data_sc_verify_ci(fd) : file_data_verify_ci(fd); | |
1775 | |
1776 if (error) | |
1777 { | |
1778 gchar *err_msg = file_data_get_error_string(error); | |
1779 g_string_append(message, err_msg); | |
1780 if (stock_id) *stock_id = (error & CHANGE_ERROR_MASK) ? GTK_STOCK_DIALOG_ERROR : GTK_STOCK_DIALOG_WARNING; | |
1781 } | |
1782 else | |
1783 { | |
1784 g_string_append(message, _("no problem detected")); | |
1785 if (stock_id) *stock_id = GTK_STOCK_DIALOG_INFO; | |
1786 } | |
1787 | |
1788 return g_string_free(message, FALSE);; | |
1789 } | |
1790 | |
1564 | 1791 static void file_util_details_dialog(UtilityData *ud, FileData *fd) |
1563 | 1792 { |
1564 | 1793 GenericDialog *gd; |
1794 GtkWidget *box; | |
1795 gchar *message; | |
1796 const gchar *stock_id; | |
1797 | |
1798 gd = file_util_gen_dlg(_("File details"), "details", ud->gd->dialog, TRUE, NULL, ud); | |
1565 | 1799 generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, file_util_details_dialog_ok_cb, TRUE); |
1800 generic_dialog_add_button(gd, GTK_STOCK_REMOVE, _("Exclude file"), file_util_details_dialog_exclude_cb, FALSE); | |
1564 | 1801 |
1802 g_object_set_data(G_OBJECT(gd->dialog), "file_data", fd); | |
1803 | |
1804 g_signal_connect(G_OBJECT(gd->dialog), "destroy", | |
1805 G_CALLBACK(file_util_details_dialog_destroy_cb), ud); | |
1806 | |
1807 /* in case the ud->gd->dialog is closed during editing */ | |
1808 g_signal_connect(G_OBJECT(ud->gd->dialog), "destroy", | |
1809 G_CALLBACK(file_util_details_dialog_close_cb), gd->dialog); | |
1810 | |
1811 | |
1565 | 1812 message = file_util_details_get_message(ud, fd, &stock_id); |
1564 | 1813 |
1814 box = generic_dialog_add_message(gd, stock_id, _("File details"), message); | |
1815 | |
1816 generic_dialog_add_image(gd, box, fd, NULL, NULL, NULL, FALSE); | |
1817 | |
1818 gtk_widget_show(gd->dialog); | |
1819 | |
1820 g_free(message); | |
1563 | 1821 } |
1822 | |
1823 static void file_util_write_metadata_details_dialog(UtilityData *ud, FileData *fd) | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1824 { |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1825 GenericDialog *gd; |
1561 | 1826 GtkWidget *box; |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1827 GtkWidget *table; |
1565 | 1828 GtkWidget *frame; |
1594 | 1829 GtkWidget *label; |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1830 GList *keys = NULL; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1831 GList *work; |
1565 | 1832 gchar *message1; |
1833 gchar *message2; | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1834 gint i; |
1565 | 1835 const gchar *stock_id; |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1836 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1837 if (fd && fd->modified_xmp) |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1838 { |
1574 | 1839 keys = hash_table_get_keys(fd->modified_xmp); |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1840 } |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1841 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1842 g_assert(keys); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1843 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1844 |
1563 | 1845 gd = file_util_gen_dlg(_("Overview of changed metadata"), "details", ud->gd->dialog, TRUE, NULL, ud); |
1565 | 1846 generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, file_util_details_dialog_ok_cb, TRUE); |
1847 generic_dialog_add_button(gd, GTK_STOCK_REMOVE, _("Exclude file"), file_util_details_dialog_exclude_cb, FALSE); | |
1564 | 1848 generic_dialog_add_button(gd, GTK_STOCK_REVERT_TO_SAVED, _("Discard changes"), file_util_details_dialog_discard_cb, FALSE); |
1563 | 1849 |
1850 g_object_set_data(G_OBJECT(gd->dialog), "file_data", fd); | |
1851 | |
1852 g_signal_connect(G_OBJECT(gd->dialog), "destroy", | |
1853 G_CALLBACK(file_util_details_dialog_destroy_cb), ud); | |
1854 | |
1855 /* in case the ud->gd->dialog is closed during editing */ | |
1856 g_signal_connect(G_OBJECT(ud->gd->dialog), "destroy", | |
1857 G_CALLBACK(file_util_details_dialog_close_cb), gd->dialog); | |
1858 | |
1565 | 1859 message1 = file_util_details_get_message(ud, fd, &stock_id); |
1860 | |
1861 if (fd->change && fd->change->dest) | |
1862 { | |
1594 | 1863 message2 = g_strdup_printf(_("The following metadata tags will be written to\n'%s'."), fd->change->dest); |
1565 | 1864 } |
1865 else | |
1866 { | |
1867 message2 = g_strdup_printf(_("The following metadata tags will be written to the image file itself.")); | |
1868 } | |
1869 | |
1870 box = generic_dialog_add_message(gd, stock_id, _("Overview of changed metadata"), message1); | |
1871 | |
1872 box = pref_group_new(box, TRUE, message2, GTK_ORIENTATION_HORIZONTAL); | |
1873 | |
1874 frame = pref_frame_new(box, TRUE, NULL, GTK_ORIENTATION_HORIZONTAL, 2); | |
1875 table = pref_table_new(frame, 2, g_list_length(keys), FALSE, TRUE); | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1876 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1877 work = keys; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1878 i = 0; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1879 while (work) |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1880 { |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1881 const gchar *key = work->data; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1882 gchar *title = exif_get_description_by_key(key); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1883 gchar *title_f = g_strdup_printf("%s:", title); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1884 gchar *value = metadata_read_string(fd, key, METADATA_FORMATTED); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1885 work = work->next; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1886 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1887 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1888 label = gtk_label_new(title_f); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1889 gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.0); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1890 pref_label_bold(label, TRUE, FALSE); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1891 gtk_table_attach(GTK_TABLE(table), label, |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1892 0, 1, i, i + 1, |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1893 GTK_FILL, GTK_FILL, |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1894 2, 2); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1895 gtk_widget_show(label); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1896 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1897 label = gtk_label_new(value); |
1565 | 1898 |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1899 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0); |
1594 | 1900 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1901 gtk_table_attach(GTK_TABLE(table), label, |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1902 1, 2, i, i + 1, |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1903 GTK_FILL, GTK_FILL, |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1904 2, 2); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1905 gtk_widget_show(label); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1906 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1907 g_free(title); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1908 g_free(title_f); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1909 g_free(value); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1910 i++; |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1911 } |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1912 |
1561 | 1913 generic_dialog_add_image(gd, box, fd, NULL, NULL, NULL, FALSE); |
1914 | |
1594 | 1915 gtk_widget_set_size_request(gd->dialog, DIALOG_WIDTH, -1); |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1916 gtk_widget_show(gd->dialog); |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1917 |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1918 g_list_free(keys); |
1565 | 1919 g_free(message1); |
1920 g_free(message2); | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1921 } |
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
1922 |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1923 |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1924 static void file_util_mark_ungrouped_files(GList *work) |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1925 { |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1926 while (work) |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1927 { |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1928 FileData *fd = work->data; |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1929 file_data_set_regroup_when_finished(fd, TRUE); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1930 work = work->next; |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1931 } |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1932 } |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1933 |
1656 | 1934 static void file_util_delete_full(FileData *source_fd, GList *flist, GtkWidget *parent, UtilityPhase phase) |
1564 | 1935 { |
1936 UtilityData *ud; | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1937 GList *ungrouped = NULL; |
1564 | 1938 |
1939 if (source_fd) | |
1940 flist = g_list_append(flist, file_data_ref(source_fd)); | |
1941 | |
1942 if (!flist) return; | |
1943 | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1944 flist = file_data_process_groups_in_selection(flist, &ungrouped); |
1564 | 1945 |
1946 if (!file_data_sc_add_ci_delete_list(flist)) | |
1947 { | |
1948 file_util_warn_op_in_progress(_("File deletion failed")); | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1949 file_data_disable_grouping_list(ungrouped, FALSE); |
1564 | 1950 filelist_free(flist); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1951 filelist_free(ungrouped); |
1564 | 1952 return; |
1953 } | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1954 |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1955 file_util_mark_ungrouped_files(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
1956 filelist_free(ungrouped); |
1564 | 1957 |
1958 ud = file_util_data_new(UTILITY_TYPE_DELETE); | |
1959 | |
1960 ud->phase = phase; | |
1961 | |
1962 ud->with_sidecars = TRUE; | |
1963 | |
1964 ud->dir_fd = NULL; | |
1965 ud->flist = flist; | |
1966 ud->content_list = NULL; | |
1967 ud->parent = parent; | |
1968 | |
1969 ud->details_func = file_util_details_dialog; | |
1970 | |
1685 | 1971 ud->messages.title = _("Delete"); |
1564 | 1972 ud->messages.question = _("Delete files?"); |
1973 ud->messages.desc_flist = _("This will delete the following files"); | |
1974 ud->messages.desc_source_fd = ""; | |
1975 ud->messages.fail = _("File deletion failed"); | |
1976 | |
1977 file_util_dialog_run(ud); | |
1978 } | |
1979 | |
1980 | |
1656 | 1981 static void file_util_write_metadata_full(FileData *source_fd, GList *flist, GtkWidget *parent, UtilityPhase phase, FileUtilDoneFunc done_func, gpointer done_data) |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1982 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1983 UtilityData *ud; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1984 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1985 if (source_fd) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1986 flist = g_list_append(flist, file_data_ref(source_fd)); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1987 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1988 if (!flist) return; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1989 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1990 if (!file_data_add_ci_write_metadata_list(flist)) |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1991 { |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1992 file_util_warn_op_in_progress(_("Can't write metadata")); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1993 filelist_free(flist); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1994 return; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1995 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1996 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1997 ud = file_util_data_new(UTILITY_TYPE_WRITE_METADATA); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1998 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
1999 ud->phase = phase; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2000 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2001 ud->with_sidecars = FALSE; /* operate on individual files, not groups */ |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2002 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2003 ud->dir_fd = NULL; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2004 ud->flist = flist; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2005 ud->content_list = NULL; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2006 ud->parent = parent; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2007 |
1231 | 2008 ud->done_func = done_func; |
2009 ud->done_data = done_data; | |
2010 | |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
2011 ud->details_func = file_util_write_metadata_details_dialog; |
1560
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
2012 ud->finalize_func = metadata_write_queue_remove; |
dd0a89cdb021
differentiate between "Cancel" and "Discard changes"
nadvornik
parents:
1559
diff
changeset
|
2013 ud->discard_func = metadata_write_queue_remove; |
1557
c10cd5197447
added possibility to show modifiied metadata before write
nadvornik
parents:
1532
diff
changeset
|
2014 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2015 ud->messages.title = _("Write metadata"); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2016 ud->messages.question = _("Write metadata?"); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2017 ud->messages.desc_flist = _("This will write the changed metadata into the following files"); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2018 ud->messages.desc_source_fd = ""; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2019 ud->messages.fail = _("Metadata writting failed"); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2020 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2021 file_util_dialog_run(ud); |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2022 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2023 |
1656 | 2024 static void file_util_move_full(FileData *source_fd, GList *flist, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase) |
1 | 2025 { |
753 | 2026 UtilityData *ud; |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2027 GList *ungrouped = NULL; |
753 | 2028 |
2029 if (source_fd) | |
2030 flist = g_list_append(flist, file_data_ref(source_fd)); | |
2031 | |
947
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2032 if (!flist) return; |
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2033 |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2034 flist = file_data_process_groups_in_selection(flist, &ungrouped); |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
800
diff
changeset
|
2035 |
753 | 2036 if (!file_data_sc_add_ci_move_list(flist, dest_path)) |
2037 { | |
757 | 2038 file_util_warn_op_in_progress(_("Move failed")); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2039 file_data_disable_grouping_list(ungrouped, FALSE); |
753 | 2040 filelist_free(flist); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2041 filelist_free(ungrouped); |
753 | 2042 return; |
2043 } | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2044 |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2045 file_util_mark_ungrouped_files(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2046 filelist_free(ungrouped); |
753 | 2047 |
2048 ud = file_util_data_new(UTILITY_TYPE_MOVE); | |
2049 | |
2050 ud->phase = phase; | |
2051 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2052 ud->with_sidecars = TRUE; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2053 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2054 ud->dir_fd = NULL; |
753 | 2055 ud->flist = flist; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2056 ud->content_list = NULL; |
753 | 2057 ud->parent = parent; |
9 | 2058 |
900 | 2059 if (dest_path) ud->dest_path = g_strdup(dest_path); |
753 | 2060 |
2061 ud->messages.title = _("Move"); | |
2062 ud->messages.question = _("Move files?"); | |
2063 ud->messages.desc_flist = _("This will move the following files"); | |
2064 ud->messages.desc_source_fd = ""; | |
2065 ud->messages.fail = _("Move failed"); | |
138 | 2066 |
753 | 2067 file_util_dialog_run(ud); |
2068 } | |
1452 | 2069 |
1656 | 2070 static void file_util_copy_full(FileData *source_fd, GList *flist, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase) |
753 | 2071 { |
2072 UtilityData *ud; | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2073 GList *ungrouped = NULL; |
753 | 2074 |
2075 if (source_fd) | |
2076 flist = g_list_append(flist, file_data_ref(source_fd)); | |
2077 | |
947
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2078 if (!flist) return; |
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2079 |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2080 flist = file_data_process_groups_in_selection(flist, &ungrouped); |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
800
diff
changeset
|
2081 |
753 | 2082 if (!file_data_sc_add_ci_copy_list(flist, dest_path)) |
1 | 2083 { |
757 | 2084 file_util_warn_op_in_progress(_("Copy failed")); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2085 file_data_disable_grouping_list(ungrouped, FALSE); |
753 | 2086 filelist_free(flist); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2087 filelist_free(ungrouped); |
1 | 2088 return; |
2089 } | |
2090 | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2091 file_util_mark_ungrouped_files(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2092 filelist_free(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2093 |
753 | 2094 ud = file_util_data_new(UTILITY_TYPE_COPY); |
2095 | |
2096 ud->phase = phase; | |
2097 | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2098 ud->with_sidecars = TRUE; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2099 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2100 ud->dir_fd = NULL; |
753 | 2101 ud->flist = flist; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2102 ud->content_list = NULL; |
753 | 2103 ud->parent = parent; |
9 | 2104 |
900 | 2105 if (dest_path) ud->dest_path = g_strdup(dest_path); |
753 | 2106 |
2107 ud->messages.title = _("Copy"); | |
2108 ud->messages.question = _("Copy files?"); | |
2109 ud->messages.desc_flist = _("This will copy the following files"); | |
2110 ud->messages.desc_source_fd = ""; | |
2111 ud->messages.fail = _("Copy failed"); | |
1 | 2112 |
753 | 2113 file_util_dialog_run(ud); |
9 | 2114 } |
2115 | |
1656 | 2116 static void file_util_rename_full(FileData *source_fd, GList *flist, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase) |
1 | 2117 { |
753 | 2118 UtilityData *ud; |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2119 GList *ungrouped = NULL; |
753 | 2120 |
2121 if (source_fd) | |
2122 flist = g_list_append(flist, file_data_ref(source_fd)); | |
138 | 2123 |
947
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2124 if (!flist) return; |
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2125 |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2126 flist = file_data_process_groups_in_selection(flist, &ungrouped); |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
800
diff
changeset
|
2127 |
753 | 2128 if (!file_data_sc_add_ci_rename_list(flist, dest_path)) |
2129 { | |
757 | 2130 file_util_warn_op_in_progress(_("Rename failed")); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2131 file_data_disable_grouping_list(ungrouped, FALSE); |
753 | 2132 filelist_free(flist); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2133 filelist_free(ungrouped); |
753 | 2134 return; |
2135 } | |
9 | 2136 |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2137 file_util_mark_ungrouped_files(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2138 filelist_free(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2139 |
753 | 2140 ud = file_util_data_new(UTILITY_TYPE_RENAME); |
138 | 2141 |
753 | 2142 ud->phase = phase; |
1 | 2143 |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2144 ud->with_sidecars = TRUE; |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2145 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2146 ud->dir_fd = NULL; |
753 | 2147 ud->flist = flist; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2148 ud->content_list = NULL; |
753 | 2149 ud->parent = parent; |
1564 | 2150 |
2151 ud->details_func = file_util_details_dialog; | |
753 | 2152 |
2153 ud->messages.title = _("Rename"); | |
2154 ud->messages.question = _("Rename files?"); | |
2155 ud->messages.desc_flist = _("This will rename the following files"); | |
2156 ud->messages.desc_source_fd = ""; | |
2157 ud->messages.fail = _("Rename failed"); | |
138 | 2158 |
753 | 2159 file_util_dialog_run(ud); |
1 | 2160 } |
2161 | |
1656 | 2162 static void file_util_start_editor_full(const gchar *key, FileData *source_fd, GList *flist, const gchar *dest_path, const gchar *working_directory, GtkWidget *parent, UtilityPhase phase) |
753 | 2163 { |
2164 UtilityData *ud; | |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2165 GList *ungrouped = NULL; |
1581
c9c1a16ff8ae
allow external editors without parameters, as long as they are in
nadvornik
parents:
1574
diff
changeset
|
2166 |
c9c1a16ff8ae
allow external editors without parameters, as long as they are in
nadvornik
parents:
1574
diff
changeset
|
2167 if (editor_no_param(key)) |
c9c1a16ff8ae
allow external editors without parameters, as long as they are in
nadvornik
parents:
1574
diff
changeset
|
2168 { |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2169 gchar *file_directory = NULL; |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2170 if (!working_directory) |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2171 { |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2172 /* working directory was not specified, try to extract it from the files */ |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2173 if (source_fd) |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2174 file_directory = remove_level_from_path(source_fd->path); |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2175 |
1656 | 2176 if (!file_directory && flist) |
2177 file_directory = remove_level_from_path(((FileData *)flist->data)->path); | |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2178 working_directory = file_directory; |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2179 } |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2180 |
1581
c9c1a16ff8ae
allow external editors without parameters, as long as they are in
nadvornik
parents:
1574
diff
changeset
|
2181 /* just start the editor, don't care about files */ |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2182 start_editor(key, working_directory); |
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2183 g_free(file_directory); |
1656 | 2184 filelist_free(flist); |
1581
c9c1a16ff8ae
allow external editors without parameters, as long as they are in
nadvornik
parents:
1574
diff
changeset
|
2185 return; |
c9c1a16ff8ae
allow external editors without parameters, as long as they are in
nadvornik
parents:
1574
diff
changeset
|
2186 } |
c9c1a16ff8ae
allow external editors without parameters, as long as they are in
nadvornik
parents:
1574
diff
changeset
|
2187 |
753 | 2188 |
2189 if (source_fd) | |
1650
c16f499ea1ce
made file_util_start_editor_from_file consider also sidecars
nadvornik
parents:
1637
diff
changeset
|
2190 { |
c16f499ea1ce
made file_util_start_editor_from_file consider also sidecars
nadvornik
parents:
1637
diff
changeset
|
2191 /* flist is most probably NULL |
c16f499ea1ce
made file_util_start_editor_from_file consider also sidecars
nadvornik
parents:
1637
diff
changeset
|
2192 operate on source_fd and it's sidecars |
c16f499ea1ce
made file_util_start_editor_from_file consider also sidecars
nadvornik
parents:
1637
diff
changeset
|
2193 */ |
c16f499ea1ce
made file_util_start_editor_from_file consider also sidecars
nadvornik
parents:
1637
diff
changeset
|
2194 flist = g_list_concat(filelist_copy(source_fd->sidecar_files), flist); |
753 | 2195 flist = g_list_append(flist, file_data_ref(source_fd)); |
1650
c16f499ea1ce
made file_util_start_editor_from_file consider also sidecars
nadvornik
parents:
1637
diff
changeset
|
2196 } |
1 | 2197 |
947
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2198 if (!flist) return; |
368643594bc8
abort file operations when the file list is empty
nadvornik
parents:
946
diff
changeset
|
2199 |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2200 flist = file_data_process_groups_in_selection(flist, &ungrouped); |
849
db68d673448f
added possibility to disable grouping of selected files
nadvornik
parents:
800
diff
changeset
|
2201 |
753 | 2202 if (!file_data_sc_add_ci_unspecified_list(flist, dest_path)) |
1 | 2203 { |
757 | 2204 file_util_warn_op_in_progress(_("Can't run external editor")); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2205 file_data_disable_grouping_list(ungrouped, FALSE); |
753 | 2206 filelist_free(flist); |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2207 filelist_free(ungrouped); |
753 | 2208 return; |
1 | 2209 } |
9 | 2210 |
1623
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2211 file_util_mark_ungrouped_files(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2212 filelist_free(ungrouped); |
2842a051c870
regroup sidecar files when an operation on partial group is finished
nadvornik
parents:
1622
diff
changeset
|
2213 |
1272 | 2214 if (editor_is_filter(key)) |
753 | 2215 ud = file_util_data_new(UTILITY_TYPE_FILTER); |
2216 else | |
2217 ud = file_util_data_new(UTILITY_TYPE_EDITOR); | |
2218 | |
2219 | |
2220 /* ask for destination if we don't have it */ | |
2221 if (ud->type == UTILITY_TYPE_FILTER && dest_path == NULL) phase = UTILITY_PHASE_START; | |
2222 | |
2223 ud->phase = phase; | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2224 |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2225 ud->with_sidecars = TRUE; |
753 | 2226 |
1272 | 2227 ud->external_command = g_strdup(key); |
753 | 2228 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2229 ud->dir_fd = NULL; |
753 | 2230 ud->flist = flist; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2231 ud->content_list = NULL; |
753 | 2232 ud->parent = parent; |
2233 | |
1564 | 2234 ud->details_func = file_util_details_dialog; |
2235 | |
900 | 2236 if (dest_path) ud->dest_path = g_strdup(dest_path); |
753 | 2237 |
2238 ud->messages.title = _("Editor"); | |
2239 ud->messages.question = _("Run editor?"); | |
2240 ud->messages.desc_flist = _("This will copy the following files"); | |
2241 ud->messages.desc_source_fd = ""; | |
2242 ud->messages.fail = _("External command failed"); | |
2243 | |
2244 file_util_dialog_run(ud); | |
1 | 2245 } |
2246 | |
901 | 2247 static GList *file_util_delete_dir_remaining_folders(GList *dlist) |
2248 { | |
2249 GList *rlist = NULL; | |
2250 | |
2251 while (dlist) | |
2252 { | |
2253 FileData *fd; | |
2254 | |
2255 fd = dlist->data; | |
2256 dlist = dlist->next; | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2257 |
901 | 2258 if (!fd->name || |
2259 (strcmp(fd->name, THUMB_FOLDER_GLOBAL) != 0 && | |
2260 strcmp(fd->name, THUMB_FOLDER_LOCAL) != 0 && | |
2261 strcmp(fd->name, GQ_CACHE_LOCAL_METADATA) != 0) ) | |
2262 { | |
2263 rlist = g_list_prepend(rlist, fd); | |
2264 } | |
2265 } | |
2266 | |
2267 return g_list_reverse(rlist); | |
2268 } | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2269 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2270 static gboolean file_util_delete_dir_empty_path(UtilityData *ud, FileData *fd, gint level) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2271 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2272 GList *dlist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2273 GList *flist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2274 GList *work; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2275 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2276 gboolean ok = TRUE; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2277 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2278 DEBUG_1("deltree into: %s", fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2279 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2280 level++; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2281 if (level > UTILITY_DELETE_MAX_DEPTH) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2282 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2283 log_printf("folder recursion depth past %d, giving up\n", UTILITY_DELETE_MAX_DEPTH); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2284 // ud->fail_fd = fd |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2285 return 0; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2286 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2287 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2288 if (!filelist_read_lstat(fd, &flist, &dlist)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2289 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2290 // ud->fail_fd = fd |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2291 return 0; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2292 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2293 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2294 if (ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2295 { |
921 | 2296 ok = file_data_sc_add_ci_delete(fd); |
2297 if (ok) | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2298 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2299 ud->content_list = g_list_prepend(ud->content_list, fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2300 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2301 // ud->fail_fd = fd |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2302 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2303 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2304 work = dlist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2305 while (work && ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2306 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2307 FileData *lfd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2308 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2309 lfd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2310 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2311 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2312 ok = file_util_delete_dir_empty_path(ud, lfd, level); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2313 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2314 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2315 work = flist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2316 while (work && ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2317 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2318 FileData *lfd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2319 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2320 lfd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2321 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2322 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2323 DEBUG_1("deltree child: %s", lfd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2324 |
921 | 2325 ok = file_data_sc_add_ci_delete(lfd); |
2326 if (ok) | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2327 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2328 ud->content_list = g_list_prepend(ud->content_list, lfd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2329 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2330 // ud->fail_fd = fd |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2331 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2332 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2333 filelist_free(dlist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2334 filelist_free(flist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2335 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2336 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2337 DEBUG_1("deltree done: %s", fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2338 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2339 return ok; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2340 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2341 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2342 static gboolean file_util_delete_dir_prepare(UtilityData *ud, GList *flist, GList *dlist) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2343 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2344 gboolean ok = TRUE; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2345 GList *work; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2346 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2347 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2348 work = dlist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2349 while (work && ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2350 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2351 FileData *fd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2352 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2353 fd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2354 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2355 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2356 ok = file_util_delete_dir_empty_path(ud, fd, 0); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2357 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2358 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2359 work = flist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2360 if (ok && file_data_sc_add_ci_delete_list(flist)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2361 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2362 ud->content_list = g_list_concat(filelist_copy(flist), ud->content_list); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2363 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2364 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2365 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2366 ok = FALSE; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2367 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2368 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2369 if (ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2370 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2371 ok = file_data_sc_add_ci_delete(ud->dir_fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2372 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2373 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2374 if (!ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2375 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2376 work = ud->content_list; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2377 while (work) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2378 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2379 FileData *fd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2380 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2381 fd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2382 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2383 file_data_sc_free_ci(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2384 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2385 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2386 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2387 return ok; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2388 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2389 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2390 static void file_util_delete_dir_full(FileData *fd, GtkWidget *parent, UtilityPhase phase) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2391 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2392 GList *dlist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2393 GList *flist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2394 GList *rlist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2395 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2396 if (!isdir(fd->path)) return; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2397 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2398 if (islink(fd->path)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2399 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2400 UtilityData *ud; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2401 ud = file_util_data_new(UTILITY_TYPE_DELETE_LINK); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2402 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2403 ud->phase = phase; |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2404 ud->with_sidecars = TRUE; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2405 ud->dir_fd = file_data_ref(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2406 ud->content_list = NULL; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2407 ud->flist = NULL; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2408 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2409 ud->parent = parent; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2410 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2411 ud->messages.title = _("Delete folder"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2412 ud->messages.question = _("Delete symbolic link?"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2413 ud->messages.desc_flist = ""; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2414 ud->messages.desc_source_fd = _("This will delete the symbolic link.\n" |
995 | 2415 "The folder this link points to will not be deleted."); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2416 ud->messages.fail = _("Link deletion failed"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2417 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2418 file_util_dialog_run(ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2419 return; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2420 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2421 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2422 if (!access_file(fd->path, W_OK | X_OK)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2423 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2424 gchar *text; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2425 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2426 text = g_strdup_printf(_("Unable to remove folder %s\n" |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2427 "Permissions do not allow writing to the folder."), fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2428 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, parent); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2429 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2430 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2431 return; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2432 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2433 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2434 if (!filelist_read_lstat(fd, &flist, &dlist)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2435 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2436 gchar *text; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2437 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2438 text = g_strdup_printf(_("Unable to list contents of folder %s"), fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2439 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, parent); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2440 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2441 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2442 return; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2443 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2444 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2445 rlist = file_util_delete_dir_remaining_folders(dlist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2446 if (rlist) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2447 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2448 GenericDialog *gd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2449 GtkWidget *box; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2450 gchar *text; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2451 |
1174
0bea79d87065
Drop useless wmclass stuff. Gtk will take care of it and as said in the documentation using gtk_window_set_wmclass() is sort of pointless.
zas_
parents:
1055
diff
changeset
|
2452 gd = file_util_gen_dlg(_("Folder contains subfolders"), "dlg_warning", |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2453 parent, TRUE, NULL, NULL); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2454 generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2455 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2456 text = g_strdup_printf(_("Unable to delete the folder:\n\n%s\n\n" |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2457 "This folder contains subfolders which must be moved before it can be deleted."), |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2458 fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2459 box = generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING, |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2460 _("Folder contains subfolders"), |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2461 text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2462 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2463 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2464 box = pref_group_new(box, TRUE, _("Subfolders:"), GTK_ORIENTATION_VERTICAL); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2465 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2466 rlist = filelist_sort_path(rlist); |
1211 | 2467 file_util_dialog_add_list(box, rlist, FALSE, FALSE); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2468 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2469 gtk_widget_show(gd->dialog); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2470 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2471 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2472 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2473 UtilityData *ud; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2474 ud = file_util_data_new(UTILITY_TYPE_DELETE_FOLDER); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2475 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2476 ud->phase = phase; |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2477 ud->with_sidecars = TRUE; |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2478 ud->dir_fd = file_data_ref(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2479 ud->content_list = NULL; /* will be filled by file_util_delete_dir_prepare */ |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2480 ud->flist = flist = filelist_sort_path(flist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2481 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2482 ud->parent = parent; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2483 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2484 ud->messages.title = _("Delete folder"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2485 ud->messages.question = _("Delete folder?"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2486 ud->messages.desc_flist = _("The folder contains these files:"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2487 ud->messages.desc_source_fd = _("This will delete the folder.\n" |
995 | 2488 "The contents of this folder will also be deleted."); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2489 ud->messages.fail = _("File deletion failed"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2490 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2491 if (!file_util_delete_dir_prepare(ud, flist, dlist)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2492 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2493 gchar *text; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2494 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2495 text = g_strdup_printf(_("Unable to list contents of folder %s"), fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2496 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, parent); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2497 g_free(text); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2498 file_data_unref(ud->dir_fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2499 file_util_data_free(ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2500 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2501 else |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2502 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2503 filelist_free(dlist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2504 file_util_dialog_run(ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2505 return; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2506 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2507 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2508 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2509 g_list_free(rlist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2510 filelist_free(dlist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2511 filelist_free(flist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2512 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2513 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2514 static gboolean file_util_rename_dir_scan(UtilityData *ud, FileData *fd) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2515 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2516 GList *dlist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2517 GList *flist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2518 GList *work; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2519 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2520 gboolean ok = TRUE; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2521 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2522 if (!filelist_read_lstat(fd, &flist, &dlist)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2523 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2524 // ud->fail_fd = fd |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2525 return 0; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2526 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2527 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2528 ud->content_list = g_list_concat(flist, ud->content_list); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2529 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2530 work = dlist; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2531 while (work && ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2532 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2533 FileData *lfd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2534 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2535 lfd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2536 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2537 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2538 ud->content_list = g_list_prepend(ud->content_list, file_data_ref(lfd)); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2539 ok = file_util_rename_dir_scan(ud, lfd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2540 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2541 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2542 filelist_free(dlist); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2543 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2544 return ok; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2545 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2546 |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
995
diff
changeset
|
2547 static gboolean file_util_rename_dir_prepare(UtilityData *ud, const gchar *new_path) |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2548 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2549 gboolean ok; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2550 GList *work; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2551 gint orig_len = strlen(ud->dir_fd->path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2552 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2553 ok = file_util_rename_dir_scan(ud, ud->dir_fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2554 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2555 work = ud->content_list; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2556 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2557 while (ok && work) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2558 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2559 gchar *np; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2560 FileData *fd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2561 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2562 fd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2563 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2564 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2565 g_assert(strncmp(fd->path, ud->dir_fd->path, orig_len) == 0); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2566 |
921 | 2567 np = g_strconcat(new_path, fd->path + orig_len, NULL); |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2568 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2569 ok = file_data_sc_add_ci_rename(fd, np); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2570 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2571 DEBUG_1("Dir rename: %s -> %s", fd->path, np); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2572 g_free(np); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2573 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2574 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2575 if (ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2576 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2577 ok = file_data_sc_add_ci_rename(ud->dir_fd, new_path); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2578 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2579 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2580 if (!ok) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2581 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2582 work = ud->content_list; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2583 while (work) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2584 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2585 FileData *fd; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2586 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2587 fd = work->data; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2588 work = work->next; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2589 file_data_sc_free_ci(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2590 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2591 } |
921 | 2592 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2593 return ok; |
995 | 2594 } |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2595 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2596 |
1637 | 2597 static void file_util_rename_dir_full(FileData *fd, const gchar *new_path, GtkWidget *parent, UtilityPhase phase, FileUtilDoneFunc done_func, gpointer done_data) |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2598 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2599 UtilityData *ud; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2600 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2601 ud = file_util_data_new(UTILITY_TYPE_RENAME_FOLDER); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2602 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2603 ud->phase = phase; |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2604 ud->with_sidecars = TRUE; /* does not matter, the directory should not have sidecars |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2605 and the content must be handled including sidecars */ |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2606 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2607 ud->dir_fd = file_data_ref(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2608 ud->flist = NULL; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2609 ud->content_list = NULL; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2610 ud->parent = parent; |
1637 | 2611 |
2612 ud->done_func = done_func; | |
2613 ud->done_data = done_data; | |
2614 ud->dest_path = g_strdup(new_path); | |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2615 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2616 ud->messages.title = _("Rename"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2617 ud->messages.question = _("Rename folder?"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2618 ud->messages.desc_flist = _("The folder contains the following files"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2619 ud->messages.desc_source_fd = ""; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2620 ud->messages.fail = _("Rename failed"); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2621 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2622 if (!file_util_rename_dir_prepare(ud, new_path)) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2623 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2624 file_util_warn_op_in_progress(ud->messages.fail); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2625 file_util_data_free(ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2626 return; |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2627 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2628 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2629 // ud->flist = filelist_recursive(fd); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2630 |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2631 file_util_dialog_run(ud); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2632 } |
753 | 2633 |
1231 | 2634 static void file_util_create_dir_full(FileData *fd, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase, FileUtilDoneFunc done_func, gpointer done_data) |
1 | 2635 { |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2636 UtilityData *ud; |
901 | 2637 |
2638 ud = file_util_data_new(UTILITY_TYPE_CREATE_FOLDER); | |
2639 | |
2640 ud->phase = phase; | |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2641 ud->with_sidecars = TRUE; |
901 | 2642 |
2643 ud->dir_fd = NULL; | |
2644 ud->flist = NULL; | |
2645 ud->content_list = NULL; | |
2646 ud->parent = parent; | |
2647 | |
995 | 2648 if (dest_path) |
901 | 2649 { |
2650 ud->dest_path = g_strdup(dest_path); | |
2651 } | |
2652 else | |
2653 { | |
2654 gchar *buf = g_build_filename(fd->path, _("New folder"), NULL); | |
2655 ud->dest_path = unique_filename(buf, NULL, " ", FALSE); | |
2656 g_free(buf); | |
2657 } | |
2658 | |
2659 ud->dir_fd = file_data_new_simple(ud->dest_path); | |
1231 | 2660 |
2661 ud->done_func = done_func; | |
2662 ud->done_data = done_data; | |
901 | 2663 |
2664 ud->messages.title = _("Create Folder"); | |
2665 ud->messages.question = _("Create folder?"); | |
2666 ud->messages.desc_flist = ""; | |
2667 ud->messages.desc_source_fd = ""; | |
2668 ud->messages.fail = _("Can't create folder"); | |
2669 | |
2670 file_util_dialog_run(ud); | |
1 | 2671 } |
757 | 2672 |
9 | 2673 |
757 | 2674 /* full-featured entry points |
753 | 2675 */ |
1 | 2676 |
753 | 2677 void file_util_delete(FileData *source_fd, GList *source_list, GtkWidget *parent) |
2678 { | |
1054 | 2679 file_util_delete_full(source_fd, source_list, parent, options->file_ops.confirm_delete ? UTILITY_PHASE_START : UTILITY_PHASE_ENTERING); |
753 | 2680 } |
9 | 2681 |
1586
249b539cc952
force the metadata dialog if it was triggered by the menu or the button
nadvornik
parents:
1581
diff
changeset
|
2682 void file_util_write_metadata(FileData *source_fd, GList *source_list, GtkWidget *parent, gboolean force_dialog, FileUtilDoneFunc done_func, gpointer done_data) |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2683 { |
1211 | 2684 file_util_write_metadata_full(source_fd, source_list, parent, |
1586
249b539cc952
force the metadata dialog if it was triggered by the menu or the button
nadvornik
parents:
1581
diff
changeset
|
2685 ((options->metadata.save_in_image_file && options->metadata.confirm_write) || force_dialog) ? UTILITY_PHASE_START : UTILITY_PHASE_ENTERING, |
1231 | 2686 done_func, done_data); |
1205
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2687 } |
3ff2aa99108b
use the workflow in utilops.c for metadata approving and writting
nadvornik
parents:
1175
diff
changeset
|
2688 |
753 | 2689 void file_util_copy(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent) |
2690 { | |
2691 file_util_copy_full(source_fd, source_list, dest_path, parent, UTILITY_PHASE_START); | |
2692 } | |
757 | 2693 |
753 | 2694 void file_util_move(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent) |
2695 { | |
2696 file_util_move_full(source_fd, source_list, dest_path, parent, UTILITY_PHASE_START); | |
2697 } | |
757 | 2698 |
753 | 2699 void file_util_rename(FileData *source_fd, GList *source_list, GtkWidget *parent) |
2700 { | |
2701 file_util_rename_full(source_fd, source_list, NULL, parent, UTILITY_PHASE_START); | |
1 | 2702 } |
2703 | |
753 | 2704 /* these avoid the location entry dialog unless there is an error, list must be files only and |
2705 * dest_path must be a valid directory path | |
757 | 2706 */ |
753 | 2707 void file_util_move_simple(GList *list, const gchar *dest_path, GtkWidget *parent) |
44
458e396d3f35
Wed May 18 19:36:49 2005 John Ellis <johne@verizon.net>
gqview
parents:
42
diff
changeset
|
2708 { |
753 | 2709 file_util_move_full(NULL, list, dest_path, parent, UTILITY_PHASE_ENTERING); |
2710 } | |
757 | 2711 |
753 | 2712 void file_util_copy_simple(GList *list, const gchar *dest_path, GtkWidget *parent) |
2713 { | |
2714 file_util_copy_full(NULL, list, dest_path, parent, UTILITY_PHASE_ENTERING); | |
2715 } | |
757 | 2716 |
753 | 2717 void file_util_rename_simple(FileData *fd, const gchar *dest_path, GtkWidget *parent) |
2718 { | |
2719 file_util_rename_full(fd, NULL, dest_path, parent, UTILITY_PHASE_ENTERING); | |
2720 } | |
138 | 2721 |
44
458e396d3f35
Wed May 18 19:36:49 2005 John Ellis <johne@verizon.net>
gqview
parents:
42
diff
changeset
|
2722 |
1272 | 2723 void file_util_start_editor_from_file(const gchar *key, FileData *fd, GtkWidget *parent) |
753 | 2724 { |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2725 file_util_start_editor_full(key, fd, NULL, NULL, NULL, parent, UTILITY_PHASE_ENTERING); |
753 | 2726 } |
2727 | |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2728 void file_util_start_editor_from_filelist(const gchar *key, GList *list, const gchar *working_directory, GtkWidget *parent) |
753 | 2729 { |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2730 file_util_start_editor_full(key, NULL, list, NULL, working_directory, parent, UTILITY_PHASE_ENTERING); |
753 | 2731 } |
44
458e396d3f35
Wed May 18 19:36:49 2005 John Ellis <johne@verizon.net>
gqview
parents:
42
diff
changeset
|
2732 |
1272 | 2733 void file_util_start_filter_from_file(const gchar *key, FileData *fd, const gchar *dest_path, GtkWidget *parent) |
753 | 2734 { |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2735 file_util_start_editor_full(key, fd, NULL, dest_path, NULL, parent, UTILITY_PHASE_ENTERING); |
753 | 2736 } |
44
458e396d3f35
Wed May 18 19:36:49 2005 John Ellis <johne@verizon.net>
gqview
parents:
42
diff
changeset
|
2737 |
1272 | 2738 void file_util_start_filter_from_filelist(const gchar *key, GList *list, const gchar *dest_path, GtkWidget *parent) |
753 | 2739 { |
1652
58a5d1e01e33
run external commands from current directory even with no files
nadvornik
parents:
1650
diff
changeset
|
2740 file_util_start_editor_full(key, NULL, list, dest_path, NULL, parent, UTILITY_PHASE_ENTERING); |
753 | 2741 } |
44
458e396d3f35
Wed May 18 19:36:49 2005 John Ellis <johne@verizon.net>
gqview
parents:
42
diff
changeset
|
2742 |
896
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2743 void file_util_delete_dir(FileData *fd, GtkWidget *parent) |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2744 { |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2745 file_util_delete_dir_full(fd, parent, UTILITY_PHASE_START); |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2746 } |
cf21dc928122
implemented directory rename and delete operations
nadvornik
parents:
855
diff
changeset
|
2747 |
1231 | 2748 void file_util_create_dir(FileData *dir_fd, GtkWidget *parent, FileUtilDoneFunc done_func, gpointer done_data) |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
2749 { |
1231 | 2750 file_util_create_dir_full(dir_fd, NULL, parent, UTILITY_PHASE_ENTERING, done_func, done_data); |
901 | 2751 } |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
2752 |
1637 | 2753 void file_util_rename_dir(FileData *source_fd, const gchar *new_path, GtkWidget *parent, FileUtilDoneFunc done_func, gpointer done_data) |
901 | 2754 { |
1637 | 2755 file_util_rename_dir_full(source_fd, new_path, parent, UTILITY_PHASE_ENTERING, done_func, done_data); |
112
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
2756 } |
b15d4c18168f
Fri Nov 17 19:06:19 2006 John Ellis <johne@verizon.net>
gqview
parents:
80
diff
changeset
|
2757 |
753 | 2758 |
2759 void file_util_copy_path_to_clipboard(FileData *fd) | |
2760 { | |
2761 GtkClipboard *clipboard; | |
2762 | |
2763 if (!fd || !*fd->path) return; | |
2764 | |
2765 clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY); | |
2766 gtk_clipboard_set_text(clipboard, g_shell_quote(fd->path), -1); | |
2767 } | |
2768 | |
2769 void file_util_copy_path_list_to_clipboard(GList *list) | |
2770 { | |
2771 GtkClipboard *clipboard; | |
2772 GList *work; | |
2773 GString *new; | |
2774 | |
2775 clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY); | |
2776 | |
2777 new = g_string_new(""); | |
2778 work = list; | |
2779 while (work) { | |
2780 FileData *fd = work->data; | |
2781 work = work->next; | |
2782 | |
2783 if (!fd || !*fd->path) continue; | |
2784 | |
2785 g_string_append(new, g_shell_quote(fd->path)); | |
2786 if (work) g_string_append_c(new, ' '); | |
2787 } | |
2788 | |
2789 gtk_clipboard_set_text(clipboard, new->str, new->len); | |
2790 g_string_free(new, TRUE); | |
1656 | 2791 filelist_free(list); |
753 | 2792 } |
1055
1646720364cf
Adding a vim modeline to all files - patch by Klaus Ethgen
nadvornik
parents:
1054
diff
changeset
|
2793 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ |