« back to all changes in this revision
Viewing changes to src/gnome-cmd-file-selector.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Michael Vogt
- Date: 2006-06-13 15:39:48 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20060613153948-gvrt3mb2ddk5u62o
Tags: 1.2.0-3
added --disable-scrollkeeper on build
- files added:
- BUGS
- data
- doc/C
- doc/C/figures
- m4
- src/libgviewer
- tests
- tests/gviewer
- files removed:
- doc/create_archive.png
- files modified:
- AUTHORS
added
removed
src/gnome-cmd-file-selector.c
1
1
/*
2
GNOME Commander - A GNOME based file manager
2
GNOME Commander - A GNOME based file manager
3
3
Copyright (C) 2001-2006 Marcus Bjurman
4
4
5
5
This program is free software; you can redistribute it and/or modify
44
44
#define FS_PBAR_MAX 50
45
45
46
46
GtkTargetEntry drop_types [] = {
47
{ TARGET_URI_LIST_TYPE, 0, TARGET_URI_LIST },
48
{ TARGET_URL_TYPE, 0, TARGET_URL }
47
{ TARGET_URI_LIST_TYPE, 0, TARGET_URI_LIST },
48
{ TARGET_URL_TYPE, 0, TARGET_URL }
49
49
};
50
50
51
51
static GtkVBoxClass *parent_class = NULL;
52
52
53
53
struct _GnomeCmdFileSelectorPrivate {
54
GtkWidget *filter_box;
55
56
gboolean active;
57
gboolean realized;
58
gboolean selection_lock;
59
gboolean sel_first_file;
60
GnomeCmdCon *con;
61
GnomeCmdDir *cwd, *lwd; // current & last working dir
62
GnomeCmdDir *connected_dir;
63
GList *old_btns;
64
History *dir_history;
65
GnomeCmdFile *sym_file;
66
GtkWidget *con_open_dialog;
67
GtkWidget *con_open_dialog_label;
68
GtkWidget *con_open_dialog_pbar;
69
GnomeCmdCon *con_opening;
70
71
gboolean autoscroll_dir;
72
guint autoscroll_timeout;
73
gint autoscroll_y;
54
GtkWidget *filter_box;
55
56
gboolean active;
57
gboolean realized;
58
gboolean selection_lock;
59
gboolean sel_first_file;
60
GnomeCmdCon *con;
61
GnomeCmdDir *cwd, *lwd; // current & last working dir
62
GnomeCmdDir *connected_dir;
63
GList *old_btns;
64
History *dir_history;
65
GnomeCmdFile *sym_file;
66
GtkWidget *con_open_dialog;
67
GtkWidget *con_open_dialog_label;
68
GtkWidget *con_open_dialog_pbar;
69
GnomeCmdCon *con_opening;
70
71
gboolean autoscroll_dir;
72
guint autoscroll_timeout;
73
gint autoscroll_y;
74
74
};
75
75
76
76
enum {
87
87
static void
88
88
set_same_directory (GnomeCmdFileSelector *fs, GnomeCmdFileSelector *other)
89
89
{
90
GnomeCmdCon *con;
91
GnomeCmdDir *dir;
90
GnomeCmdCon *con;
91
GnomeCmdDir *dir;
92
92
93
con = gnome_cmd_file_selector_get_connection (other);
94
dir = gnome_cmd_file_selector_get_directory (other);
95
if (fs->priv->con != con)
96
gnome_cmd_file_selector_set_connection (fs, con, dir);
97
else
98
gnome_cmd_file_selector_set_directory (fs, dir);
93
con = gnome_cmd_file_selector_get_connection (other);
94
dir = gnome_cmd_file_selector_get_directory (other);
95
if (fs->priv->con != con)
96
gnome_cmd_file_selector_set_connection (fs, con, dir);
97
else
98
gnome_cmd_file_selector_set_directory (fs, dir);
99
99
}
100
100
101
101
102
102
static void
103
103
show_list_popup (GnomeCmdFileSelector *fs)
104
104
{
105
/* create the popup menu */
106
GtkWidget *menu = gnome_cmd_list_popmenu_new (fs);
107
gtk_widget_ref (menu);
105
/* create the popup menu */
106
GtkWidget *menu = gnome_cmd_list_popmenu_new (fs);
107
gtk_widget_ref (menu);
108
108
109
gtk_menu_popup (GTK_MENU(menu), NULL, NULL,
110
NULL, fs,
111
3, GDK_CURRENT_TIME);
109
gtk_menu_popup (GTK_MENU(menu), NULL, NULL,
110
NULL, fs,
111
3, GDK_CURRENT_TIME);
112
112
}
113
113
114
114
115
115
static void
116
116
show_selected_dir_tree_size (GnomeCmdFileSelector *fs)
117
117
{
118
GnomeCmdFile *finfo;
119
120
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
121
122
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
123
gnome_cmd_file_list_show_dir_size (fs->list, finfo);
118
GnomeCmdFile *finfo;
119
120
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
121
122
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
123
gnome_cmd_file_list_show_dir_size (fs->list, finfo);
124
124
}
125
125
126
126
127
127
static void
128
128
show_dir_tree_sizes (GnomeCmdFileSelector *fs)
129
129
{
130
GList *files;
131
132
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
133
134
files = gnome_cmd_file_list_get_all_files (fs->list);
135
while (files) {
136
gnome_cmd_file_list_show_dir_size (fs->list, (GnomeCmdFile*)files->data);
137
files = files->next;
138
}
130
GList *files;
131
132
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
133
134
files = gnome_cmd_file_list_get_all_files (fs->list);
135
while (files) {
136
gnome_cmd_file_list_show_dir_size (fs->list, (GnomeCmdFile*)files->data);
137
files = files->next;
138
}
139
139
}
140
140
141
141
142
142
static void
143
143
update_selected_files_label (GnomeCmdFileSelector *fs)
144
144
{
145
GList *all_files;
146
147
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
148
149
all_files = gnome_cmd_file_list_get_all_files (fs->list);
150
if (!all_files)
151
return;
152
153
if (g_list_length (all_files) >= 0)
154
{
155
GList *sel_files, *tmp;
156
gchar *info_str, *sel_str, *total_str;
157
GnomeVFSFileSize sel_kb, sel_bytes = 0;
158
GnomeVFSFileSize total_kb, total_bytes = 0;
159
gint num_files = 0;
160
gint num_sel_files = 0;
161
162
tmp = all_files;
163
while (tmp)
164
{
165
GnomeCmdFile *finfo = (GnomeCmdFile*)tmp->data;
166
if (finfo->info->type == GNOME_VFS_FILE_TYPE_REGULAR) {
167
total_bytes += finfo->info->size;
168
num_files++;
169
}
170
tmp = tmp->next;
171
}
172
173
sel_files = gnome_cmd_file_list_get_marked_files (fs->list);
174
tmp = sel_files;
175
while (tmp)
176
{
177
GnomeCmdFile *finfo = (GnomeCmdFile*)tmp->data;
178
if (finfo->info->type == GNOME_VFS_FILE_TYPE_REGULAR) {
179
sel_bytes += finfo->info->size;
180
num_sel_files++;
181
}
182
tmp = tmp->next;
183
}
184
185
sel_kb = sel_bytes / 1024;
186
total_kb = total_bytes / 1024;
187
188
sel_str = g_strdup (size2string (sel_kb, GNOME_CMD_SIZE_DISP_MODE_GROUPED));
189
total_str = g_strdup (size2string (total_kb, GNOME_CMD_SIZE_DISP_MODE_GROUPED));
190
191
info_str = g_strdup_printf (
192
ngettext("%s of %s kB in %d of %d file selected",
193
"%s of %s kB in %d of %d files selected",
194
num_sel_files),
195
sel_str, total_str, num_sel_files, num_files);
196
197
gtk_label_set_text (GTK_LABEL (fs->info_label), info_str);
198
199
if (sel_files)
200
g_list_free (sel_files);
201
202
g_free (sel_str);
203
g_free (total_str);
204
g_free (info_str);
205
}
145
GList *all_files;
146
147
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
148
149
all_files = gnome_cmd_file_list_get_all_files (fs->list);
150
if (!all_files)
151
return;
152
153
if (g_list_length (all_files) >= 0)
154
{
155
GList *sel_files, *tmp;
156
gchar *info_str, *sel_str, *total_str;
157
GnomeVFSFileSize sel_kb, sel_bytes = 0;
158
GnomeVFSFileSize total_kb, total_bytes = 0;
159
gint num_files = 0;
160
gint num_sel_files = 0;
161
162
tmp = all_files;
163
while (tmp)
164
{
165
GnomeCmdFile *finfo = (GnomeCmdFile*)tmp->data;
166
if (finfo->info->type == GNOME_VFS_FILE_TYPE_REGULAR) {
167
total_bytes += finfo->info->size;
168
num_files++;
169
}
170
tmp = tmp->next;
171
}
172
173
sel_files = gnome_cmd_file_list_get_marked_files (fs->list);
174
tmp = sel_files;
175
while (tmp)
176
{
177
GnomeCmdFile *finfo = (GnomeCmdFile*)tmp->data;
178
if (finfo->info->type == GNOME_VFS_FILE_TYPE_REGULAR) {
179
sel_bytes += finfo->info->size;
180
num_sel_files++;
181
}
182
tmp = tmp->next;
183
}
184
185
sel_kb = sel_bytes / 1024;
186
total_kb = total_bytes / 1024;
187
188
sel_str = g_strdup (size2string (sel_kb, GNOME_CMD_SIZE_DISP_MODE_GROUPED));
189
total_str = g_strdup (size2string (total_kb, GNOME_CMD_SIZE_DISP_MODE_GROUPED));
190
191
info_str = g_strdup_printf (
192
ngettext("%s of %s kB in %d of %d file selected",
193
"%s of %s kB in %d of %d files selected",
194
num_files),
195
sel_str, total_str, num_sel_files, num_files);
196
197
gtk_label_set_text (GTK_LABEL (fs->info_label), info_str);
198
199
if (sel_files)
200
g_list_free (sel_files);
201
202
g_free (sel_str);
203
g_free (total_str);
204
g_free (info_str);
205
}
206
206
}
207
207
208
208
209
209
static void
210
210
set_connection (GnomeCmdFileSelector *fs, GnomeCmdCon *con, GnomeCmdDir *dir)
211
211
{
212
fs->priv->con = con;
213
fs->priv->dir_history = gnome_cmd_con_get_dir_history (con);
214
215
if (fs->priv->lwd) {
216
gnome_cmd_dir_cancel_monitoring (fs->priv->lwd);
217
gnome_cmd_dir_unref (fs->priv->lwd);
218
fs->priv->lwd = NULL;
219
}
220
if (fs->priv->cwd) {
221
gnome_cmd_dir_cancel_monitoring (fs->priv->cwd);
222
gnome_cmd_dir_unref (fs->priv->cwd);
223
fs->priv->cwd = NULL;
224
}
225
226
if (dir) {
227
gnome_cmd_file_selector_set_directory (fs, dir);
228
}
229
else if (gnome_cmd_con_should_remember_dir (con)) {
230
dir = gnome_cmd_con_get_cwd (con);
231
gnome_cmd_file_selector_set_directory (fs, dir);
232
}
233
else {
234
dir = gnome_cmd_con_get_default_dir (con);
235
gnome_cmd_file_selector_set_directory (fs, dir);
236
}
237
238
gnome_cmd_combo_select_data (GNOME_CMD_COMBO (fs->con_combo), con);
212
fs->priv->con = con;
213
fs->priv->dir_history = gnome_cmd_con_get_dir_history (con);
214
215
if (fs->priv->lwd) {
216
gnome_cmd_dir_cancel_monitoring (fs->priv->lwd);
217
gnome_cmd_dir_unref (fs->priv->lwd);
218
fs->priv->lwd = NULL;
219
}
220
if (fs->priv->cwd) {
221
gnome_cmd_dir_cancel_monitoring (fs->priv->cwd);
222
gnome_cmd_dir_unref (fs->priv->cwd);
223
fs->priv->cwd = NULL;
224
}
225
226
if (dir) {
227
gnome_cmd_file_selector_set_directory (fs, dir);
228
}
229
else if (gnome_cmd_con_should_remember_dir (con)) {
230
dir = gnome_cmd_con_get_cwd (con);
231
gnome_cmd_file_selector_set_directory (fs, dir);
232
}
233
else {
234
dir = gnome_cmd_con_get_default_dir (con);
235
gnome_cmd_file_selector_set_directory (fs, dir);
236
}
237
238
gnome_cmd_combo_select_data (GNOME_CMD_COMBO (fs->con_combo), con);
239
239
}
240
240
241
241
242
242
static gboolean
243
243
file_is_wanted (GnomeCmdFileSelector *fs, GnomeVFSFileInfo *info)
244
244
{
245
if (info->type == GNOME_VFS_FILE_TYPE_UNKNOWN
246
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_UNKNOWN))
247
return FALSE;
248
if (info->type == GNOME_VFS_FILE_TYPE_REGULAR
249
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_REGULAR))
250
return FALSE;
251
if (info->type == GNOME_VFS_FILE_TYPE_DIRECTORY
252
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_DIRECTORY))
253
return FALSE;
254
if (info->type == GNOME_VFS_FILE_TYPE_FIFO
255
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_FIFO))
256
return FALSE;
257
if (info->type == GNOME_VFS_FILE_TYPE_SOCKET
258
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_SOCKET))
259
return FALSE;
260
if (info->type == GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE
261
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE))
262
return FALSE;
263
if (info->type == GNOME_VFS_FILE_TYPE_BLOCK_DEVICE
264
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_BLOCK_DEVICE))
265
return FALSE;
266
if ((info->flags == GNOME_VFS_FILE_FLAGS_SYMLINK
267
|| info->symlink_name != NULL)
268
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK))
269
return FALSE;
270
if (strcmp (info->name, ".") == 0)
271
return FALSE;
272
if (strcmp (info->name, "..") == 0)
273
return FALSE;
274
if (info->name[0] == '.'
275
&& gnome_cmd_data_get_hidden_filter ())
276
return FALSE;
277
if (gnome_cmd_data_get_backup_filter () &&
278
patlist_matches (gnome_cmd_data_get_backup_pattern_list (), info->name))
279
return FALSE;
245
if (info->type == GNOME_VFS_FILE_TYPE_UNKNOWN
246
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_UNKNOWN))
247
return FALSE;
248
if (info->type == GNOME_VFS_FILE_TYPE_REGULAR
249
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_REGULAR))
250
return FALSE;
251
if (info->type == GNOME_VFS_FILE_TYPE_DIRECTORY
252
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_DIRECTORY))
253
return FALSE;
254
if (info->type == GNOME_VFS_FILE_TYPE_FIFO
255
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_FIFO))
256
return FALSE;
257
if (info->type == GNOME_VFS_FILE_TYPE_SOCKET
258
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_SOCKET))
259
return FALSE;
260
if (info->type == GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE
261
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE))
262
return FALSE;
263
if (info->type == GNOME_VFS_FILE_TYPE_BLOCK_DEVICE
264
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_BLOCK_DEVICE))
265
return FALSE;
266
if ((info->flags == GNOME_VFS_FILE_FLAGS_SYMLINK
267
|| info->symlink_name != NULL)
268
&& gnome_cmd_data_get_type_filter (GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK))
269
return FALSE;
270
if (strcmp (info->name, ".") == 0)
271
return FALSE;
272
if (strcmp (info->name, "..") == 0)
273
return FALSE;
274
if (info->name[0] == '.'
275
&& gnome_cmd_data_get_hidden_filter ())
276
return FALSE;
277
if (gnome_cmd_data_get_backup_filter () &&
278
patlist_matches (gnome_cmd_data_get_backup_pattern_list (), info->name))
279
return FALSE;
280
280
281
return TRUE;
281
return TRUE;
282
282
}
283
283
284
284
285
285
static GnomeCmdFile *
286
286
create_parent_dir_file (GnomeCmdDir *dir)
287
287
{
288
GnomeCmdFile *finfo;
289
GnomeVFSFileInfo *info = gnome_vfs_file_info_new ();
290
memset (info, '\0', sizeof (GnomeVFSFileInfo));
291
info->name = g_strdup ("..");
292
info->type = GNOME_VFS_FILE_TYPE_DIRECTORY;
293
info->mime_type = g_strdup ("x-directory/normal");
294
info->size = 0;
295
info->refcount = 1;
296
info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE
297
| GNOME_VFS_FILE_INFO_FIELDS_SIZE
298
| GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE;
299
finfo = gnome_cmd_file_new (info, dir);
300
return finfo;
288
GnomeCmdFile *finfo;
289
GnomeVFSFileInfo *info = gnome_vfs_file_info_new ();
290
memset (info, '\0', sizeof (GnomeVFSFileInfo));
291
info->name = g_strdup ("..");
292
info->type = GNOME_VFS_FILE_TYPE_DIRECTORY;
293
info->mime_type = g_strdup ("x-directory/normal");
294
info->size = 0;
295
info->refcount = 1;
296
info->valid_fields = GNOME_VFS_FILE_INFO_FIELDS_TYPE
297
| GNOME_VFS_FILE_INFO_FIELDS_SIZE
298
| GNOME_VFS_FILE_INFO_FIELDS_MIME_TYPE;
299
finfo = gnome_cmd_file_new (info, dir);
300
return finfo;
301
301
}
302
302
303
303
304
304
static void
305
305
update_files (GnomeCmdFileSelector *fs)
306
306
{
307
GList *list;
308
GList *list2 = NULL;
309
GnomeCmdDir *dir;
310
gchar *path;
311
312
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
313
314
dir = gnome_cmd_file_selector_get_directory (fs);
315
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
316
317
// if (gnome_cmd_con_open_is_needed (fs->priv->con))
318
// gnome_cmd_con_open (fs->priv->con);
319
320
gnome_cmd_dir_get_files (dir, &list);
321
322
// if (!list) {
323
// create_error_dialog (_("Failed to load directory"));
324
// return;
325
// }
326
327
/* sort out the files to show */
328
while (list != NULL) {
329
GnomeCmdFile *finfo = GNOME_CMD_FILE (list->data);
330
331
if (file_is_wanted (fs, finfo->info))
332
list2 = g_list_append (list2, finfo);
333
334
list = list->next;
335
}
336
337
/* Create a parent dir file (..) if appropriate */
338
path = gnome_cmd_file_get_path (GNOME_CMD_FILE (dir));
339
if (path && strcmp (path, "/") != 0)
340
list2 = g_list_append (list2, create_parent_dir_file (dir));
341
g_free (path);
342
343
gnome_cmd_file_list_show_files (fs->list, list2, TRUE);
344
gnome_cmd_clist_set_voffset (GNOME_CMD_CLIST (fs->list), fs->priv->cwd->voffset);
345
346
if (fs->priv->realized)
347
update_selected_files_label (fs);
348
if (fs->priv->active)
349
gnome_cmd_file_list_select_row (fs->list, 0);
350
351
if (list2)
352
g_list_free (list2);
307
GList *list;
308
GList *list2 = NULL;
309
GnomeCmdDir *dir;
310
gchar *path;
311
312
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
313
314
dir = gnome_cmd_file_selector_get_directory (fs);
315
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
316
317
// if (gnome_cmd_con_open_is_needed (fs->priv->con))
318
// gnome_cmd_con_open (fs->priv->con);
319
320
gnome_cmd_dir_get_files (dir, &list);
321
322
// if (!list) {
323
// create_error_dialog (_("Failed to load directory"));
324
// return;
325
// }
326
327
/* sort out the files to show */
328
while (list != NULL) {
329
GnomeCmdFile *finfo = GNOME_CMD_FILE (list->data);
330
331
if (file_is_wanted (fs, finfo->info))
332
list2 = g_list_append (list2, finfo);
333
334
list = list->next;
335
}
336
337
/* Create a parent dir file (..) if appropriate */
338
path = gnome_cmd_file_get_path (GNOME_CMD_FILE (dir));
339
if (path && strcmp (path, "/") != 0)
340
list2 = g_list_append (list2, create_parent_dir_file (dir));
341
g_free (path);
342
343
gnome_cmd_file_list_show_files (fs->list, list2, TRUE);
344
gnome_cmd_clist_set_voffset (GNOME_CMD_CLIST (fs->list), fs->priv->cwd->voffset);
345
346
if (fs->priv->realized)
347
update_selected_files_label (fs);
348
if (fs->priv->active)
349
gnome_cmd_file_list_select_row (fs->list, 0);
350
351
if (list2)
352
g_list_free (list2);
353
353
}
354
354
355
355
356
356
static void update_direntry (GnomeCmdFileSelector *fs)
357
357
{
358
gchar *tmp;
359
360
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
361
362
tmp = gnome_cmd_dir_get_display_path (fs->priv->cwd);
363
g_return_if_fail (tmp != NULL);
364
365
gnome_cmd_dir_indicator_set_dir (
366
GNOME_CMD_DIR_INDICATOR (fs->dir_indicator), tmp);
367
368
g_free (tmp);
358
gchar *tmp;
359
360
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
361
362
tmp = gnome_cmd_dir_get_display_path (fs->priv->cwd);
363
g_return_if_fail (tmp != NULL);
364
365
gnome_cmd_dir_indicator_set_dir (GNOME_CMD_DIR_INDICATOR (fs->dir_indicator), tmp);
366
367
g_free (tmp);
369
368
}
370
369
371
370
372
371
void
373
372
gnome_cmd_file_list_show_make_copy_dialog (GnomeCmdFileSelector *fs)
374
373
{
375
GnomeCmdFile *finfo;
376
377
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
378
379
finfo = gnome_cmd_file_list_get_selected_file (
380
GNOME_CMD_FILE_LIST (fs->list));
381
382
if (GNOME_CMD_IS_FILE (finfo)) {
383
GtkWidget *dialog = gnome_cmd_make_copy_dialog_new (finfo, fs->priv->cwd);
384
385
gtk_widget_ref (dialog);
386
gtk_widget_show (dialog);
387
}
374
GnomeCmdFile *finfo;
375
376
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
377
378
finfo = gnome_cmd_file_list_get_selected_file (
379
GNOME_CMD_FILE_LIST (fs->list));
380
381
if (GNOME_CMD_IS_FILE (finfo)) {
382
GtkWidget *dialog = gnome_cmd_make_copy_dialog_new (finfo, fs->priv->cwd);
383
384
gtk_widget_ref (dialog);
385
gtk_widget_show (dialog);
386
}
388
387
}
389
388
390
389
395
394
static void
396
395
restore_drag_indicator (GnomeCmdFileSelector *fs)
397
396
{
398
gnome_cmd_clist_set_drag_row (GNOME_CMD_CLIST (fs->list), -1);
397
gnome_cmd_clist_set_drag_row (GNOME_CMD_CLIST (fs->list), -1);
399
398
}
400
399
401
400
402
401
static void
403
402
unref_uri_list (GList *list)
404
403
{
405
g_return_if_fail (list != NULL);
406
407
g_list_foreach (list, (GFunc)gnome_vfs_uri_unref, NULL);
404
g_return_if_fail (list != NULL);
405
406
g_list_foreach (list, (GFunc)gnome_vfs_uri_unref, NULL);
408
407
}
409
408
410
409
411
410
static void
412
411
drag_data_received (GtkWidget *widget,
413
GdkDragContext *context,
414
gint x,
415
gint y,
416
GtkSelectionData *selection_data,
417
guint info,
418
guint32 time,
419
GnomeCmdFileSelector *fs)
412
GdkDragContext *context,
413
gint x,
414
gint y,
415
GtkSelectionData *selection_data,
416
guint info,
417
guint32 time,
418
GnomeCmdFileSelector *fs)
420
419
{
421
GnomeCmdFile *finfo;
422
GtkCList *clist;
423
GnomeCmdDir *to, *cwd;
424
GList *uri_list = NULL;
425
gchar *to_fn = NULL;
426
int row;
427
GnomeVFSXferOptions xferOptions;
428
429
clist = GTK_CLIST (fs->list);
430
431
432
/* Find out what operation to perform
433
*
434
*/
435
if (context->action == GDK_ACTION_MOVE)
436
xferOptions = GNOME_VFS_XFER_REMOVESOURCE;
437
else if (context->action == GDK_ACTION_COPY)
438
xferOptions = GNOME_VFS_XFER_RECURSIVE;
439
else {
440
warn_print ("Unknown context->action in drag_data_received\n");
441
return;
442
}
443
444
445
/* Find the row that the file was dropped on
446
*
447
*/
448
y -= (clist->column_title_area.height - GTK_CONTAINER (clist)->border_width);
449
if (y < 0) return;
450
row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), x, y);
451
452
/* Transform the drag data to a list with uris
453
*
454
*/
455
uri_list = strings_to_uris (selection_data->data);
456
457
if (g_list_length (uri_list) == 1) {
458
GnomeVFSURI *uri = (GnomeVFSURI*)uri_list->data;
459
to_fn = gnome_vfs_unescape_string (gnome_vfs_uri_extract_short_name (uri), 0);
460
}
461
462
finfo = gnome_cmd_file_list_get_file_at_row (fs->list, row);
463
cwd = gnome_cmd_file_selector_get_directory (fs);
464
465
if (finfo && finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY) {
466
/* The drop was over a directory in the list, which means that the
467
* xfer should be done to that directory instead of the current one in the list
468
*/
469
if (strcmp (finfo->info->name, "..") == 0 )
470
to = gnome_cmd_dir_get_parent (cwd);
471
else
472
to = gnome_cmd_dir_get_child (cwd, finfo->info->name);
473
}
474
else
475
to = cwd;
476
477
g_return_if_fail (GNOME_CMD_IS_DIR (to));
478
479
gnome_cmd_dir_ref (to);
480
481
/* Start the xfer
482
*
483
*/
484
gnome_cmd_xfer_uris_start (uri_list,
485
to,
486
NULL,
487
NULL,
488
to_fn,
489
xferOptions,
490
GNOME_VFS_XFER_OVERWRITE_MODE_QUERY,
491
GTK_SIGNAL_FUNC (unref_uri_list),
492
uri_list);
420
GnomeCmdFile *finfo;
421
GtkCList *clist;
422
GnomeCmdDir *to, *cwd;
423
GList *uri_list = NULL;
424
gchar *to_fn = NULL;
425
int row;
426
GnomeVFSXferOptions xferOptions;
427
428
clist = GTK_CLIST (fs->list);
429
430
431
/* Find out what operation to perform
432
*
433
*/
434
if (context->action == GDK_ACTION_MOVE)
435
xferOptions = GNOME_VFS_XFER_REMOVESOURCE;
436
else if (context->action == GDK_ACTION_COPY)
437
xferOptions = GNOME_VFS_XFER_RECURSIVE;
438
else {
439
warn_print ("Unknown context->action in drag_data_received\n");
440
return;
441
}
442
443
444
/* Find the row that the file was dropped on
445
*
446
*/
447
y -= (clist->column_title_area.height - GTK_CONTAINER (clist)->border_width);
448
if (y < 0) return;
449
row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), x, y);
450
451
/* Transform the drag data to a list with uris
452
*
453
*/
454
uri_list = strings_to_uris (selection_data->data);
455
456
if (g_list_length (uri_list) == 1) {
457
GnomeVFSURI *uri = (GnomeVFSURI*)uri_list->data;
458
to_fn = gnome_vfs_unescape_string (gnome_vfs_uri_extract_short_name (uri), 0);
459
}
460
461
finfo = gnome_cmd_file_list_get_file_at_row (fs->list, row);
462
cwd = gnome_cmd_file_selector_get_directory (fs);
463
464
if (finfo && finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY) {
465
/* The drop was over a directory in the list, which means that the
466
* xfer should be done to that directory instead of the current one in the list
467
*/
468
if (strcmp (finfo->info->name, "..") == 0 )
469
to = gnome_cmd_dir_get_parent (cwd);
470
else
471
to = gnome_cmd_dir_get_child (cwd, finfo->info->name);
472
}
473
else
474
to = cwd;
475
476
g_return_if_fail (GNOME_CMD_IS_DIR (to));
477
478
gnome_cmd_dir_ref (to);
479
480
/* Start the xfer
481
*
482
*/
483
gnome_cmd_xfer_uris_start (uri_list,
484
to,
485
NULL,
486
NULL,
487
to_fn,
488
xferOptions,
489
GNOME_VFS_XFER_OVERWRITE_MODE_QUERY,
490
GTK_SIGNAL_FUNC (unref_uri_list),
491
uri_list);
493
492
}
494
493
495
494
502
501
static void
503
502
drag_end (GtkWidget *widget, GdkDragContext *context, GnomeCmdFileSelector *fs)
504
503
{
505
restore_drag_indicator (fs);
504
restore_drag_indicator (fs);
506
505
}
507
506
508
507
509
508
static void
510
509
drag_leave (GtkWidget *widget, GdkDragContext *context, guint time, GnomeCmdFileSelector *fs)
511
510
{
512
if (fs->priv->autoscroll_timeout > 0) {
513
gtk_timeout_remove (fs->priv->autoscroll_timeout);
514
fs->priv->autoscroll_timeout = 0;
515
}
516
517
restore_drag_indicator (fs);
511
if (fs->priv->autoscroll_timeout > 0) {
512
gtk_timeout_remove (fs->priv->autoscroll_timeout);
513
fs->priv->autoscroll_timeout = 0;
514
}
515
516
restore_drag_indicator (fs);
518
517
}
519
518
520
519
521
520
static void
522
521
drag_data_delete (GtkWidget *widget,
523
GdkDragContext *drag_context,
524
GnomeCmdFileSelector *fs)
522
GdkDragContext *drag_context,
523
GnomeCmdFileSelector *fs)
525
524
{
526
GnomeCmdDir *dir;
527
528
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
529
530
dir = gnome_cmd_file_selector_get_directory (fs);
531
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
532
533
GList *files = gnome_cmd_file_list_get_selected_files (fs->list);
534
gnome_cmd_file_list_remove_files (fs->list, files);
535
g_list_free (files);
525
GnomeCmdDir *dir;
526
527
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
528
529
dir = gnome_cmd_file_selector_get_directory (fs);
530
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
531
532
GList *files = gnome_cmd_file_list_get_selected_files (fs->list);
533
gnome_cmd_file_list_remove_files (fs->list, files);
534
g_list_free (files);
536
535
}
537
536
538
537
539
538
static gboolean
540
539
do_scroll (GnomeCmdFileSelector *fs)
541
540
{
542
gint w, h;
543
gint focus_row, top_row, bottom_row;
544
gint row_count;
545
guint offset;
546
gint row_height;
547
GtkCList *clist = GTK_CLIST (fs->list);
548
549
gdk_window_get_size (GTK_WIDGET (clist)->window, &w, &h);
550
551
offset = (0-clist->voffset);
552
row_height = gnome_cmd_data_get_list_row_height();
553
row_count = clist->rows;
554
focus_row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), 1, fs->priv->autoscroll_y);
555
top_row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), 1, 0);
556
bottom_row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), 1, h);
557
558
if (!fs->priv->autoscroll_dir) {
559
if (focus_row > 0) {
560
gtk_clist_moveto (clist, top_row-1, 0, 0, 0);
561
}
562
else
563
return FALSE;
564
}
565
else {
566
if (focus_row < row_count) {
567
gtk_clist_moveto (clist, top_row+1, 0, 0, 0);
568
}
569
else
570
return FALSE;
571
}
572
573
return TRUE;
541
gint w, h;
542
gint focus_row, top_row, bottom_row;
543
gint row_count;
544
guint offset;
545
gint row_height;
546
GtkCList *clist = GTK_CLIST (fs->list);
547
548
gdk_window_get_size (GTK_WIDGET (clist)->window, &w, &h);
549
550
offset = (0-clist->voffset);
551
row_height = gnome_cmd_data_get_list_row_height();
552
row_count = clist->rows;
553
focus_row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), 1, fs->priv->autoscroll_y);
554
top_row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), 1, 0);
555
bottom_row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), 1, h);
556
557
if (!fs->priv->autoscroll_dir) {
558
if (focus_row > 0) {
559
gtk_clist_moveto (clist, top_row-1, 0, 0, 0);
560
}
561
else
562
return FALSE;
563
}
564
else {
565
if (focus_row < row_count) {
566
gtk_clist_moveto (clist, top_row+1, 0, 0, 0);
567
}
568
else
569
return FALSE;
570
}
571
572
return TRUE;
574
573
}
575
574
576
575
577
576
static void
578
577
autoscroll_if_appropriate (GnomeCmdFileSelector *fs, gint x, gint y)
579
578
{
580
gint w, h;
581
gint smin, smax;
582
guint offset;
583
GtkCList *clist = GTK_CLIST (fs->list);
584
585
if (y < 0) return;
586
587
gdk_window_get_size (GTK_WIDGET (clist)->window, &w, &h);
588
589
offset = (0-clist->voffset);
590
smin = h/8;
591
smax = h-smin;
592
593
if (y < smin) {
594
if (fs->priv->autoscroll_timeout) return;
595
fs->priv->autoscroll_dir = FALSE;
596
fs->priv->autoscroll_y = y;
597
fs->priv->autoscroll_timeout =
598
gtk_timeout_add (gnome_cmd_data_get_gui_update_rate (), (GtkFunction)do_scroll, fs);
599
}
600
else if (y > smax) {
601
if (fs->priv->autoscroll_timeout) return;
602
fs->priv->autoscroll_dir = TRUE;
603
fs->priv->autoscroll_y = y;
604
fs->priv->autoscroll_timeout =
605
gtk_timeout_add (gnome_cmd_data_get_gui_update_rate (), (GtkFunction)do_scroll, fs);
606
}
607
else {
608
if (fs->priv->autoscroll_timeout > 0) {
609
gtk_timeout_remove (fs->priv->autoscroll_timeout);
610
fs->priv->autoscroll_timeout = 0;
611
}
612
}
579
gint w, h;
580
gint smin, smax;
581
guint offset;
582
GtkCList *clist = GTK_CLIST (fs->list);
583
584
if (y < 0) return;
585
586
gdk_window_get_size (GTK_WIDGET (clist)->window, &w, &h);
587
588
offset = (0-clist->voffset);
589
smin = h/8;
590
smax = h-smin;
591
592
if (y < smin) {
593
if (fs->priv->autoscroll_timeout) return;
594
fs->priv->autoscroll_dir = FALSE;
595
fs->priv->autoscroll_y = y;
596
fs->priv->autoscroll_timeout = gtk_timeout_add (gnome_cmd_data_get_gui_update_rate (), (GtkFunction)do_scroll, fs);
597
}
598
else if (y > smax) {
599
if (fs->priv->autoscroll_timeout) return;
600
fs->priv->autoscroll_dir = TRUE;
601
fs->priv->autoscroll_y = y;
602
fs->priv->autoscroll_timeout =
603
gtk_timeout_add (gnome_cmd_data_get_gui_update_rate (), (GtkFunction)do_scroll, fs);
604
}
605
else {
606
if (fs->priv->autoscroll_timeout > 0) {
607
gtk_timeout_remove (fs->priv->autoscroll_timeout);
608
fs->priv->autoscroll_timeout = 0;
609
}
610
}
613
611
}
614
612
615
613
616
614
static gboolean
617
615
drag_motion (GtkWidget *widget,
618
GdkDragContext *context,
619
gint x, gint y,
620
guint time,
621
GnomeCmdFileSelector *fs)
616
GdkDragContext *context,
617
gint x, gint y,
618
guint time,
619
GnomeCmdFileSelector *fs)
622
620
{
623
gint row;
624
GtkCList *clist;
625
626
gdk_drag_status (context, context->suggested_action, time);
627
628
clist = GTK_CLIST (fs->list);
629
630
y -= (clist->column_title_area.height - GTK_CONTAINER (clist)->border_width);
631
632
row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), x, y);
633
634
if (row > -1) {
635
GnomeCmdFile *finfo = gnome_cmd_file_list_get_file_at_row (fs->list, row);
636
if (finfo->info->type != GNOME_VFS_FILE_TYPE_DIRECTORY)
637
row = -1;
638
639
gnome_cmd_clist_set_drag_row (GNOME_CMD_CLIST (clist), row);
640
}
641
642
autoscroll_if_appropriate (fs, x, y);
643
644
return FALSE;
621
gint row;
622
GtkCList *clist;
623
624
gdk_drag_status (context, context->suggested_action, time);
625
626
clist = GTK_CLIST (fs->list);
627
628
y -= (clist->column_title_area.height - GTK_CONTAINER (clist)->border_width);
629
630
row = gnome_cmd_clist_get_row (GNOME_CMD_CLIST (fs->list), x, y);
631
632
if (row > -1) {
633
GnomeCmdFile *finfo = gnome_cmd_file_list_get_file_at_row (fs->list, row);
634
if (finfo->info->type != GNOME_VFS_FILE_TYPE_DIRECTORY)
635
row = -1;
636
637
gnome_cmd_clist_set_drag_row (GNOME_CMD_CLIST (clist), row);
638
}
639
640
autoscroll_if_appropriate (fs, x, y);
641
642
return FALSE;
645
643
}
646
644
647
645
648
646
static void
649
647
init_dnd (GnomeCmdFileSelector *fs)
650
648
{
651
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
652
653
654
/* Set up drag source */
655
656
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_begin",
657
GTK_SIGNAL_FUNC (drag_begin), fs);
658
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_end",
659
GTK_SIGNAL_FUNC (drag_end), fs);
660
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_leave",
661
GTK_SIGNAL_FUNC (drag_leave), fs);
662
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_data_delete",
663
GTK_SIGNAL_FUNC (drag_data_delete), fs);
664
665
/* Set up drag destination */
666
667
gtk_drag_dest_set (GTK_WIDGET (fs->list),
668
GTK_DEST_DEFAULT_DROP,
669
drop_types, ELEMENTS (drop_types),
670
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK);
671
672
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_motion",
673
GTK_SIGNAL_FUNC (drag_motion), fs);
674
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_leave",
675
GTK_SIGNAL_FUNC (drag_leave), fs);
676
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_data_received",
677
GTK_SIGNAL_FUNC (drag_data_received), fs);
649
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
650
651
652
/* Set up drag source */
653
654
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_begin", GTK_SIGNAL_FUNC (drag_begin), fs);
655
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_end", GTK_SIGNAL_FUNC (drag_end), fs);
656
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_leave", GTK_SIGNAL_FUNC (drag_leave), fs);
657
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_data_delete", GTK_SIGNAL_FUNC (drag_data_delete), fs);
658
659
/* Set up drag destination */
660
661
gtk_drag_dest_set (GTK_WIDGET (fs->list),
662
GTK_DEST_DEFAULT_DROP,
663
drop_types, ELEMENTS (drop_types),
664
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK);
665
666
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_motion", GTK_SIGNAL_FUNC (drag_motion), fs);
667
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_leave", GTK_SIGNAL_FUNC (drag_leave), fs);
668
gtk_signal_connect (GTK_OBJECT (fs->list), "drag_data_received", GTK_SIGNAL_FUNC (drag_data_received), fs);
678
669
}
679
670
680
671
681
672
static void
682
673
update_dir_combo (GnomeCmdFileSelector *fs)
683
674
{/*
684
GList *tmp;
685
686
if (!fs->priv->dir_history) return;
687
688
tmp = fs->priv->dir_history->ents;
689
690
gnome_cmd_combo_clear (GNOME_CMD_COMBO (fs->dir_combo));
691
692
while (tmp) {
693
gchar *text[2];
694
695
text[0] = (gchar*)tmp->data;
696
text[1] = NULL;
697
698
gnome_cmd_combo_append (GNOME_CMD_COMBO (fs->dir_combo), text, tmp->data);
699
tmp = tmp->next;
700
}
701
702
if (fs->priv->dir_history->ents && fs->priv->dir_history->pos)
703
gtk_clist_select_row (
704
GTK_CLIST (GNOME_CMD_COMBO (fs->dir_combo)->list),
705
g_list_index (fs->priv->dir_history->ents, fs->priv->dir_history->pos->data),
706
0);*/
675
GList *tmp;
676
677
if (!fs->priv->dir_history) return;
678
679
tmp = fs->priv->dir_history->ents;
680
681
gnome_cmd_combo_clear (GNOME_CMD_COMBO (fs->dir_combo));
682
683
while (tmp) {
684
gchar *text[2];
685
686
text[0] = (gchar*)tmp->data;
687
text[1] = NULL;
688
689
gnome_cmd_combo_append (GNOME_CMD_COMBO (fs->dir_combo), text, tmp->data);
690
tmp = tmp->next;
691
}
692
693
if (fs->priv->dir_history->ents && fs->priv->dir_history->pos)
694
gtk_clist_select_row (
695
GTK_CLIST (GNOME_CMD_COMBO (fs->dir_combo)->list),
696
g_list_index (fs->priv->dir_history->ents, fs->priv->dir_history->pos->data),
697
0);*/
707
698
}
708
699
709
700
711
702
update_vol_label (GnomeCmdFileSelector *fs)
712
703
713
704
{
714
gchar *s;
715
GnomeVFSFileSize free_space;
716
GnomeVFSResult res;
717
718
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
719
g_return_if_fail (GNOME_CMD_IS_CON (fs->priv->con));
720
721
if (gnome_cmd_con_can_show_free_space (fs->priv->con)) {
722
GnomeVFSURI *uri = gnome_cmd_file_get_uri (GNOME_CMD_FILE (fs->priv->cwd));
723
res = gnome_vfs_get_volume_free_space (uri, &free_space);
724
gnome_vfs_uri_unref (uri);
725
726
if (res == GNOME_VFS_OK) {
727
gchar *sfree = gnome_vfs_format_file_size_for_display (free_space);
728
s = g_strdup_printf (_("%s Free"), sfree);
729
g_free (sfree);
730
}
731
else
732
s = g_strdup ("Unknown disk usage");
733
}
734
else
735
s = g_strdup ("");
736
737
gtk_label_set_text (GTK_LABEL (fs->vol_label), s);
738
739
g_free (s);
705
gchar *s;
706
GnomeVFSFileSize free_space;
707
GnomeVFSResult res;
708
709
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
710
g_return_if_fail (GNOME_CMD_IS_CON (fs->priv->con));
711
712
if (gnome_cmd_con_can_show_free_space (fs->priv->con)) {
713
GnomeVFSURI *uri = gnome_cmd_file_get_uri (GNOME_CMD_FILE (fs->priv->cwd));
714
res = gnome_vfs_get_volume_free_space (uri, &free_space);
715
gnome_vfs_uri_unref (uri);
716
717
if (res == GNOME_VFS_OK) {
718
gchar *sfree = gnome_vfs_format_file_size_for_display (free_space);
719
s = g_strdup_printf (_("%s free"), sfree);
720
g_free (sfree);
721
}
722
else
723
s = g_strdup (_("Unknown disk usage"));
724
}
725
else
726
s = g_strdup ("");
727
728
gtk_label_set_text (GTK_LABEL (fs->vol_label), s);
729
730
g_free (s);
740
731
}
741
732
742
733
743
734
static void
744
735
goto_directory (GnomeCmdFileSelector *fs,
745
const gchar *in_dir)
736
const gchar *in_dir)
746
737
{
747
GnomeCmdDir *cur_dir, *new_dir = NULL;
748
const gchar *focus_dir = NULL;
749
gchar *dir;
750
751
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
752
g_return_if_fail (in_dir != NULL);
753
754
cur_dir = gnome_cmd_file_selector_get_directory (fs);
755
g_return_if_fail (GNOME_CMD_IS_DIR (cur_dir));
756
757
if (strcmp (in_dir, "~") == 0)
758
dir = g_strdup (g_get_home_dir ());
759
else
760
dir = unquote_if_needed (in_dir);
761
762
if (strcmp (dir, "..") == 0) {
763
/* lets get the parent directory */
764
new_dir = gnome_cmd_dir_get_parent (cur_dir);
765
if (!new_dir) {
766
g_free (dir);
767
return;
768
}
769
focus_dir = gnome_cmd_file_get_name (GNOME_CMD_FILE (cur_dir));
770
}
771
else {
772
/* check if it's an absolute address or not */
773
if (dir[0] == '/') {
774
new_dir = gnome_cmd_dir_new (
775
fs->priv->con, gnome_cmd_con_create_path (fs->priv->con, dir));
776
}
777
else if (strncmp (dir, "\\\\", 2) == 0) {
778
GnomeCmdPath *path = gnome_cmd_con_create_path (get_smb_con (), dir);
779
if (path)
780
new_dir = gnome_cmd_dir_new (get_smb_con (), path);
781
}
782
else
783
new_dir = gnome_cmd_dir_get_child (cur_dir, dir);
784
}
785
786
if (new_dir)
787
gnome_cmd_file_selector_set_directory (fs, new_dir);
788
789
/* focus the current dir when going back to the parent dir */
790
if (focus_dir)
791
gnome_cmd_file_list_focus_file (fs->list, focus_dir, FALSE);
792
793
g_free (dir);
738
GnomeCmdDir *cur_dir, *new_dir = NULL;
739
const gchar *focus_dir = NULL;
740
gchar *dir;
741
742
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
743
g_return_if_fail (in_dir != NULL);
744
745
cur_dir = gnome_cmd_file_selector_get_directory (fs);
746
g_return_if_fail (GNOME_CMD_IS_DIR (cur_dir));
747
748
if (strcmp (in_dir, "~") == 0)
749
dir = g_strdup (g_get_home_dir ());
750
else
751
dir = unquote_if_needed (in_dir);
752
753
if (strcmp (dir, "..") == 0) {
754
/* lets get the parent directory */
755
new_dir = gnome_cmd_dir_get_parent (cur_dir);
756
if (!new_dir) {
757
g_free (dir);
758
return;
759
}
760
focus_dir = gnome_cmd_file_get_name (GNOME_CMD_FILE (cur_dir));
761
}
762
else {
763
/* check if it's an absolute address or not */
764
if (dir[0] == '/') {
765
new_dir = gnome_cmd_dir_new (fs->priv->con, gnome_cmd_con_create_path (fs->priv->con, dir));
766
}
767
else if (strncmp (dir, "\\\\", 2) == 0) {
768
GnomeCmdPath *path = gnome_cmd_con_create_path (get_smb_con (), dir);
769
if (path)
770
new_dir = gnome_cmd_dir_new (get_smb_con (), path);
771
}
772
else
773
new_dir = gnome_cmd_dir_get_child (cur_dir, dir);
774
}
775
776
if (new_dir)
777
gnome_cmd_file_selector_set_directory (fs, new_dir);
778
779
/* focus the current dir when going back to the parent dir */
780
if (focus_dir)
781
gnome_cmd_file_list_focus_file (fs->list, focus_dir, FALSE);
782
783
g_free (dir);
794
784
}
795
785
796
786
797
787
static void
798
788
do_file_specific_action (GnomeCmdFileSelector *fs,
799
GnomeCmdFile *finfo)
789
GnomeCmdFile *finfo)
800
790
{
801
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
791
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
792
g_return_if_fail (finfo!=NULL) ;
793
g_return_if_fail (finfo->info!=NULL) ;
802
794
803
if (finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY) {
804
if (strcmp (finfo->info->name, "..") == 0)
805
goto_directory (fs, "..");
806
else
807
gnome_cmd_file_selector_set_directory (fs, GNOME_CMD_DIR (finfo));
808
}
795
if (finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY) {
796
if (strcmp (finfo->info->name, "..") == 0)
797
goto_directory (fs, "..");
798
else
799
gnome_cmd_file_selector_set_directory (fs, GNOME_CMD_DIR (finfo));
800
}
809
801
}
810
802
811
803
812
804
static gboolean
813
805
file_is_in_list (GnomeCmdFileSelector *fs, GnomeCmdFile *finfo)
814
806
{
815
return g_list_index (gnome_cmd_file_list_get_all_files (fs->list), finfo) != -1;
807
return g_list_index (gnome_cmd_file_list_get_all_files (fs->list), finfo) != -1;
816
808
}
817
809
818
810
819
811
static void
820
812
add_file_to_cmdline (GnomeCmdFileSelector *fs, gboolean fullpath)
821
{
822
GnomeCmdFile *finfo;
823
824
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
825
826
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
827
828
if (finfo && gnome_cmd_data_get_cmdline_visibility ()) {
829
gchar *text;
830
831
if (fullpath)
832
text = gnome_cmd_file_get_quoted_real_path (finfo);
833
else
834
text = gnome_cmd_file_get_quoted_name (finfo);
835
836
gnome_cmd_cmdline_append_text (
837
gnome_cmd_main_win_get_cmdline (main_win), text);
838
gnome_cmd_cmdline_focus (
839
gnome_cmd_main_win_get_cmdline (main_win));
840
g_free (text);
841
}
813
{
814
GnomeCmdFile *finfo;
815
816
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
817
818
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
819
820
if (finfo && gnome_cmd_data_get_cmdline_visibility ()) {
821
gchar *text;
822
823
if (fullpath)
824
text = gnome_cmd_file_get_quoted_real_path (finfo);
825
else
826
text = gnome_cmd_file_get_quoted_name (finfo);
827
828
gnome_cmd_cmdline_append_text (gnome_cmd_main_win_get_cmdline (main_win), text);
829
gnome_cmd_cmdline_focus (gnome_cmd_main_win_get_cmdline (main_win));
830
g_free (text);
831
}
842
832
}
843
833
844
834
845
835
static void
846
836
add_cwd_to_cmdline (GnomeCmdFileSelector *fs)
847
{
848
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
849
850
if (gnome_cmd_data_get_cmdline_visibility ()) {
851
gchar *dpath = gnome_cmd_file_get_real_path (GNOME_CMD_FILE (fs->priv->cwd));
852
gnome_cmd_cmdline_append_text (
853
gnome_cmd_main_win_get_cmdline (main_win), dpath);
854
g_free (dpath);
855
856
gnome_cmd_cmdline_focus (
857
gnome_cmd_main_win_get_cmdline (main_win));
858
}
837
{
838
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
839
840
if (gnome_cmd_data_get_cmdline_visibility ()) {
841
gchar *dpath = gnome_cmd_file_get_real_path (GNOME_CMD_FILE (fs->priv->cwd));
842
gnome_cmd_cmdline_append_text (gnome_cmd_main_win_get_cmdline (main_win), dpath);
843
g_free (dpath);
844
845
gnome_cmd_cmdline_focus (gnome_cmd_main_win_get_cmdline (main_win));
846
}
859
847
}
860
848
861
849
867
855
static void
868
856
on_con_list_list_changed (GnomeCmdConList *con_list, GnomeCmdFileSelector *fs)
869
857
{
870
gnome_cmd_file_selector_update_connections (fs);
858
gnome_cmd_file_selector_update_connections (fs);
871
859
}
872
860
873
861
874
862
static void
875
863
on_dir_file_created (GnomeCmdDir *dir, GnomeCmdFile *finfo, GnomeCmdFileSelector *fs)
876
864
{
877
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
878
g_return_if_fail (GNOME_CMD_IS_FILE (finfo));
879
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
880
881
if (!file_is_wanted (fs, finfo->info))
882
return;
883
884
gnome_cmd_file_list_insert_file (fs->list, finfo);
885
update_selected_files_label (fs);
865
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
866
g_return_if_fail (GNOME_CMD_IS_FILE (finfo));
867
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
868
869
if (!file_is_wanted (fs, finfo->info))
870
return;
871
872
gnome_cmd_file_list_insert_file (fs->list, finfo);
873
update_selected_files_label (fs);
886
874
}
887
875
888
876
889
877
static void
890
878
on_dir_file_deleted (GnomeCmdDir *dir, GnomeCmdFile *finfo, GnomeCmdFileSelector *fs)
891
879
{
892
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
893
g_return_if_fail (GNOME_CMD_IS_FILE (finfo));
894
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
895
896
if (fs->priv->cwd == dir && file_is_in_list (fs, finfo)) {
897
gnome_cmd_file_list_remove_file (fs->list, finfo);
898
update_selected_files_label (fs);
899
}
880
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
881
g_return_if_fail (GNOME_CMD_IS_FILE (finfo));
882
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
883
884
if (fs->priv->cwd == dir && file_is_in_list (fs, finfo)) {
885
gnome_cmd_file_list_remove_file (fs->list, finfo);
886
update_selected_files_label (fs);
887
}
900
888
}
901
889
902
890
903
891
static void
904
892
on_dir_file_changed (GnomeCmdDir *dir, GnomeCmdFile *finfo, GnomeCmdFileSelector *fs)
905
893
{
906
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
907
g_return_if_fail (GNOME_CMD_IS_FILE (finfo));
908
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
894
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
895
g_return_if_fail (GNOME_CMD_IS_FILE (finfo));
896
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
909
897
910
if (file_is_in_list (fs, finfo)) {
911
gnome_cmd_file_list_update_file (GNOME_CMD_FILE_LIST (fs->list), finfo);
912
update_selected_files_label (fs);
913
}
898
if (file_is_in_list (fs, finfo)) {
899
gnome_cmd_file_list_update_file (GNOME_CMD_FILE_LIST (fs->list), finfo);
900
update_selected_files_label (fs);
901
}
914
902
}
915
903
916
904
917
905
static void
918
906
on_con_combo_item_selected (GnomeCmdCombo *con_combo,
919
GnomeCmdCon *con,
920
GnomeCmdFileSelector *fs)
907
GnomeCmdCon *con,
908
GnomeCmdFileSelector *fs)
921
909
{
922
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
923
g_return_if_fail (GNOME_CMD_IS_CON (con));
910
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
911
g_return_if_fail (GNOME_CMD_IS_CON (con));
924
912
925
gnome_cmd_main_win_switch_fs (main_win, fs);
926
gnome_cmd_file_selector_set_connection (fs, con, NULL);
913
gnome_cmd_main_win_switch_fs (main_win, fs);
914
gnome_cmd_file_selector_set_connection (fs, con, NULL);
927
915
}
928
916
929
917
930
918
static void
931
919
on_combo_popwin_hidden (GnomeCmdCombo *combo,
932
GnomeCmdFileSelector *fs)
920
GnomeCmdFileSelector *fs)
933
921
{
934
g_return_if_fail (GNOME_CMD_IS_COMBO (combo));
935
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
922
g_return_if_fail (GNOME_CMD_IS_COMBO (combo));
923
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
936
924
937
gnome_cmd_main_win_refocus (main_win);
925
gnome_cmd_main_win_refocus (main_win);
938
926
}
939
927
940
928
941
929
static void
942
930
on_con_btn_clicked (GtkButton *button,
943
GnomeCmdFileSelector *fs)
931
GnomeCmdFileSelector *fs)
944
932
{
945
GnomeCmdCon *con = gtk_object_get_data (GTK_OBJECT (button), "con");
946
947
g_return_if_fail (GNOME_CMD_IS_CON (con));
948
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
949
950
gnome_cmd_main_win_switch_fs (main_win, fs);
951
gnome_cmd_file_selector_set_connection (fs, con, NULL);
933
GnomeCmdCon *con = gtk_object_get_data (GTK_OBJECT (button), "con");
934
935
g_return_if_fail (GNOME_CMD_IS_CON (con));
936
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
937
938
gnome_cmd_main_win_switch_fs (main_win, fs);
939
gnome_cmd_file_selector_set_connection (fs, con, NULL);
952
940
}
953
941
954
942
955
943
static void
956
944
create_con_buttons (GnomeCmdFileSelector *fs)
957
945
{
958
GList *l;
959
static GtkTooltips *tooltips = NULL;
960
961
if (!gnome_cmd_data_get_conbuttons_visibility ())
962
return;
963
964
l = fs->priv->old_btns;
965
while (l) {
966
gtk_object_destroy (GTK_OBJECT (l->data));
967
l = l->next;
968
}
969
g_list_free (fs->priv->old_btns);
970
fs->priv->old_btns = NULL;
971
972
if (!tooltips) {
973
tooltips = gtk_tooltips_new ();
974
}
975
976
l = gnome_cmd_con_list_get_all (gnome_cmd_data_get_con_list ());
977
while (l) {
978
GtkWidget *btn, *label;
979
GtkWidget *hbox;
980
GnomeCmdPixmap *pm;
981
GnomeCmdCon *con = GNOME_CMD_CON (l->data);
982
983
if (!gnome_cmd_con_is_open (con) && !GNOME_CMD_IS_CON_DEVICE (con)
984
&& !GNOME_CMD_IS_CON_SMB (con)) {
985
l = l->next;
986
continue;
987
}
988
pm = gnome_cmd_con_get_go_pixmap (con);
989
990
btn = create_styled_button (NULL);
991
gtk_object_set_data (GTK_OBJECT (btn), "con", con);
992
gtk_signal_connect (GTK_OBJECT (btn), "clicked",
993
(GtkSignalFunc)on_con_btn_clicked, fs);
994
gtk_box_pack_start (GTK_BOX (fs->con_btns_hbox), btn, FALSE, FALSE, 0);
995
GTK_WIDGET_UNSET_FLAGS (btn, GTK_CAN_FOCUS);
996
fs->priv->old_btns = g_list_append (fs->priv->old_btns, btn);
997
gtk_tooltips_set_tip (tooltips, btn,
998
gnome_cmd_con_get_go_text (con), NULL);
999
1000
hbox = gtk_hbox_new (FALSE, 1);
1001
gtk_widget_ref (hbox);
1002
gtk_object_set_data_full (GTK_OBJECT (fs), "con-hbox", hbox,
1003
(GtkDestroyNotify) gtk_widget_unref);
1004
gtk_widget_show (hbox);
1005
1006
if (pm) {
1007
GtkWidget *pixmap = gtk_pixmap_new (pm->pixmap, pm->mask);
1008
if (pixmap) {
1009
gtk_widget_ref (pixmap);
1010
gtk_object_set_data_full (GTK_OBJECT (fs), "con-pixmap", pixmap,
1011
(GtkDestroyNotify) gtk_widget_unref);
1012
gtk_widget_show (pixmap);
1013
gtk_box_pack_start (GTK_BOX (hbox), pixmap, TRUE, TRUE, 0);
1014
}
1015
}
1016
1017
if (!gnome_cmd_data_get_device_only_icon () || !pm) {
1018
label = gtk_label_new (gnome_cmd_con_get_alias (con));
1019
gtk_widget_ref (label);
1020
gtk_object_set_data_full (GTK_OBJECT (fs), "con-label", label,
1021
(GtkDestroyNotify) gtk_widget_unref);
1022
gtk_widget_show (label);
1023
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1024
}
1025
1026
gtk_container_add (GTK_CONTAINER (btn), hbox);
1027
1028
l = l->next;
1029
}
946
GList *l;
947
static GtkTooltips *tooltips = NULL;
948
949
if (!gnome_cmd_data_get_conbuttons_visibility ())
950
return;
951
952
for (l = fs->priv->old_btns; l; l = l->next)
953
gtk_object_destroy (GTK_OBJECT (l->data));
954
955
g_list_free (fs->priv->old_btns);
956
fs->priv->old_btns = NULL;
957
958
if (!tooltips) {
959
tooltips = gtk_tooltips_new ();
960
}
961
962
l = gnome_cmd_con_list_get_all (gnome_cmd_data_get_con_list ());
963
while (l) {
964
GtkWidget *btn, *label;
965
GtkWidget *hbox;
966
GnomeCmdPixmap *pm;
967
GnomeCmdCon *con = GNOME_CMD_CON (l->data);
968
969
if (!gnome_cmd_con_is_open (con) && !GNOME_CMD_IS_CON_DEVICE (con)
970
&& !GNOME_CMD_IS_CON_SMB (con)) {
971
l = l->next;
972
continue;
973
}
974
pm = gnome_cmd_con_get_go_pixmap (con);
975
976
btn = create_styled_button (NULL);
977
gtk_object_set_data (GTK_OBJECT (btn), "con", con);
978
gtk_signal_connect (GTK_OBJECT (btn), "clicked", (GtkSignalFunc)on_con_btn_clicked, fs);
979
gtk_box_pack_start (GTK_BOX (fs->con_btns_hbox), btn, FALSE, FALSE, 0);
980
GTK_WIDGET_UNSET_FLAGS (btn, GTK_CAN_FOCUS);
981
fs->priv->old_btns = g_list_append (fs->priv->old_btns, btn);
982
gtk_tooltips_set_tip (tooltips, btn, gnome_cmd_con_get_go_text (con), NULL);
983
984
hbox = gtk_hbox_new (FALSE, 1);
985
gtk_widget_ref (hbox);
986
gtk_object_set_data_full (GTK_OBJECT (fs), "con-hbox", hbox, (GtkDestroyNotify) gtk_widget_unref);
987
gtk_widget_show (hbox);
988
989
if (pm) {
990
GtkWidget *pixmap = gtk_pixmap_new (pm->pixmap, pm->mask);
991
if (pixmap) {
992
gtk_widget_ref (pixmap);
993
gtk_object_set_data_full (GTK_OBJECT (fs), "con-pixmap", pixmap,
994
(GtkDestroyNotify) gtk_widget_unref);
995
gtk_widget_show (pixmap);
996
gtk_box_pack_start (GTK_BOX (hbox), pixmap, TRUE, TRUE, 0);
997
}
998
}
999
1000
if (!gnome_cmd_data_get_device_only_icon () || !pm) {
1001
label = gtk_label_new (gnome_cmd_con_get_alias (con));
1002
gtk_widget_ref (label);
1003
gtk_object_set_data_full (GTK_OBJECT (fs), "con-label", label,
1004
(GtkDestroyNotify) gtk_widget_unref);
1005
gtk_widget_show (label);
1006
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
1007
}
1008
1009
gtk_container_add (GTK_CONTAINER (btn), hbox);
1010
1011
l = l->next;
1012
}
1030
1013
}
1031
1014
1032
1015
1033
1016
static void
1034
1017
on_realize (GnomeCmdFileSelector *fs,
1035
gpointer user_data)
1018
gpointer user_data)
1036
1019
{
1037
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1038
1039
fs->priv->realized = TRUE;
1040
1041
create_con_buttons (fs);
1042
gnome_cmd_file_selector_update_connections (fs);
1020
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1021
1022
fs->priv->realized = TRUE;
1023
1024
create_con_buttons (fs);
1025
gnome_cmd_file_selector_update_connections (fs);
1043
1026
}
1044
1027
1045
1028
1046
1029
static void
1047
1030
on_list_file_clicked (GnomeCmdFileList *fl, GnomeCmdFile *finfo,
1048
GdkEventButton *event, GnomeCmdFileSelector *fs)
1031
GdkEventButton *event, GnomeCmdFileSelector *fs)
1049
1032
{
1050
if (event->type == GDK_2BUTTON_PRESS) {
1051
if (event->button == 1)
1052
do_file_specific_action (fs, finfo);
1053
}
1033
if (event->type == GDK_2BUTTON_PRESS) {
1034
if (event->button == 1)
1035
do_file_specific_action (fs, finfo);
1036
}
1054
1037
}
1055
1038
1056
1039
1057
1040
static void
1058
1041
on_list_list_clicked (GnomeCmdFileList *fl, GdkEventButton *event,
1059
GnomeCmdFileSelector *fs)
1042
GnomeCmdFileSelector *fs)
1060
1043
{
1061
if (event->type == GDK_BUTTON_PRESS) {
1062
if (event->button == 1 || event->button == 3)
1063
gnome_cmd_main_win_switch_fs (main_win, fs);
1064
else if (event->button == 2)
1065
goto_directory (fs, "..");
1066
}
1044
if (event->type == GDK_BUTTON_PRESS) {
1045
if (event->button == 1 || event->button == 3)
1046
gnome_cmd_main_win_switch_fs (main_win, fs);
1047
else if (event->button == 2)
1048
goto_directory (fs, "..");
1049
}
1067
1050
}
1068
1051
1069
1052
1070
1053
static void
1071
1054
on_list_empty_space_clicked (GnomeCmdFileList *fl, GdkEventButton *event,
1072
GnomeCmdFileSelector *fs)
1055
GnomeCmdFileSelector *fs)
1073
1056
{
1074
if (event->type == GDK_BUTTON_PRESS) {
1075
if (event->button == 3)
1076
show_list_popup (fs);
1077
}
1057
if (event->type == GDK_BUTTON_PRESS) {
1058
if (event->button == 3)
1059
show_list_popup (fs);
1060
}
1078
1061
}
1079
1062
1080
1063
1081
1064
static void
1082
1065
on_list_selection_changed (GnomeCmdFileList *fl, GnomeCmdFileSelector *fs)
1083
1066
{
1084
update_selected_files_label (fs);
1067
update_selected_files_label (fs);
1085
1068
}
1086
1069
1087
1070
1088
1071
static void
1089
1072
on_dir_list_ok (GnomeCmdDir *dir, GList *files, GnomeCmdFileSelector *fs)
1090
1073
{
1091
GnomeCmdCon *con;
1092
1093
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1094
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1095
1096
DEBUG('l', "on_dir_list_ok\n");
1097
1098
if (fs->priv->realized) {
1099
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
1100
set_cursor_default_for_widget (GTK_WIDGET (fs));
1101
gtk_widget_grab_focus (GTK_WIDGET (fs->list));
1102
}
1103
1104
if (fs->priv->connected_dir != dir) {
1105
if (fs->priv->connected_dir != NULL) {
1106
gtk_signal_disconnect_by_func (
1107
GTK_OBJECT (fs->priv->connected_dir),
1108
GTK_SIGNAL_FUNC (on_dir_file_created), fs);
1109
gtk_signal_disconnect_by_func (
1110
GTK_OBJECT (fs->priv->connected_dir),
1111
GTK_SIGNAL_FUNC (on_dir_file_deleted), fs);
1112
gtk_signal_disconnect_by_func (
1113
GTK_OBJECT (fs->priv->connected_dir),
1114
GTK_SIGNAL_FUNC (on_dir_file_changed), fs);
1115
}
1116
1117
gtk_signal_connect (GTK_OBJECT (dir), "file-created",
1118
GTK_SIGNAL_FUNC (on_dir_file_created), fs);
1119
gtk_signal_connect (GTK_OBJECT (dir), "file-deleted",
1120
GTK_SIGNAL_FUNC (on_dir_file_deleted), fs);
1121
gtk_signal_connect (GTK_OBJECT (dir), "file-changed",
1122
GTK_SIGNAL_FUNC (on_dir_file_changed), fs);
1123
fs->priv->connected_dir = dir;
1124
}
1125
1126
con = gnome_cmd_file_selector_get_connection (fs);
1127
gnome_cmd_con_set_cwd (con, dir);
1128
1129
if (fs->priv->dir_history && !fs->priv->dir_history->lock) {
1130
gchar *fpath = gnome_cmd_file_get_path (GNOME_CMD_FILE (dir));
1131
history_add (fs->priv->dir_history, fpath);
1132
g_free (fpath);
1133
update_dir_combo (fs);
1134
}
1135
1136
gtk_signal_emit (GTK_OBJECT (fs),
1137
file_selector_signals[CHANGED_DIR], dir);
1138
1139
update_direntry (fs);
1140
update_vol_label (fs);
1141
1142
if (fs->priv->cwd != dir) return;
1143
1144
fs->priv->sel_first_file = FALSE;
1145
update_files (fs);
1146
fs->priv->sel_first_file = TRUE;
1147
1148
if (!fs->priv->active) {
1149
GTK_CLIST (fs->list)->focus_row = -1;
1150
gtk_clist_unselect_all (GTK_CLIST (fs->list));
1151
}
1152
1153
if (fs->priv->sel_first_file && fs->priv->active)
1154
gtk_clist_select_row (GTK_CLIST (fs->list), 0, 0);
1155
1156
update_selected_files_label (fs);
1157
1158
DEBUG('l', "returning from on_dir_list_ok\n");
1074
GnomeCmdCon *con;
1075
1076
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1077
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1078
1079
DEBUG('l', "on_dir_list_ok\n");
1080
1081
if (fs->priv->realized) {
1082
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
1083
set_cursor_default_for_widget (GTK_WIDGET (fs));
1084
gtk_widget_grab_focus (GTK_WIDGET (fs->list));
1085
}
1086
1087
if (fs->priv->connected_dir != dir) {
1088
if (fs->priv->connected_dir != NULL) {
1089
gtk_signal_disconnect_by_func (
1090
GTK_OBJECT (fs->priv->connected_dir),
1091
GTK_SIGNAL_FUNC (on_dir_file_created), fs);
1092
gtk_signal_disconnect_by_func (
1093
GTK_OBJECT (fs->priv->connected_dir),
1094
GTK_SIGNAL_FUNC (on_dir_file_deleted), fs);
1095
gtk_signal_disconnect_by_func (
1096
GTK_OBJECT (fs->priv->connected_dir),
1097
GTK_SIGNAL_FUNC (on_dir_file_changed), fs);
1098
}
1099
1100
gtk_signal_connect (GTK_OBJECT (dir), "file-created", GTK_SIGNAL_FUNC (on_dir_file_created), fs);
1101
gtk_signal_connect (GTK_OBJECT (dir), "file-deleted", GTK_SIGNAL_FUNC (on_dir_file_deleted), fs);
1102
gtk_signal_connect (GTK_OBJECT (dir), "file-changed", GTK_SIGNAL_FUNC (on_dir_file_changed), fs);
1103
fs->priv->connected_dir = dir;
1104
}
1105
1106
con = gnome_cmd_file_selector_get_connection (fs);
1107
gnome_cmd_con_set_cwd (con, dir);
1108
1109
if (fs->priv->dir_history && !fs->priv->dir_history->lock) {
1110
gchar *fpath = gnome_cmd_file_get_path (GNOME_CMD_FILE (dir));
1111
history_add (fs->priv->dir_history, fpath);
1112
g_free (fpath);
1113
update_dir_combo (fs);
1114
}
1115
1116
gtk_signal_emit (GTK_OBJECT (fs),
1117
file_selector_signals[CHANGED_DIR], dir);
1118
1119
update_direntry (fs);
1120
update_vol_label (fs);
1121
1122
if (fs->priv->cwd != dir) return;
1123
1124
fs->priv->sel_first_file = FALSE;
1125
update_files (fs);
1126
fs->priv->sel_first_file = TRUE;
1127
1128
if (!fs->priv->active) {
1129
GTK_CLIST (fs->list)->focus_row = -1;
1130
gtk_clist_unselect_all (GTK_CLIST (fs->list));
1131
}
1132
1133
if (fs->priv->sel_first_file && fs->priv->active)
1134
gtk_clist_select_row (GTK_CLIST (fs->list), 0, 0);
1135
1136
update_selected_files_label (fs);
1137
1138
DEBUG('l', "returning from on_dir_list_ok\n");
1159
1139
}
1160
1140
1161
1141
1162
1142
static gboolean
1163
1143
set_home_connection (GnomeCmdFileSelector *fs)
1164
1144
{
1165
g_printerr ("Setting home connection\n");
1166
gnome_cmd_file_selector_set_connection (
1167
fs,
1168
gnome_cmd_con_list_get_home (gnome_cmd_data_get_con_list ()),
1169
NULL);
1170
1171
return FALSE;
1145
g_printerr ("Setting home connection\n");
1146
gnome_cmd_file_selector_set_connection (
1147
fs,
1148
gnome_cmd_con_list_get_home (gnome_cmd_data_get_con_list ()),
1149
NULL);
1150
1151
return FALSE;
1172
1152
}
1173
1153
1174
1154
1175
1155
static void
1176
1156
on_dir_list_failed (GnomeCmdDir *dir, GnomeVFSResult result, GnomeCmdFileSelector *fs)
1177
1157
{
1178
DEBUG('l', "on_dir_list_failed\n");
1179
1180
if (result != GNOME_VFS_OK) {
1181
gchar *msg = g_strdup_printf (
1182
"List failed: %s\n", gnome_vfs_result_to_string (result));
1183
create_error_dialog (msg);
1184
g_free (msg);
1185
}
1186
1187
gtk_signal_disconnect_by_data (GTK_OBJECT (fs->priv->cwd), fs);
1188
fs->priv->connected_dir = NULL;
1189
gnome_cmd_dir_unref (fs->priv->cwd);
1190
set_cursor_default_for_widget (GTK_WIDGET (fs));
1191
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
1192
1193
if (fs->priv->lwd
1194
&& fs->priv->con == gnome_cmd_dir_get_connection (fs->priv->lwd)) {
1195
fs->priv->cwd = fs->priv->lwd;
1196
gtk_signal_connect (GTK_OBJECT (fs->priv->cwd), "list-ok",
1197
GTK_SIGNAL_FUNC (on_dir_list_ok), fs);
1198
gtk_signal_connect (GTK_OBJECT (fs->priv->cwd), "list-failed",
1199
GTK_SIGNAL_FUNC (on_dir_list_failed), fs);
1200
fs->priv->lwd = NULL;
1201
}
1202
else {
1203
g_timeout_add (1, (GtkFunction)set_home_connection, fs);
1204
}
1158
DEBUG('l', "on_dir_list_failed\n");
1159
1160
if (result != GNOME_VFS_OK) {
1161
gchar *msg = g_strdup_printf (
1162
"List failed: %s\n", gnome_vfs_result_to_string (result));
1163
create_error_dialog (msg);
1164
g_free (msg);
1165
}
1166
1167
gtk_signal_disconnect_by_data (GTK_OBJECT (fs->priv->cwd), fs);
1168
fs->priv->connected_dir = NULL;
1169
gnome_cmd_dir_unref (fs->priv->cwd);
1170
set_cursor_default_for_widget (GTK_WIDGET (fs));
1171
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
1172
1173
if (fs->priv->lwd
1174
&& fs->priv->con == gnome_cmd_dir_get_connection (fs->priv->lwd)) {
1175
fs->priv->cwd = fs->priv->lwd;
1176
gtk_signal_connect (GTK_OBJECT (fs->priv->cwd), "list-ok",
1177
GTK_SIGNAL_FUNC (on_dir_list_ok), fs);
1178
gtk_signal_connect (GTK_OBJECT (fs->priv->cwd), "list-failed",
1179
GTK_SIGNAL_FUNC (on_dir_list_failed), fs);
1180
fs->priv->lwd = NULL;
1181
}
1182
else {
1183
g_timeout_add (1, (GtkFunction)set_home_connection, fs);
1184
}
1205
1185
}
1206
1186
1207
1187
1210
1190
*/
1211
1191
static gboolean
1212
1192
on_list_key_pressed (GtkCList *clist,
1213
GdkEventKey *event,
1214
GnomeCmdFileSelector *fs)
1193
GdkEventKey *event,
1194
GnomeCmdFileSelector *fs)
1215
1195
{
1216
gboolean ret = FALSE;
1217
1218
if (gnome_cmd_file_list_keypressed (fs->list, event))
1219
ret = TRUE;
1220
else if (gnome_cmd_file_selector_keypressed (fs, event))
1221
ret = TRUE;
1222
else if (gnome_cmd_main_win_keypressed (main_win, event))
1223
ret = TRUE;
1224
1225
if (ret) {
1226
stop_kp (GTK_OBJECT (clist));
1227
return TRUE;
1228
}
1229
1230
return FALSE;
1196
gboolean ret = FALSE;
1197
1198
if (gnome_cmd_file_list_keypressed (fs->list, event))
1199
ret = TRUE;
1200
else if (gnome_cmd_file_selector_keypressed (fs, event))
1201
ret = TRUE;
1202
else if (gnome_cmd_main_win_keypressed (main_win, event))
1203
ret = TRUE;
1204
1205
if (ret) {
1206
stop_kp (GTK_OBJECT (clist));
1207
return TRUE;
1208
}
1209
1210
return FALSE;
1231
1211
}
1232
1212
1233
1213
1234
1214
static gboolean
1235
1215
on_list_key_pressed_private (GtkCList *clist,
1236
GdkEventKey *event,
1237
GnomeCmdFileSelector *fs)
1216
GdkEventKey *event,
1217
GnomeCmdFileSelector *fs)
1238
1218
{
1239
if (state_is_blank (event->state) || state_is_shift (event->state)) {
1240
if ((event->keyval >= GDK_A && event->keyval <= GDK_Z)
1241
|| (event->keyval >= GDK_a && event->keyval <= GDK_z)
1242
|| event->keyval == GDK_period) {
1243
static gchar text[2];
1244
1245
if (!gnome_cmd_data_get_cmdline_visibility ()) {
1246
gnome_cmd_file_list_show_quicksearch (fs->list, (gchar)event->keyval);
1247
}
1248
else {
1249
text[0] = event->keyval;
1250
text[1] = '\0';
1251
gnome_cmd_cmdline_append_text (
1252
gnome_cmd_main_win_get_cmdline (main_win), text);
1253
gnome_cmd_cmdline_focus (
1254
gnome_cmd_main_win_get_cmdline (main_win));
1255
}
1256
return TRUE;
1257
}
1258
}
1259
1260
return FALSE;
1219
if (state_is_blank (event->state) || state_is_shift (event->state)) {
1220
if ((event->keyval >= GDK_A && event->keyval <= GDK_Z)
1221
|| (event->keyval >= GDK_a && event->keyval <= GDK_z)
1222
|| event->keyval == GDK_period) {
1223
static gchar text[2];
1224
1225
if (!gnome_cmd_data_get_cmdline_visibility ()) {
1226
gnome_cmd_file_list_show_quicksearch (fs->list, (gchar)event->keyval);
1227
}
1228
else {
1229
text[0] = event->keyval;
1230
text[1] = '\0';
1231
gnome_cmd_cmdline_append_text (
1232
gnome_cmd_main_win_get_cmdline (main_win), text);
1233
gnome_cmd_cmdline_focus (
1234
gnome_cmd_main_win_get_cmdline (main_win));
1235
}
1236
return TRUE;
1237
}
1238
}
1239
1240
return FALSE;
1261
1241
}
1262
1242
1263
1243
1264
1244
static void
1265
1245
on_root_btn_clicked (GtkButton *button,
1266
GnomeCmdFileSelector *fs)
1267
{
1268
gnome_cmd_main_win_switch_fs (main_win, fs);
1269
goto_directory (fs, "/");
1270
}
1271
1272
1273
static void
1274
on_parent_btn_clicked (GtkButton *button,
1275
GnomeCmdFileSelector *fs)
1276
{
1277
gnome_cmd_main_win_switch_fs (main_win, fs);
1278
goto_directory (fs, "..");
1246
GnomeCmdFileSelector *fs)
1247
{
1248
gnome_cmd_main_win_switch_fs (main_win, fs);
1249
goto_directory (fs, "/");
1279
1250
}
1280
1251
1281
1252
1286
1257
static void
1287
1258
destroy (GtkObject *object)
1288
1259
{
1289
GnomeCmdFileSelector *fs;
1290
1291
fs = GNOME_CMD_FILE_SELECTOR (object);
1292
1293
gnome_cmd_dir_unref (fs->priv->cwd);
1294
g_free (fs->priv);
1295
1296
if (GTK_OBJECT_CLASS (parent_class)->destroy)
1297
(*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
1260
GnomeCmdFileSelector *fs;
1261
1262
fs = GNOME_CMD_FILE_SELECTOR (object);
1263
1264
gnome_cmd_dir_unref (fs->priv->cwd);
1265
g_free (fs->priv);
1266
1267
if (GTK_OBJECT_CLASS (parent_class)->destroy)
1268
(*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
1298
1269
}
1299
1270
1300
1271
static void
1301
1272
map (GtkWidget *widget)
1302
1273
{
1303
if (GTK_WIDGET_CLASS (parent_class)->map != NULL)
1304
GTK_WIDGET_CLASS (parent_class)->map (widget);
1274
if (GTK_WIDGET_CLASS (parent_class)->map != NULL)
1275
GTK_WIDGET_CLASS (parent_class)->map (widget);
1305
1276
}
1306
1277
1307
1278
1308
1279
static void
1309
1280
class_init (GnomeCmdFileSelectorClass *class)
1310
1281
{
1311
GtkObjectClass *object_class;
1312
GtkWidgetClass *widget_class;
1313
1314
object_class = GTK_OBJECT_CLASS (class);
1315
widget_class = GTK_WIDGET_CLASS (class);
1316
parent_class = gtk_type_class (gtk_vbox_get_type ());
1317
1318
file_selector_signals[CHANGED_DIR] =
1319
gtk_signal_new ("changed_dir",
1320
GTK_RUN_LAST,
1321
G_OBJECT_CLASS_TYPE (object_class),
1322
GTK_SIGNAL_OFFSET (GnomeCmdFileSelectorClass, changed_dir),
1323
gtk_marshal_NONE__POINTER,
1324
GTK_TYPE_NONE,
1325
1, GTK_TYPE_POINTER);
1326
1327
object_class->destroy = destroy;
1328
widget_class->map = map;
1329
class->changed_dir = NULL;
1282
GtkObjectClass *object_class;
1283
GtkWidgetClass *widget_class;
1284
1285
object_class = GTK_OBJECT_CLASS (class);
1286
widget_class = GTK_WIDGET_CLASS (class);
1287
parent_class = gtk_type_class (gtk_vbox_get_type ());
1288
1289
file_selector_signals[CHANGED_DIR] =
1290
gtk_signal_new ("changed_dir",
1291
GTK_RUN_LAST,
1292
G_OBJECT_CLASS_TYPE (object_class),
1293
GTK_SIGNAL_OFFSET (GnomeCmdFileSelectorClass, changed_dir),
1294
gtk_marshal_NONE__POINTER,
1295
GTK_TYPE_NONE,
1296
1, GTK_TYPE_POINTER);
1297
1298
object_class->destroy = destroy;
1299
widget_class->map = map;
1300
class->changed_dir = NULL;
1330
1301
}
1331
1302
1332
1303
static void
1333
1304
init (GnomeCmdFileSelector *fs)
1334
1305
{
1335
GtkVBox *vbox;
1336
GtkWidget *padding;
1337
1338
fs->priv = g_new0 (GnomeCmdFileSelectorPrivate, 1);
1339
fs->priv->realized = FALSE;
1340
fs->priv->cwd = NULL;
1341
fs->priv->lwd = NULL;
1342
fs->priv->connected_dir = NULL;
1343
fs->priv->old_btns = NULL;
1344
fs->priv->selection_lock = FALSE;
1345
fs->priv->sel_first_file = TRUE;
1346
fs->priv->dir_history = NULL;
1347
fs->priv->active = FALSE;
1348
fs->priv->sym_file = NULL;
1349
fs->priv->con = NULL;
1350
fs->priv->con_open_dialog = NULL;
1351
fs->priv->con_open_dialog_label = NULL;
1352
fs->priv->con_opening = NULL;
1353
1354
vbox = GTK_VBOX (fs);
1355
1356
/* create the box used for packing the dir_combo and buttons */
1357
gnome_cmd_file_selector_update_conbuttons_visibility (fs);
1358
1359
/* create the box used for packing the con_combo and information */
1360
fs->con_hbox = create_hbox (GTK_WIDGET (fs), FALSE, 2);
1361
1362
/* create the list */
1363
fs->list_widget = gnome_cmd_file_list_new ();
1364
gtk_widget_ref (fs->list_widget);
1365
gtk_object_set_data_full (GTK_OBJECT (fs), "list_widget", fs->list_widget,
1366
(GtkDestroyNotify) gtk_widget_unref);
1367
fs->list = GNOME_CMD_FILE_LIST (fs->list_widget);
1368
gnome_cmd_file_list_show_column (fs->list, FILE_LIST_COLUMN_DIR, FALSE);
1369
1370
/* create the connection combo */
1371
fs->con_combo = gnome_cmd_combo_new (2, 1, NULL);
1372
gtk_widget_ref (fs->con_combo);
1373
gtk_object_set_data_full (GTK_OBJECT (fs),
1374
"con_combo", fs->con_combo,
1375
(GtkDestroyNotify) gtk_widget_unref);
1376
gtk_clist_set_row_height (GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 20);
1377
gtk_entry_set_editable (GTK_ENTRY (GNOME_CMD_COMBO (fs->con_combo)->entry), FALSE);
1378
gtk_clist_set_column_width (
1379
GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 0, 20);
1380
gtk_clist_set_column_width (
1381
GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 1, 60);
1382
GTK_WIDGET_UNSET_FLAGS (GNOME_CMD_COMBO (fs->con_combo)->button, GTK_CAN_FOCUS);
1383
1384
/* Create the free space on volume label */
1385
fs->vol_label = gtk_label_new ("");
1386
gtk_widget_ref (fs->vol_label);
1387
gtk_object_set_data_full (GTK_OBJECT (fs), "vol_label", fs->vol_label,
1388
(GtkDestroyNotify) gtk_widget_unref);
1389
gtk_misc_set_alignment (GTK_MISC (fs->vol_label), 1, 0.5);
1390
1391
/* create the root button */
1392
fs->root_btn = create_styled_pixmap_button (
1393
NULL, IMAGE_get_gnome_cmd_pixmap (PIXMAP_ROOT_DIR));
1394
gtk_object_set_data_full (GTK_OBJECT (fs),
1395
"root_btn", fs->root_btn,
1396
(GtkDestroyNotify) gtk_widget_unref);
1397
GTK_WIDGET_UNSET_FLAGS (fs->root_btn, GTK_CAN_FOCUS);
1398
1399
/* create the parent dir button */
1400
fs->parent_btn = create_styled_pixmap_button (
1401
NULL, IMAGE_get_gnome_cmd_pixmap (PIXMAP_PARENT_DIR));
1402
gtk_object_set_data_full (GTK_OBJECT (fs),
1403
"parent_btn", fs->parent_btn,
1404
(GtkDestroyNotify) gtk_widget_unref);
1405
GTK_WIDGET_UNSET_FLAGS (fs->parent_btn, GTK_CAN_FOCUS);
1406
1407
/* create the directory indicator */
1408
fs->dir_indicator = gnome_cmd_dir_indicator_new (fs);
1409
gtk_widget_ref (fs->dir_indicator);
1410
gtk_object_set_data_full (GTK_OBJECT (fs),
1411
"dir_indicator", fs->dir_indicator,
1412
(GtkDestroyNotify) gtk_widget_unref);
1413
1414
/* create the scrollwindow that we'll place the list in */
1415
fs->scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
1416
gtk_widget_ref (fs->scrolledwindow);
1417
gtk_object_set_data_full (GTK_OBJECT (fs),
1418
"scrolledwindow", fs->scrolledwindow,
1419
(GtkDestroyNotify) gtk_widget_unref);
1420
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (fs->scrolledwindow),
1421
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1422
1423
/* create the info label */
1424
fs->info_label = gtk_label_new ("not initialized");
1425
gtk_widget_ref (fs->info_label);
1426
gtk_object_set_data_full (GTK_OBJECT (fs), "infolabel", fs->info_label,
1427
(GtkDestroyNotify) gtk_widget_unref);
1428
gtk_misc_set_alignment (GTK_MISC (fs->info_label), 0.0f, 0.5f);
1429
1430
/* pack the widgets */
1431
gtk_box_pack_start (GTK_BOX (fs), fs->con_hbox, FALSE, FALSE, 0);
1432
gtk_box_pack_start (GTK_BOX (vbox), fs->dir_indicator, FALSE, FALSE, 0);
1433
gtk_container_add (GTK_CONTAINER (fs->scrolledwindow), fs->list_widget);
1434
gtk_box_pack_start (GTK_BOX (vbox), fs->scrolledwindow, TRUE, TRUE, 0);
1435
padding = create_hbox (GTK_WIDGET (fs), FALSE, 6);
1436
gtk_box_pack_start (GTK_BOX (vbox), padding, FALSE, TRUE, 0);
1437
gtk_box_pack_start (GTK_BOX (padding), fs->info_label, FALSE, TRUE, 6);
1438
gtk_box_pack_start (GTK_BOX (fs->con_hbox), fs->con_combo, FALSE, FALSE, 0);
1439
gtk_box_pack_start (GTK_BOX (fs->con_hbox), fs->vol_label, TRUE, TRUE, 0);
1440
gtk_box_pack_start (GTK_BOX (fs->con_hbox), fs->root_btn, FALSE, FALSE, 0);
1441
gtk_box_pack_start (GTK_BOX (fs->con_hbox), fs->parent_btn, FALSE, FALSE, 0);
1442
1443
1444
/* initialize dnd */
1445
init_dnd (fs);
1446
1447
/* connect signals */
1448
gtk_signal_connect (GTK_OBJECT (fs), "realize",
1449
GTK_SIGNAL_FUNC (on_realize), fs);
1450
1451
gtk_signal_connect (GTK_OBJECT (fs->con_combo), "item-selected",
1452
GTK_SIGNAL_FUNC (on_con_combo_item_selected), fs);
1453
gtk_signal_connect (GTK_OBJECT (fs->con_combo), "popwin-hidden",
1454
GTK_SIGNAL_FUNC (on_combo_popwin_hidden), fs);
1455
1456
gtk_signal_connect (GTK_OBJECT (fs->list), "file-clicked",
1457
GTK_SIGNAL_FUNC (on_list_file_clicked), fs);
1458
gtk_signal_connect (GTK_OBJECT (fs->list), "list-clicked",
1459
GTK_SIGNAL_FUNC (on_list_list_clicked), fs);
1460
gtk_signal_connect (GTK_OBJECT (fs->list), "empty-space-clicked",
1461
GTK_SIGNAL_FUNC (on_list_empty_space_clicked), fs);
1462
gtk_signal_connect (GTK_OBJECT (fs->list), "selection_changed",
1463
GTK_SIGNAL_FUNC (on_list_selection_changed), fs);
1464
1465
gtk_signal_connect (GTK_OBJECT (fs->list), "key-press-event",
1466
GTK_SIGNAL_FUNC (on_list_key_pressed), fs);
1467
gtk_signal_connect (GTK_OBJECT (fs->list), "key-press-event",
1468
GTK_SIGNAL_FUNC (on_list_key_pressed_private), fs);
1469
1470
gtk_signal_connect (GTK_OBJECT (fs->root_btn), "clicked",
1471
GTK_SIGNAL_FUNC (on_root_btn_clicked), fs);
1472
gtk_signal_connect (GTK_OBJECT (fs->parent_btn), "clicked",
1473
GTK_SIGNAL_FUNC (on_parent_btn_clicked), fs);
1474
1475
gtk_signal_connect (GTK_OBJECT (gnome_cmd_data_get_con_list ()), "list-changed",
1476
GTK_SIGNAL_FUNC (on_con_list_list_changed), fs);
1477
1478
1479
/* show the widgets */
1480
gtk_widget_show (GTK_WIDGET (vbox));
1481
gtk_widget_show (fs->con_hbox);
1482
gtk_widget_show (fs->dir_indicator);
1483
gtk_widget_show (fs->root_btn);
1484
gtk_widget_show (fs->parent_btn);
1485
gtk_widget_show (fs->scrolledwindow);
1486
gtk_widget_show (fs->vol_label);
1487
gtk_widget_show (fs->con_combo);
1488
gtk_widget_show (fs->list_widget);
1489
gtk_widget_show (fs->info_label);
1490
1491
gnome_cmd_file_selector_update_style (fs);
1306
GtkVBox *vbox;
1307
GtkWidget *padding;
1308
1309
fs->priv = g_new0 (GnomeCmdFileSelectorPrivate, 1);
1310
fs->priv->realized = FALSE;
1311
fs->priv->cwd = NULL;
1312
fs->priv->lwd = NULL;
1313
fs->priv->connected_dir = NULL;
1314
fs->priv->old_btns = NULL;
1315
fs->priv->selection_lock = FALSE;
1316
fs->priv->sel_first_file = TRUE;
1317
fs->priv->dir_history = NULL;
1318
fs->priv->active = FALSE;
1319
fs->priv->sym_file = NULL;
1320
fs->priv->con = NULL;
1321
fs->priv->con_open_dialog = NULL;
1322
fs->priv->con_open_dialog_label = NULL;
1323
fs->priv->con_opening = NULL;
1324
1325
vbox = GTK_VBOX (fs);
1326
1327
/* create the box used for packing the dir_combo and buttons */
1328
gnome_cmd_file_selector_update_conbuttons_visibility (fs);
1329
1330
/* create the box used for packing the con_combo and information */
1331
fs->con_hbox = create_hbox (GTK_WIDGET (fs), FALSE, 2);
1332
1333
/* create the list */
1334
fs->list_widget = gnome_cmd_file_list_new ();
1335
gtk_widget_ref (fs->list_widget);
1336
gtk_object_set_data_full (GTK_OBJECT (fs), "list_widget", fs->list_widget,
1337
(GtkDestroyNotify) gtk_widget_unref);
1338
fs->list = GNOME_CMD_FILE_LIST (fs->list_widget);
1339
gnome_cmd_file_list_show_column (fs->list, FILE_LIST_COLUMN_DIR, FALSE);
1340
1341
/* create the connection combo */
1342
fs->con_combo = gnome_cmd_combo_new (2, 1, NULL);
1343
gtk_widget_ref (fs->con_combo);
1344
gtk_object_set_data_full (GTK_OBJECT (fs),
1345
"con_combo", fs->con_combo,
1346
(GtkDestroyNotify) gtk_widget_unref);
1347
gtk_clist_set_row_height (GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 20);
1348
gtk_entry_set_editable (GTK_ENTRY (GNOME_CMD_COMBO (fs->con_combo)->entry), FALSE);
1349
gtk_clist_set_column_width (
1350
GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 0, 20);
1351
gtk_clist_set_column_width (
1352
GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 1, 60);
1353
GTK_WIDGET_UNSET_FLAGS (GNOME_CMD_COMBO (fs->con_combo)->button, GTK_CAN_FOCUS);
1354
1355
/* Create the free space on volume label */
1356
fs->vol_label = gtk_label_new ("");
1357
gtk_widget_ref (fs->vol_label);
1358
gtk_object_set_data_full (GTK_OBJECT (fs), "vol_label", fs->vol_label,
1359
(GtkDestroyNotify) gtk_widget_unref);
1360
gtk_misc_set_alignment (GTK_MISC (fs->vol_label), 1, 0.5);
1361
1362
/* create the root button */
1363
fs->root_btn = create_styled_pixmap_button (
1364
NULL, IMAGE_get_gnome_cmd_pixmap (PIXMAP_ROOT_DIR));
1365
gtk_object_set_data_full (GTK_OBJECT (fs),
1366
"root_btn", fs->root_btn,
1367
(GtkDestroyNotify) gtk_widget_unref);
1368
GTK_WIDGET_UNSET_FLAGS (fs->root_btn, GTK_CAN_FOCUS);
1369
1370
/* create the directory indicator */
1371
fs->dir_indicator = gnome_cmd_dir_indicator_new (fs);
1372
gtk_widget_ref (fs->dir_indicator);
1373
gtk_object_set_data_full (GTK_OBJECT (fs),
1374
"dir_indicator", fs->dir_indicator,
1375
(GtkDestroyNotify) gtk_widget_unref);
1376
1377
/* create the scrollwindow that we'll place the list in */
1378
fs->scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
1379
gtk_widget_ref (fs->scrolledwindow);
1380
gtk_object_set_data_full (GTK_OBJECT (fs),
1381
"scrolledwindow", fs->scrolledwindow,
1382
(GtkDestroyNotify) gtk_widget_unref);
1383
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (fs->scrolledwindow),
1384
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1385
1386
/* create the info label */
1387
fs->info_label = gtk_label_new ("not initialized");
1388
gtk_widget_ref (fs->info_label);
1389
gtk_object_set_data_full (GTK_OBJECT (fs), "infolabel", fs->info_label,
1390
(GtkDestroyNotify) gtk_widget_unref);
1391
gtk_misc_set_alignment (GTK_MISC (fs->info_label), 0.0f, 0.5f);
1392
1393
/* pack the widgets */
1394
gtk_box_pack_start (GTK_BOX (fs), fs->con_hbox, FALSE, FALSE, 0);
1395
gtk_box_pack_start (GTK_BOX (vbox), fs->dir_indicator, FALSE, FALSE, 0);
1396
gtk_container_add (GTK_CONTAINER (fs->scrolledwindow), fs->list_widget);
1397
gtk_box_pack_start (GTK_BOX (vbox), fs->scrolledwindow, TRUE, TRUE, 0);
1398
padding = create_hbox (GTK_WIDGET (fs), FALSE, 6);
1399
gtk_box_pack_start (GTK_BOX (vbox), padding, FALSE, TRUE, 0);
1400
gtk_box_pack_start (GTK_BOX (padding), fs->info_label, FALSE, TRUE, 6);
1401
gtk_box_pack_start (GTK_BOX (fs->con_hbox), fs->con_combo, FALSE, FALSE, 0);
1402
gtk_box_pack_start (GTK_BOX (fs->con_hbox), fs->vol_label, TRUE, TRUE, 0);
1403
gtk_box_pack_start (GTK_BOX (fs->con_hbox), fs->root_btn, FALSE, FALSE, 0);
1404
1405
1406
/* initialize dnd */
1407
init_dnd (fs);
1408
1409
/* connect signals */
1410
gtk_signal_connect (GTK_OBJECT (fs), "realize",
1411
GTK_SIGNAL_FUNC (on_realize), fs);
1412
1413
gtk_signal_connect (GTK_OBJECT (fs->con_combo), "item-selected",
1414
GTK_SIGNAL_FUNC (on_con_combo_item_selected), fs);
1415
gtk_signal_connect (GTK_OBJECT (fs->con_combo), "popwin-hidden",
1416
GTK_SIGNAL_FUNC (on_combo_popwin_hidden), fs);
1417
1418
gtk_signal_connect (GTK_OBJECT (fs->list), "file-clicked",
1419
GTK_SIGNAL_FUNC (on_list_file_clicked), fs);
1420
gtk_signal_connect (GTK_OBJECT (fs->list), "list-clicked",
1421
GTK_SIGNAL_FUNC (on_list_list_clicked), fs);
1422
gtk_signal_connect (GTK_OBJECT (fs->list), "empty-space-clicked",
1423
GTK_SIGNAL_FUNC (on_list_empty_space_clicked), fs);
1424
gtk_signal_connect (GTK_OBJECT (fs->list), "selection_changed",
1425
GTK_SIGNAL_FUNC (on_list_selection_changed), fs);
1426
1427
gtk_signal_connect (GTK_OBJECT (fs->list), "key-press-event",
1428
GTK_SIGNAL_FUNC (on_list_key_pressed), fs);
1429
gtk_signal_connect (GTK_OBJECT (fs->list), "key-press-event",
1430
GTK_SIGNAL_FUNC (on_list_key_pressed_private), fs);
1431
1432
gtk_signal_connect (GTK_OBJECT (fs->root_btn), "clicked",
1433
GTK_SIGNAL_FUNC (on_root_btn_clicked), fs);
1434
1435
gtk_signal_connect (GTK_OBJECT (gnome_cmd_data_get_con_list ()), "list-changed",
1436
GTK_SIGNAL_FUNC (on_con_list_list_changed), fs);
1437
1438
1439
/* show the widgets */
1440
gtk_widget_show (GTK_WIDGET (vbox));
1441
gtk_widget_show (fs->con_hbox);
1442
gtk_widget_show (fs->dir_indicator);
1443
gtk_widget_show (fs->root_btn);
1444
gtk_widget_show (fs->scrolledwindow);
1445
gtk_widget_show (fs->vol_label);
1446
gtk_widget_show (fs->con_combo);
1447
gtk_widget_show (fs->list_widget);
1448
gtk_widget_show (fs->info_label);
1449
1450
gnome_cmd_file_selector_update_style (fs);
1492
1451
}
1493
1452
1494
1453
1504
1463
GtkType
1505
1464
gnome_cmd_file_selector_get_type (void)
1506
1465
{
1507
static GtkType fs_type = 0;
1508
1509
if (fs_type == 0)
1510
{
1511
GtkTypeInfo fs_info =
1512
{
1513
"GnomeCmdFileSelector",
1514
sizeof (GnomeCmdFileSelector),
1515
sizeof (GnomeCmdFileSelectorClass),
1516
(GtkClassInitFunc) class_init,
1517
(GtkObjectInitFunc) init,
1518
/* reserved_1 */ NULL,
1519
/* reserved_2 */ NULL,
1520
(GtkClassInitFunc) NULL
1521
};
1522
1523
fs_type = gtk_type_unique (gtk_vbox_get_type (), &fs_info);
1524
}
1525
return fs_type;
1466
static GtkType fs_type = 0;
1467
1468
if (fs_type == 0)
1469
{
1470
GtkTypeInfo fs_info =
1471
{
1472
"GnomeCmdFileSelector",
1473
sizeof (GnomeCmdFileSelector),
1474
sizeof (GnomeCmdFileSelectorClass),
1475
(GtkClassInitFunc) class_init,
1476
(GtkObjectInitFunc) init,
1477
/* reserved_1 */ NULL,
1478
/* reserved_2 */ NULL,
1479
(GtkClassInitFunc) NULL
1480
};
1481
1482
fs_type = gtk_type_unique (gtk_vbox_get_type (), &fs_info);
1483
}
1484
return fs_type;
1526
1485
}
1527
1486
1528
1487
1529
1488
GtkWidget *
1530
1489
gnome_cmd_file_selector_new (void)
1531
1490
{
1532
GnomeCmdFileSelector *fs;
1533
1534
fs = gtk_type_new (gnome_cmd_file_selector_get_type ());
1535
1536
return GTK_WIDGET (fs);
1491
GnomeCmdFileSelector *fs;
1492
1493
fs = gtk_type_new (gnome_cmd_file_selector_get_type ());
1494
1495
return GTK_WIDGET (fs);
1537
1496
}
1538
1497
1539
1498
1540
1499
GnomeCmdDir*
1541
1500
gnome_cmd_file_selector_get_directory (GnomeCmdFileSelector *fs)
1542
1501
{
1543
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), NULL);
1544
1545
return fs->priv->cwd;
1502
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), NULL);
1503
1504
return fs->priv->cwd;
1546
1505
}
1547
1506
1548
1507
1549
1508
void
1550
1509
gnome_cmd_file_selector_reload (GnomeCmdFileSelector *fs)
1551
1510
{
1552
GnomeCmdDir *dir;
1553
1554
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1555
1556
gnome_cmd_file_list_unselect_all (fs->list);
1557
1558
dir = gnome_cmd_file_selector_get_directory (fs);
1559
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1560
1561
gnome_cmd_dir_relist_files (
1562
dir, gnome_cmd_con_needs_list_visprog (fs->priv->con));
1511
GnomeCmdDir *dir;
1512
1513
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1514
1515
gnome_cmd_file_list_unselect_all (fs->list);
1516
1517
dir = gnome_cmd_file_selector_get_directory (fs);
1518
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1519
1520
gnome_cmd_dir_relist_files (
1521
dir, gnome_cmd_con_needs_list_visprog (fs->priv->con));
1563
1522
}
1564
1523
1565
1524
1566
1525
void
1567
1526
gnome_cmd_file_selector_start_editor (GnomeCmdFileSelector *fs)
1568
1527
{
1569
gint i;
1570
gint l;
1571
gchar *cmd, *dpath;
1572
1573
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1574
g_return_if_fail (GNOME_CMD_IS_DIR (fs->priv->cwd));
1575
g_return_if_fail (GNOME_CMD_IS_CON (fs->priv->con));
1576
1577
if (!gnome_cmd_con_is_local (fs->priv->con))
1578
return;
1579
1580
/* create a command with an empty argument to the editor */
1581
cmd = g_strdup (gnome_cmd_data_get_editor ());
1582
l = strlen(cmd);
1583
for ( i=0 ; i<l ; i++ ) {
1584
if (cmd[i] == ' ') {
1585
cmd[i] = '\0';
1586
break;
1587
}
1588
}
1589
1590
dpath = gnome_cmd_file_get_real_path (GNOME_CMD_FILE (fs->priv->cwd));
1591
run_command_indir (cmd, dpath, FALSE);
1592
g_free (dpath);
1528
gint i;
1529
gint l;
1530
gchar *cmd, *dpath;
1531
1532
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1533
g_return_if_fail (GNOME_CMD_IS_DIR (fs->priv->cwd));
1534
g_return_if_fail (GNOME_CMD_IS_CON (fs->priv->con));
1535
1536
if (!gnome_cmd_con_is_local (fs->priv->con))
1537
return;
1538
1539
/* create a command with an empty argument to the editor */
1540
cmd = g_strdup (gnome_cmd_data_get_editor ());
1541
l = strlen(cmd);
1542
for ( i=0 ; i<l ; i++ ) {
1543
if (cmd[i] == ' ') {
1544
cmd[i] = '\0';
1545
break;
1546
}
1547
}
1548
1549
dpath = gnome_cmd_file_get_real_path (GNOME_CMD_FILE (fs->priv->cwd));
1550
run_command_indir (cmd, dpath, FALSE);
1551
g_free (dpath);
1552
}
1553
1554
1555
void
1556
gnome_cmd_file_selector_first (GnomeCmdFileSelector *fs)
1557
{
1558
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1559
if (!fs->priv->dir_history) return;
1560
1561
if (history_can_back (fs->priv->dir_history)) {
1562
fs->priv->dir_history->lock = TRUE;
1563
goto_directory (fs, history_first (fs->priv->dir_history));
1564
fs->priv->dir_history->lock = FALSE;
1565
}
1593
1566
}
1594
1567
1595
1568
1596
1569
void
1597
1570
gnome_cmd_file_selector_back (GnomeCmdFileSelector *fs)
1598
1571
{
1599
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1600
if (!fs->priv->dir_history) return;
1601
1602
if (history_can_back (fs->priv->dir_history)) {
1603
fs->priv->dir_history->lock = TRUE;
1604
goto_directory (fs, history_back (fs->priv->dir_history));
1605
fs->priv->dir_history->lock = FALSE;
1606
}
1572
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1573
if (!fs->priv->dir_history) return;
1574
1575
if (history_can_back (fs->priv->dir_history)) {
1576
fs->priv->dir_history->lock = TRUE;
1577
goto_directory (fs, history_back (fs->priv->dir_history));
1578
fs->priv->dir_history->lock = FALSE;
1579
}
1607
1580
}
1608
1581
1609
1582
1610
1583
void
1611
1584
gnome_cmd_file_selector_forward (GnomeCmdFileSelector *fs)
1612
1585
{
1613
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1614
if (!fs->priv->dir_history) return;
1615
1616
if (history_can_forward (fs->priv->dir_history)) {
1617
fs->priv->dir_history->lock = TRUE;
1618
goto_directory (fs, history_forward (fs->priv->dir_history));
1619
fs->priv->dir_history->lock = FALSE;
1620
}
1586
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1587
if (!fs->priv->dir_history) return;
1588
1589
if (history_can_forward (fs->priv->dir_history)) {
1590
fs->priv->dir_history->lock = TRUE;
1591
goto_directory (fs, history_forward (fs->priv->dir_history));
1592
fs->priv->dir_history->lock = FALSE;
1593
}
1594
}
1595
1596
1597
void
1598
gnome_cmd_file_selector_last (GnomeCmdFileSelector *fs)
1599
{
1600
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1601
if (!fs->priv->dir_history) return;
1602
1603
if (history_can_forward (fs->priv->dir_history)) {
1604
fs->priv->dir_history->lock = TRUE;
1605
goto_directory (fs, history_last (fs->priv->dir_history));
1606
fs->priv->dir_history->lock = FALSE;
1607
}
1621
1608
}
1622
1609
1623
1610
1624
1611
gboolean
1625
1612
gnome_cmd_file_selector_can_back (GnomeCmdFileSelector *fs)
1626
1613
{
1627
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), FALSE);
1628
if (!fs->priv->dir_history) return FALSE;
1629
1630
return history_can_back (fs->priv->dir_history);
1614
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), FALSE);
1615
if (!fs->priv->dir_history) return FALSE;
1616
1617
return history_can_back (fs->priv->dir_history);
1631
1618
}
1632
1619
1633
1620
1634
1621
gboolean
1635
1622
gnome_cmd_file_selector_can_forward (GnomeCmdFileSelector *fs)
1636
1623
{
1637
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), FALSE);
1638
if (!fs->priv->dir_history) return FALSE;
1624
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), FALSE);
1625
if (!fs->priv->dir_history) return FALSE;
1639
1626
1640
return history_can_forward (fs->priv->dir_history);
1627
return history_can_forward (fs->priv->dir_history);
1641
1628
}
1642
1629
1643
1630
1644
1631
void
1645
1632
gnome_cmd_file_selector_set_directory (GnomeCmdFileSelector *fs, GnomeCmdDir *dir)
1646
1633
{
1647
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1648
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1649
1650
if (fs->priv->cwd == dir)
1651
return;
1652
1653
gnome_cmd_dir_ref (dir);
1654
1655
if (fs->priv->lwd && fs->priv->lwd != dir) {
1656
gnome_cmd_dir_unref (fs->priv->lwd);
1657
}
1658
1659
if (fs->priv->cwd) {
1660
gnome_cmd_dir_cancel_monitoring (fs->priv->cwd);
1661
fs->priv->lwd = fs->priv->cwd;
1662
gtk_signal_disconnect_by_data (GTK_OBJECT (fs->priv->lwd), fs);
1663
fs->priv->connected_dir = NULL;
1664
fs->priv->lwd->voffset = gnome_cmd_clist_get_voffset (GNOME_CMD_CLIST (fs->list));
1665
}
1666
1667
fs->priv->cwd = dir;
1668
1669
if (fs->priv->realized) {
1670
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
1671
set_cursor_busy_for_widget (GTK_WIDGET (fs));
1672
}
1673
1674
gtk_signal_connect (GTK_OBJECT (dir), "list-ok",
1675
GTK_SIGNAL_FUNC (on_dir_list_ok), fs);
1676
gtk_signal_connect (GTK_OBJECT (dir), "list-failed",
1677
GTK_SIGNAL_FUNC (on_dir_list_failed), fs);
1678
1679
gnome_cmd_dir_list_files (
1680
dir, gnome_cmd_con_needs_list_visprog (fs->priv->con));
1681
gnome_cmd_dir_start_monitoring (dir);
1634
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1635
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1636
1637
if (fs->priv->cwd == dir)
1638
return;
1639
1640
gnome_cmd_dir_ref (dir);
1641
1642
if (fs->priv->lwd && fs->priv->lwd != dir) {
1643
gnome_cmd_dir_unref (fs->priv->lwd);
1644
}
1645
1646
if (fs->priv->cwd) {
1647
gnome_cmd_dir_cancel_monitoring (fs->priv->cwd);
1648
fs->priv->lwd = fs->priv->cwd;
1649
gtk_signal_disconnect_by_data (GTK_OBJECT (fs->priv->lwd), fs);
1650
fs->priv->connected_dir = NULL;
1651
fs->priv->lwd->voffset = gnome_cmd_clist_get_voffset (GNOME_CMD_CLIST (fs->list));
1652
}
1653
1654
fs->priv->cwd = dir;
1655
1656
if (fs->priv->realized) {
1657
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
1658
set_cursor_busy_for_widget (GTK_WIDGET (fs));
1659
}
1660
1661
gtk_signal_connect (GTK_OBJECT (dir), "list-ok",
1662
GTK_SIGNAL_FUNC (on_dir_list_ok), fs);
1663
gtk_signal_connect (GTK_OBJECT (dir), "list-failed",
1664
GTK_SIGNAL_FUNC (on_dir_list_failed), fs);
1665
1666
gnome_cmd_dir_list_files (
1667
dir, gnome_cmd_con_needs_list_visprog (fs->priv->con));
1668
gnome_cmd_dir_start_monitoring (dir);
1682
1669
}
1683
1670
1684
1671
1685
1672
void
1686
1673
gnome_cmd_file_selector_goto_directory (GnomeCmdFileSelector *fs,
1687
const gchar *dir)
1674
const gchar *dir)
1688
1675
{
1689
goto_directory (fs, dir);
1676
goto_directory (fs, dir);
1690
1677
}
1691
1678
1692
1679
1693
1680
void
1694
1681
gnome_cmd_file_selector_set_active (GnomeCmdFileSelector *fs,
1695
gboolean value)
1682
gboolean value)
1696
1683
{
1697
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1698
1699
fs->priv->active = value;
1700
1701
if (value) {
1702
gtk_widget_grab_focus (fs->list_widget);
1703
gnome_cmd_file_list_select_row (
1704
fs->list, GTK_CLIST (fs->list)->focus_row);
1705
}
1706
else
1707
gtk_clist_unselect_all (GTK_CLIST (fs->list));
1708
1709
gnome_cmd_dir_indicator_set_active (
1710
GNOME_CMD_DIR_INDICATOR (fs->dir_indicator), value);
1684
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1685
1686
fs->priv->active = value;
1687
1688
if (value) {
1689
gtk_widget_grab_focus (fs->list_widget);
1690
gnome_cmd_file_list_select_row (
1691
fs->list, GTK_CLIST (fs->list)->focus_row);
1692
}
1693
else
1694
gtk_clist_unselect_all (GTK_CLIST (fs->list));
1695
1696
gnome_cmd_dir_indicator_set_active (
1697
GNOME_CMD_DIR_INDICATOR (fs->dir_indicator), value);
1711
1698
}
1712
1699
1713
1700
1714
1701
static void
1715
1702
on_con_open_cancel (GtkButton *button, GnomeCmdFileSelector *fs)
1716
1703
{
1717
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1718
g_return_if_fail (fs->priv->con_opening != NULL);
1719
g_return_if_fail (fs->priv->con_opening->state == CON_STATE_OPENING);
1720
1721
DEBUG('m', "on_con_open_cancel\n");
1722
gnome_cmd_con_cancel_open (fs->priv->con_opening);
1723
1724
gtk_widget_destroy (fs->priv->con_open_dialog);
1725
fs->priv->con_open_dialog = NULL;
1726
fs->priv->con_opening = NULL;
1704
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1705
g_return_if_fail (fs->priv->con_opening != NULL);
1706
g_return_if_fail (fs->priv->con_opening->state == CON_STATE_OPENING);
1707
1708
DEBUG('m', "on_con_open_cancel\n");
1709
gnome_cmd_con_cancel_open (fs->priv->con_opening);
1710
1711
gtk_widget_destroy (fs->priv->con_open_dialog);
1712
fs->priv->con_open_dialog = NULL;
1713
fs->priv->con_opening = NULL;
1727
1714
}
1728
1715
1729
1716
1730
1717
static gboolean
1731
1718
update_con_open_progress (GnomeCmdFileSelector *fs)
1732
1719
{
1733
const gchar *msg;
1734
1735
if (!fs->priv->con_open_dialog)
1736
return FALSE;
1737
1738
msg = gnome_cmd_con_get_open_msg (fs->priv->con_opening);
1739
gtk_label_set_text (GTK_LABEL (fs->priv->con_open_dialog_label), msg);
1740
progress_bar_update (fs->priv->con_open_dialog_pbar, FS_PBAR_MAX);
1741
1742
return TRUE;
1720
const gchar *msg;
1721
1722
if (!fs->priv->con_open_dialog)
1723
return FALSE;
1724
1725
msg = gnome_cmd_con_get_open_msg (fs->priv->con_opening);
1726
gtk_label_set_text (GTK_LABEL (fs->priv->con_open_dialog_label), msg);
1727
progress_bar_update (fs->priv->con_open_dialog_pbar, FS_PBAR_MAX);
1728
1729
return TRUE;
1743
1730
}
1744
1731
1745
1732
1746
1733
static void
1747
1734
on_con_open_done (GnomeCmdCon *con, GnomeCmdFileSelector *fs)
1748
1735
{
1749
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1750
g_return_if_fail (fs->priv->con_opening != NULL);
1751
g_return_if_fail (fs->priv->con_opening == con);
1752
g_return_if_fail (fs->priv->con_open_dialog != NULL);
1753
1754
DEBUG('m', "on_con_open_done\n");
1755
gtk_signal_disconnect_by_data (GTK_OBJECT (con), fs);
1756
1757
set_connection (fs, con, NULL);
1758
1759
gtk_widget_destroy (fs->priv->con_open_dialog);
1760
fs->priv->con_open_dialog = NULL;
1761
fs->priv->con_opening = NULL;
1736
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1737
g_return_if_fail (fs->priv->con_opening != NULL);
1738
g_return_if_fail (fs->priv->con_opening == con);
1739
g_return_if_fail (fs->priv->con_open_dialog != NULL);
1740
1741
DEBUG('m', "on_con_open_done\n");
1742
gtk_signal_disconnect_by_data (GTK_OBJECT (con), fs);
1743
1744
set_connection (fs, con, NULL);
1745
1746
gtk_widget_destroy (fs->priv->con_open_dialog);
1747
fs->priv->con_open_dialog = NULL;
1748
fs->priv->con_opening = NULL;
1762
1749
}
1763
1750
1764
1751
1765
1752
static void
1766
1753
on_con_open_failed (GnomeCmdCon *con, const gchar *emsg, GnomeVFSResult result,
1767
GnomeCmdFileSelector *fs)
1754
GnomeCmdFileSelector *fs)
1768
1755
{
1769
gchar *s;
1770
1771
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1772
g_return_if_fail (fs->priv->con_opening != NULL);
1773
g_return_if_fail (fs->priv->con_opening == con);
1774
g_return_if_fail (fs->priv->con_open_dialog != NULL);
1775
1776
DEBUG('m', "on_con_open_failed\n");
1777
gtk_signal_disconnect_by_data (GTK_OBJECT (con), fs);
1778
1779
if (emsg)
1780
s = g_strdup (emsg);
1781
else
1782
s = g_strdup_printf (_("Failed to open connection: %s\n"),
1783
gnome_vfs_result_to_string (result));
1784
1785
if (result != GNOME_VFS_OK || emsg != NULL)
1786
create_error_dialog (s);
1787
1788
g_free (s);
1789
1790
gtk_widget_destroy (fs->priv->con_open_dialog);
1791
fs->priv->con_open_dialog = NULL;
1792
fs->priv->con_opening = NULL;
1756
gchar *s;
1757
1758
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1759
g_return_if_fail (fs->priv->con_opening != NULL);
1760
g_return_if_fail (fs->priv->con_opening == con);
1761
g_return_if_fail (fs->priv->con_open_dialog != NULL);
1762
1763
DEBUG('m', "on_con_open_failed\n");
1764
gtk_signal_disconnect_by_data (GTK_OBJECT (con), fs);
1765
1766
if (emsg)
1767
s = g_strdup (emsg);
1768
else
1769
s = g_strdup_printf (_("Failed to open connection: %s\n"),
1770
gnome_vfs_result_to_string (result));
1771
1772
if (result != GNOME_VFS_OK || emsg != NULL)
1773
create_error_dialog (s);
1774
1775
g_free (s);
1776
1777
gtk_widget_destroy (fs->priv->con_open_dialog);
1778
fs->priv->con_open_dialog = NULL;
1779
fs->priv->con_opening = NULL;
1793
1780
}
1794
1781
1795
1782
1796
1783
static void
1797
1784
create_con_open_progress_dialog (GnomeCmdFileSelector *fs)
1798
1785
{
1799
GtkWidget *vbox;
1800
1801
fs->priv->con_open_dialog = gnome_cmd_dialog_new (NULL);
1802
gtk_widget_ref (fs->priv->con_open_dialog);
1803
1804
gnome_cmd_dialog_add_button (
1805
GNOME_CMD_DIALOG (fs->priv->con_open_dialog),
1806
GNOME_STOCK_BUTTON_CANCEL,
1807
GTK_SIGNAL_FUNC (on_con_open_cancel), fs);
1808
1809
vbox = create_vbox (fs->priv->con_open_dialog, FALSE, 0);
1810
1811
fs->priv->con_open_dialog_label = create_label (
1812
fs->priv->con_open_dialog, "");
1813
1814
fs->priv->con_open_dialog_pbar = create_progress_bar (
1815
fs->priv->con_open_dialog);
1816
gtk_progress_set_show_text (GTK_PROGRESS (fs->priv->con_open_dialog_pbar), FALSE);
1817
gtk_progress_set_activity_mode (GTK_PROGRESS (fs->priv->con_open_dialog_pbar), TRUE);
1818
gtk_progress_configure (GTK_PROGRESS (fs->priv->con_open_dialog_pbar), 0, 0, FS_PBAR_MAX);
1819
1820
gtk_box_pack_start (GTK_BOX (vbox), fs->priv->con_open_dialog_label, TRUE, TRUE, 0);
1821
gtk_box_pack_start (GTK_BOX (vbox), fs->priv->con_open_dialog_pbar, FALSE, TRUE, 0);
1822
1823
gnome_cmd_dialog_add_category (GNOME_CMD_DIALOG (fs->priv->con_open_dialog), vbox);
1824
1825
gnome_cmd_dialog_set_transient_for (
1826
GNOME_CMD_DIALOG (fs->priv->con_open_dialog),
1827
GTK_WINDOW (main_win));
1828
1829
gtk_widget_show_all (fs->priv->con_open_dialog);
1786
GtkWidget *vbox;
1787
1788
fs->priv->con_open_dialog = gnome_cmd_dialog_new (NULL);
1789
gtk_widget_ref (fs->priv->con_open_dialog);
1790
1791
gnome_cmd_dialog_add_button (
1792
GNOME_CMD_DIALOG (fs->priv->con_open_dialog),
1793
GNOME_STOCK_BUTTON_CANCEL,
1794
GTK_SIGNAL_FUNC (on_con_open_cancel), fs);
1795
1796
vbox = create_vbox (fs->priv->con_open_dialog, FALSE, 0);
1797
1798
fs->priv->con_open_dialog_label = create_label (
1799
fs->priv->con_open_dialog, "");
1800
1801
fs->priv->con_open_dialog_pbar = create_progress_bar (
1802
fs->priv->con_open_dialog);
1803
gtk_progress_set_show_text (GTK_PROGRESS (fs->priv->con_open_dialog_pbar), FALSE);
1804
gtk_progress_set_activity_mode (GTK_PROGRESS (fs->priv->con_open_dialog_pbar), TRUE);
1805
gtk_progress_configure (GTK_PROGRESS (fs->priv->con_open_dialog_pbar), 0, 0, FS_PBAR_MAX);
1806
1807
gtk_box_pack_start (GTK_BOX (vbox), fs->priv->con_open_dialog_label, TRUE, TRUE, 0);
1808
gtk_box_pack_start (GTK_BOX (vbox), fs->priv->con_open_dialog_pbar, FALSE, TRUE, 0);
1809
1810
gnome_cmd_dialog_add_category (GNOME_CMD_DIALOG (fs->priv->con_open_dialog), vbox);
1811
1812
gnome_cmd_dialog_set_transient_for (
1813
GNOME_CMD_DIALOG (fs->priv->con_open_dialog),
1814
GTK_WINDOW (main_win));
1815
1816
gtk_widget_show_all (fs->priv->con_open_dialog);
1830
1817
}
1831
1818
1832
1819
1833
1820
void
1834
1821
gnome_cmd_file_selector_set_connection (GnomeCmdFileSelector *fs,
1835
GnomeCmdCon *con,
1836
GnomeCmdDir *dir)
1822
GnomeCmdCon *con,
1823
GnomeCmdDir *dir)
1837
1824
{
1838
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1839
g_return_if_fail (GNOME_CMD_IS_CON (con));
1840
1841
if (fs->priv->con == con) {
1842
if (!gnome_cmd_con_should_remember_dir (con))
1843
gnome_cmd_file_selector_set_directory (
1844
fs,
1845
gnome_cmd_con_get_default_dir (con));
1846
return;
1847
}
1848
1849
if (!gnome_cmd_con_is_open (con)) {
1850
gtk_signal_connect (GTK_OBJECT (con), "open-done",
1851
GTK_SIGNAL_FUNC (on_con_open_done), fs);
1852
gtk_signal_connect (GTK_OBJECT (con), "open-failed",
1853
GTK_SIGNAL_FUNC (on_con_open_failed), fs);
1854
fs->priv->con_opening = con;
1855
1856
create_con_open_progress_dialog (fs);
1857
gtk_timeout_add (gnome_cmd_data_get_gui_update_rate (), (GtkFunction)update_con_open_progress, fs);
1858
1859
gnome_cmd_con_open (con);
1860
}
1861
else
1862
set_connection (fs, con, dir);
1825
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1826
g_return_if_fail (GNOME_CMD_IS_CON (con));
1827
1828
if (fs->priv->con == con) {
1829
if (!gnome_cmd_con_should_remember_dir (con))
1830
gnome_cmd_file_selector_set_directory (
1831
fs,
1832
gnome_cmd_con_get_default_dir (con));
1833
return;
1834
}
1835
1836
if (!gnome_cmd_con_is_open (con)) {
1837
gtk_signal_connect (GTK_OBJECT (con), "open-done",
1838
GTK_SIGNAL_FUNC (on_con_open_done), fs);
1839
gtk_signal_connect (GTK_OBJECT (con), "open-failed",
1840
GTK_SIGNAL_FUNC (on_con_open_failed), fs);
1841
fs->priv->con_opening = con;
1842
1843
create_con_open_progress_dialog (fs);
1844
gtk_timeout_add (gnome_cmd_data_get_gui_update_rate (), (GtkFunction)update_con_open_progress, fs);
1845
1846
gnome_cmd_con_open (con);
1847
}
1848
else
1849
set_connection (fs, con, dir);
1863
1850
}
1864
1851
1865
1852
1866
1853
void
1867
1854
gnome_cmd_file_selector_update_connections (GnomeCmdFileSelector *fs)
1868
1855
{
1869
GList *l;
1870
gboolean found_my_con = FALSE;
1871
GnomeCmdConList *con_list;
1872
1873
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1874
1875
if (!fs->priv->realized)
1876
return;
1877
1878
fs->priv->selection_lock = TRUE;
1879
1880
gnome_cmd_combo_clear (GNOME_CMD_COMBO (fs->con_combo));
1881
GNOME_CMD_COMBO (fs->con_combo)->highest_pixmap = 20;
1882
GNOME_CMD_COMBO (fs->con_combo)->widest_pixmap = 20;
1883
gtk_clist_set_row_height (GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 20);
1884
gtk_clist_set_column_width (GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 0, 20);
1885
1886
con_list = gnome_cmd_data_get_con_list ();
1887
l = gnome_cmd_con_list_get_all (con_list);
1888
while (l)
1889
{
1890
gint row;
1891
gchar *text[3];
1892
GnomeCmdPixmap *pixmap;
1893
GnomeCmdCon *con = (GnomeCmdCon*)l->data;
1894
1895
if (!gnome_cmd_con_is_open (con) && !GNOME_CMD_IS_CON_DEVICE (con)
1896
&& !GNOME_CMD_IS_CON_SMB (con)) {
1897
l = l->next;
1898
continue;
1899
}
1900
1901
if (con == fs->priv->con)
1902
found_my_con = TRUE;
1903
1904
text[0] = NULL;
1905
text[1] = (gchar*)gnome_cmd_con_get_alias (con);
1906
text[2] = NULL;
1907
1908
pixmap = gnome_cmd_con_get_go_pixmap (con);
1909
1910
row = gnome_cmd_combo_append (GNOME_CMD_COMBO (fs->con_combo), text, con);
1911
if (pixmap)
1912
gnome_cmd_combo_set_pixmap (GNOME_CMD_COMBO (fs->con_combo), row, 0, pixmap);
1913
1914
l = l->next;
1915
}
1916
1917
fs->priv->selection_lock = FALSE;
1918
1919
// If the connection is no longer available use the home connection
1920
if (!found_my_con)
1921
gnome_cmd_file_selector_set_connection (
1922
fs, gnome_cmd_con_list_get_home (con_list), NULL);
1923
else {
1924
gnome_cmd_combo_select_data (GNOME_CMD_COMBO (fs->con_combo), fs->priv->con);
1925
}
1926
1927
create_con_buttons (fs);
1856
GList *l;
1857
gboolean found_my_con = FALSE;
1858
GnomeCmdConList *con_list;
1859
1860
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1861
1862
if (!fs->priv->realized)
1863
return;
1864
1865
fs->priv->selection_lock = TRUE;
1866
1867
gnome_cmd_combo_clear (GNOME_CMD_COMBO (fs->con_combo));
1868
GNOME_CMD_COMBO (fs->con_combo)->highest_pixmap = 20;
1869
GNOME_CMD_COMBO (fs->con_combo)->widest_pixmap = 20;
1870
gtk_clist_set_row_height (GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 20);
1871
gtk_clist_set_column_width (GTK_CLIST (GNOME_CMD_COMBO (fs->con_combo)->list), 0, 20);
1872
1873
con_list = gnome_cmd_data_get_con_list ();
1874
l = gnome_cmd_con_list_get_all (con_list);
1875
while (l)
1876
{
1877
gint row;
1878
gchar *text[3];
1879
GnomeCmdPixmap *pixmap;
1880
GnomeCmdCon *con = (GnomeCmdCon*)l->data;
1881
1882
if (!gnome_cmd_con_is_open (con) && !GNOME_CMD_IS_CON_DEVICE (con)
1883
&& !GNOME_CMD_IS_CON_SMB (con)) {
1884
l = l->next;
1885
continue;
1886
}
1887
1888
if (con == fs->priv->con)
1889
found_my_con = TRUE;
1890
1891
text[0] = NULL;
1892
text[1] = (gchar*)gnome_cmd_con_get_alias (con);
1893
text[2] = NULL;
1894
1895
pixmap = gnome_cmd_con_get_go_pixmap (con);
1896
1897
row = gnome_cmd_combo_append (GNOME_CMD_COMBO (fs->con_combo), text, con);
1898
if (pixmap)
1899
gnome_cmd_combo_set_pixmap (GNOME_CMD_COMBO (fs->con_combo), row, 0, pixmap);
1900
1901
l = l->next;
1902
}
1903
1904
fs->priv->selection_lock = FALSE;
1905
1906
// If the connection is no longer available use the home connection
1907
if (!found_my_con)
1908
gnome_cmd_file_selector_set_connection (
1909
fs, gnome_cmd_con_list_get_home (con_list), NULL);
1910
else {
1911
gnome_cmd_combo_select_data (GNOME_CMD_COMBO (fs->con_combo), fs->priv->con);
1912
}
1913
1914
create_con_buttons (fs);
1928
1915
}
1929
1916
1930
1917
1931
1918
GnomeCmdCon *
1932
1919
gnome_cmd_file_selector_get_connection (GnomeCmdFileSelector *fs)
1933
1920
{
1934
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), NULL);
1935
1936
return fs->priv->con;
1921
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), NULL);
1922
1923
return fs->priv->con;
1937
1924
}
1938
1925
1939
1926
1940
1927
void
1941
1928
gnome_cmd_file_selector_update_style (GnomeCmdFileSelector *fs)
1942
1929
{
1943
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1944
1945
gnome_cmd_combo_update_style (GNOME_CMD_COMBO (fs->con_combo));
1946
gnome_cmd_file_list_update_style (fs->list);
1947
1948
if (fs->priv->realized)
1949
update_files (fs);
1950
1951
gnome_cmd_file_list_show_column (
1952
fs->list, FILE_LIST_COLUMN_EXT,
1953
gnome_cmd_data_get_ext_disp_mode () != GNOME_CMD_EXT_DISP_WITH_FNAME);
1954
1955
create_con_buttons (fs);
1956
gnome_cmd_file_selector_update_connections (fs);
1930
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
1931
1932
gnome_cmd_combo_update_style (GNOME_CMD_COMBO (fs->con_combo));
1933
gnome_cmd_file_list_update_style (fs->list);
1934
1935
if (fs->priv->realized)
1936
update_files (fs);
1937
1938
gnome_cmd_file_list_show_column (
1939
fs->list, FILE_LIST_COLUMN_EXT,
1940
gnome_cmd_data_get_ext_disp_mode () != GNOME_CMD_EXT_DISP_WITH_FNAME);
1941
1942
create_con_buttons (fs);
1943
gnome_cmd_file_selector_update_connections (fs);
1957
1944
}
1958
1945
1959
1946
1960
1947
void
1961
1948
gnome_cmd_file_selector_show_mkdir_dialog (GnomeCmdFileSelector *fs)
1962
1949
{
1963
GtkWidget *dialog;
1964
GnomeCmdDir *dir;
1965
1966
dir = gnome_cmd_file_selector_get_directory (fs);
1967
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1968
1969
dialog = gnome_cmd_mkdir_dialog_new (dir);
1970
g_return_if_fail (GNOME_CMD_IS_DIALOG (dialog));
1971
1972
gtk_widget_ref (dialog);
1973
gtk_widget_show (dialog);
1950
GtkWidget *dialog;
1951
GnomeCmdDir *dir;
1952
1953
dir = gnome_cmd_file_selector_get_directory (fs);
1954
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
1955
1956
dialog = gnome_cmd_mkdir_dialog_new (dir);
1957
g_return_if_fail (GNOME_CMD_IS_DIALOG (dialog));
1958
1959
gtk_widget_ref (dialog);
1960
gtk_widget_show (dialog);
1974
1961
}
1975
1962
1976
1963
1977
1964
static gboolean
1978
1965
on_new_textfile_ok (GnomeCmdStringDialog *string_dialog,
1979
const gchar **values,
1980
GnomeCmdFileSelector *fs)
1966
const gchar **values,
1967
GnomeCmdFileSelector *fs)
1981
1968
{
1982
gchar *cmd, *dpath;
1983
gchar *filepath;
1984
const gchar *filename = values[0];
1985
GnomeCmdDir *dir;
1986
1987
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), TRUE);
1988
1989
if (!filename) {
1990
gnome_cmd_string_dialog_set_error_desc (
1991
string_dialog, g_strdup (_("No filename entered")));
1992
return FALSE;
1993
}
1994
1995
dir = gnome_cmd_file_selector_get_directory (fs);
1996
g_return_val_if_fail (GNOME_CMD_IS_DIR (dir), TRUE);
1997
1998
dpath = gnome_cmd_file_get_real_path (GNOME_CMD_FILE (dir));
1999
filepath = g_build_path ("/", dpath, filename, NULL);
2000
g_free (dpath);
2001
g_return_val_if_fail (filepath, TRUE);
2002
2003
cmd = g_strdup_printf (gnome_cmd_data_get_editor (), filepath);
2004
g_return_val_if_fail (cmd, TRUE);
2005
2006
run_command (cmd, FALSE);
2007
2008
return TRUE;
1969
gchar *cmd, *dpath;
1970
gchar *filepath;
1971
const gchar *filename = values[0];
1972
GnomeCmdDir *dir;
1973
1974
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), TRUE);
1975
1976
if (!filename) {
1977
gnome_cmd_string_dialog_set_error_desc (
1978
string_dialog, g_strdup (_("No filename entered")));
1979
return FALSE;
1980
}
1981
1982
dir = gnome_cmd_file_selector_get_directory (fs);
1983
g_return_val_if_fail (GNOME_CMD_IS_DIR (dir), TRUE);
1984
1985
dpath = gnome_cmd_file_get_real_path (GNOME_CMD_FILE (dir));
1986
filepath = g_build_path ("/", dpath, filename, NULL);
1987
g_free (dpath);
1988
g_return_val_if_fail (filepath, TRUE);
1989
1990
cmd = g_strdup_printf (gnome_cmd_data_get_editor (), filepath);
1991
g_return_val_if_fail (cmd, TRUE);
1992
1993
run_command (cmd, FALSE);
1994
1995
return TRUE;
2009
1996
}
2010
1997
2011
1998
2012
1999
static gboolean
2013
2000
on_create_symlink_ok (GnomeCmdStringDialog *string_dialog,
2014
const gchar **values,
2015
GnomeCmdFileSelector *fs)
2001
const gchar **values,
2002
GnomeCmdFileSelector *fs)
2016
2003
{
2017
const gchar *name = values[0];
2018
GnomeVFSResult result;
2019
GnomeVFSURI *uri;
2020
2021
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), TRUE);
2022
g_return_val_if_fail (fs->priv->sym_file != NULL, TRUE);
2023
2024
/* dont create any symlink if no name was passed or cancel was selected */
2025
if (name == NULL || strcmp (name, "") == 0) {
2026
gnome_cmd_string_dialog_set_error_desc (
2027
string_dialog, g_strdup (_("No filename given")));
2028
return FALSE;
2029
}
2030
2031
uri = gnome_cmd_dir_get_child_uri (fs->priv->cwd, name);
2032
2033
result = gnome_vfs_create_symbolic_link (
2034
uri, gnome_cmd_file_get_uri_str (fs->priv->sym_file));
2035
2036
if (result == GNOME_VFS_OK) {
2037
gchar *uri_str = gnome_vfs_uri_to_string (uri, 0);
2038
gnome_cmd_dir_file_created (fs->priv->cwd, uri_str);
2039
g_free (uri_str);
2040
gnome_vfs_uri_unref (uri);
2041
return TRUE;
2042
}
2043
2044
gnome_vfs_uri_unref (uri);
2045
2046
gnome_cmd_string_dialog_set_error_desc (
2047
string_dialog, g_strdup (gnome_vfs_result_to_string (result)));
2048
2049
return FALSE;
2004
const gchar *name = values[0];
2005
GnomeVFSResult result;
2006
GnomeVFSURI *uri;
2007
2008
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), TRUE);
2009
g_return_val_if_fail (fs->priv->sym_file != NULL, TRUE);
2010
2011
/* dont create any symlink if no name was passed or cancel was selected */
2012
if (name == NULL || strcmp (name, "") == 0) {
2013
gnome_cmd_string_dialog_set_error_desc (
2014
string_dialog, g_strdup (_("No filename given")));
2015
return FALSE;
2016
}
2017
2018
uri = gnome_cmd_dir_get_child_uri (fs->priv->cwd, name);
2019
2020
result = gnome_vfs_create_symbolic_link (
2021
uri, gnome_cmd_file_get_uri_str (fs->priv->sym_file));
2022
2023
if (result == GNOME_VFS_OK) {
2024
gchar *uri_str = gnome_vfs_uri_to_string (uri, 0);
2025
gnome_cmd_dir_file_created (fs->priv->cwd, uri_str);
2026
g_free (uri_str);
2027
gnome_vfs_uri_unref (uri);
2028
return TRUE;
2029
}
2030
2031
gnome_vfs_uri_unref (uri);
2032
2033
gnome_cmd_string_dialog_set_error_desc (
2034
string_dialog, g_strdup (gnome_vfs_result_to_string (result)));
2035
2036
return FALSE;
2050
2037
}
2051
2038
2052
2039
2053
2040
void
2054
2041
gnome_cmd_file_selector_show_new_textfile_dialog (GnomeCmdFileSelector *fs)
2055
2042
{
2056
const gchar *labels[] = {_("Filename:")};
2057
GtkWidget *dialog;
2058
2059
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2060
2061
dialog = gnome_cmd_string_dialog_new (
2062
_("New Text File"), labels, 1,
2063
(GnomeCmdStringDialogCallback)on_new_textfile_ok, fs);
2064
g_return_if_fail (GNOME_CMD_IS_DIALOG (dialog));
2065
2066
gtk_widget_ref (dialog);
2067
gtk_widget_show (dialog);
2043
const gchar *labels[] = {_("Filename:")};
2044
GtkWidget *dialog;
2045
2046
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2047
2048
dialog = gnome_cmd_string_dialog_new (
2049
_("New Text File"), labels, 1,
2050
(GnomeCmdStringDialogCallback)on_new_textfile_ok, fs);
2051
g_return_if_fail (GNOME_CMD_IS_DIALOG (dialog));
2052
2053
gtk_widget_ref (dialog);
2054
gtk_widget_show (dialog);
2068
2055
}
2069
2056
2070
2057
2071
2058
void
2072
2059
gnome_cmd_file_selector_cap_paste (GnomeCmdFileSelector *fs)
2073
2060
{
2074
GnomeCmdDir *dir;
2075
2076
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2077
dir = gnome_cmd_file_selector_get_directory (fs);
2078
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
2079
2080
cap_paste_files (dir);
2061
GnomeCmdDir *dir;
2062
2063
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2064
dir = gnome_cmd_file_selector_get_directory (fs);
2065
g_return_if_fail (GNOME_CMD_IS_DIR (dir));
2066
2067
cap_paste_files (dir);
2081
2068
}
2082
2069
2083
2070
2084
2071
gboolean
2085
2072
gnome_cmd_file_selector_keypressed (GnomeCmdFileSelector *fs,
2086
GdkEventKey *event)
2073
GdkEventKey *event)
2087
2074
{
2088
GnomeCmdFile *finfo;
2089
2090
g_return_val_if_fail (event != NULL, FALSE);
2091
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), FALSE);
2092
2093
if (state_is_ctrl_shift (event->state)) {
2094
switch (event->keyval)
2095
{
2096
case GDK_Return:
2097
case GDK_KP_Enter:
2098
add_file_to_cmdline (fs, TRUE);
2099
return TRUE;
2100
2101
case GDK_greater:
2102
set_same_directory (gnome_cmd_main_win_get_inactive_fs (main_win),fs);
2103
return TRUE;
2104
}
2105
}
2106
else if (state_is_shift (event->state)) {
2107
switch (event->keyval)
2108
{
2109
case GDK_F5:
2110
gnome_cmd_file_list_show_make_copy_dialog (fs);
2111
return TRUE;
2112
2113
case GDK_F4:
2114
gnome_cmd_file_selector_start_editor (fs);
2115
return TRUE;
2116
}
2117
}
2118
else if (state_is_alt (event->state)) {
2119
switch (event->keyval)
2120
{
2121
case GDK_Down:
2122
gnome_cmd_dir_indicator_show_history (
2123
GNOME_CMD_DIR_INDICATOR (fs->dir_indicator));
2124
return TRUE;
2125
2126
case GDK_Left:
2127
gnome_cmd_file_selector_back (fs);
2128
stop_kp(GTK_OBJECT(fs->list));
2129
return TRUE;
2130
2131
case GDK_Right:
2132
gnome_cmd_file_selector_forward (fs);
2133
stop_kp(GTK_OBJECT(fs->list));
2134
return TRUE;
2135
}
2136
}
2137
else if (state_is_alt_shift (event->state)) {
2138
switch (event->keyval)
2139
{
2140
case GDK_Return:
2141
case GDK_KP_Enter:
2142
show_dir_tree_sizes (fs);
2143
return TRUE;
2144
}
2145
}
2146
else if (state_is_ctrl (event->state)) {
2147
switch (event->keyval)
2148
{
2149
case GDK_V:
2150
case GDK_v:
2151
gnome_cmd_file_selector_cap_paste (fs);
2152
return TRUE;
2153
2154
case GDK_R:
2155
case GDK_r:
2156
gnome_cmd_file_selector_reload (fs);
2157
return TRUE;
2158
2159
case GDK_P:
2160
case GDK_p:
2161
add_cwd_to_cmdline (fs);
2162
return TRUE;
2163
2164
case GDK_Page_Up:
2165
goto_directory (fs, "..");
2166
return TRUE;
2167
2168
case GDK_Page_Down:
2169
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
2170
if (finfo && finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY)
2171
do_file_specific_action (fs, finfo);
2172
return TRUE;
2173
2174
case GDK_Return:
2175
case GDK_KP_Enter:
2176
add_file_to_cmdline (fs, FALSE);
2177
return TRUE;
2178
2179
case GDK_period:
2180
set_same_directory (fs,
2181
gnome_cmd_main_win_get_inactive_fs (main_win));
2182
return TRUE;
2183
}
2184
}
2185
else if (state_is_blank (event->state)) {
2186
switch (event->keyval)
2187
{
2188
case GDK_space:
2189
set_cursor_busy ();
2190
gnome_cmd_file_list_toggle (fs->list);
2191
show_selected_dir_tree_size (fs);
2192
stop_kp (GTK_OBJECT (fs->list));
2193
set_cursor_default ();
2194
return TRUE;
2195
2196
case GDK_Left:
2197
case GDK_KP_Left:
2198
case GDK_BackSpace:
2199
goto_directory (fs, "..");
2200
return TRUE;
2201
2202
case GDK_Right:
2203
case GDK_KP_Right:
2204
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
2205
if (finfo && finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY)
2206
do_file_specific_action (fs, finfo);
2207
stop_kp (GTK_OBJECT (fs->list));
2208
return TRUE;
2209
2210
case GDK_Return:
2211
case GDK_KP_Enter:
2212
if (gnome_cmd_data_get_cmdline_visibility ()
2213
&& gnome_cmd_cmdline_is_empty (gnome_cmd_main_win_get_cmdline (main_win)))
2214
gnome_cmd_cmdline_exec (gnome_cmd_main_win_get_cmdline (main_win));
2215
else
2216
do_file_specific_action (
2217
fs, gnome_cmd_file_list_get_focused_file (fs->list));
2218
return TRUE;
2219
2220
case GDK_Escape:
2221
if (gnome_cmd_data_get_cmdline_visibility ())
2222
gnome_cmd_cmdline_set_text (
2223
gnome_cmd_main_win_get_cmdline (main_win), "");
2224
return TRUE;
2225
}
2226
}
2227
2228
return FALSE;
2075
GnomeCmdFile *finfo;
2076
2077
g_return_val_if_fail (event != NULL, FALSE);
2078
g_return_val_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs), FALSE);
2079
2080
if (state_is_ctrl_shift (event->state)) {
2081
switch (event->keyval)
2082
{
2083
case GDK_Return:
2084
case GDK_KP_Enter:
2085
add_file_to_cmdline (fs, TRUE);
2086
return TRUE;
2087
2088
case GDK_greater:
2089
set_same_directory (gnome_cmd_main_win_get_inactive_fs (main_win),fs);
2090
return TRUE;
2091
}
2092
}
2093
else if (state_is_shift (event->state)) {
2094
switch (event->keyval)
2095
{
2096
case GDK_F3:
2097
file_internal_view (NULL, NULL);
2098
return TRUE;
2099
2100
case GDK_F4:
2101
gnome_cmd_file_selector_start_editor (fs);
2102
return TRUE;
2103
2104
case GDK_F5:
2105
gnome_cmd_file_list_show_make_copy_dialog (fs);
2106
return TRUE;
2107
}
2108
}
2109
else if (state_is_alt (event->state)) {
2110
switch (event->keyval)
2111
{
2112
case GDK_Down:
2113
gnome_cmd_dir_indicator_show_history (
2114
GNOME_CMD_DIR_INDICATOR (fs->dir_indicator));
2115
return TRUE;
2116
2117
case GDK_Left:
2118
gnome_cmd_file_selector_back (fs);
2119
stop_kp(GTK_OBJECT(fs->list));
2120
return TRUE;
2121
2122
case GDK_Right:
2123
gnome_cmd_file_selector_forward (fs);
2124
stop_kp(GTK_OBJECT(fs->list));
2125
return TRUE;
2126
}
2127
}
2128
else if (state_is_alt_shift (event->state)) {
2129
switch (event->keyval)
2130
{
2131
case GDK_Return:
2132
case GDK_KP_Enter:
2133
show_dir_tree_sizes (fs);
2134
return TRUE;
2135
}
2136
}
2137
else if (state_is_ctrl (event->state)) {
2138
switch (event->keyval)
2139
{
2140
case GDK_V:
2141
case GDK_v:
2142
gnome_cmd_file_selector_cap_paste (fs);
2143
return TRUE;
2144
2145
case GDK_R:
2146
case GDK_r:
2147
gnome_cmd_file_selector_reload (fs);
2148
return TRUE;
2149
2150
case GDK_P:
2151
case GDK_p:
2152
add_cwd_to_cmdline (fs);
2153
return TRUE;
2154
2155
case GDK_Page_Up:
2156
goto_directory (fs, "..");
2157
return TRUE;
2158
2159
case GDK_Page_Down:
2160
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
2161
if (finfo && finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY)
2162
do_file_specific_action (fs, finfo);
2163
return TRUE;
2164
2165
case GDK_Return:
2166
case GDK_KP_Enter:
2167
add_file_to_cmdline (fs, FALSE);
2168
return TRUE;
2169
2170
case GDK_period:
2171
set_same_directory (fs,
2172
gnome_cmd_main_win_get_inactive_fs (main_win));
2173
return TRUE;
2174
}
2175
}
2176
else if (state_is_blank (event->state)) {
2177
switch (event->keyval)
2178
{
2179
case GDK_space:
2180
set_cursor_busy ();
2181
gnome_cmd_file_list_toggle (fs->list);
2182
show_selected_dir_tree_size (fs);
2183
stop_kp (GTK_OBJECT (fs->list));
2184
set_cursor_default ();
2185
return TRUE;
2186
2187
case GDK_Left:
2188
case GDK_KP_Left:
2189
case GDK_BackSpace:
2190
goto_directory (fs, "..");
2191
return TRUE;
2192
2193
case GDK_Right:
2194
case GDK_KP_Right:
2195
finfo = gnome_cmd_file_list_get_selected_file (fs->list);
2196
if (finfo && finfo->info->type == GNOME_VFS_FILE_TYPE_DIRECTORY)
2197
do_file_specific_action (fs, finfo);
2198
stop_kp (GTK_OBJECT (fs->list));
2199
return TRUE;
2200
2201
case GDK_Return:
2202
case GDK_KP_Enter:
2203
if (gnome_cmd_data_get_cmdline_visibility ()
2204
&& gnome_cmd_cmdline_is_empty (gnome_cmd_main_win_get_cmdline (main_win)))
2205
gnome_cmd_cmdline_exec (gnome_cmd_main_win_get_cmdline (main_win));
2206
else
2207
do_file_specific_action (
2208
fs, gnome_cmd_file_list_get_focused_file (fs->list));
2209
return TRUE;
2210
2211
case GDK_Escape:
2212
if (gnome_cmd_data_get_cmdline_visibility ())
2213
gnome_cmd_cmdline_set_text (
2214
gnome_cmd_main_win_get_cmdline (main_win), "");
2215
return TRUE;
2216
}
2217
}
2218
2219
return FALSE;
2229
2220
}
2230
2221
2231
2222
2232
2223
void
2233
2224
gnome_cmd_file_selector_create_symlink (GnomeCmdFileSelector *fs, GnomeCmdFile *finfo)
2234
2225
{
2235
gchar *text, *fname;
2236
const gchar *labels[] = {_("Symlink name:")};
2237
GtkWidget *dialog;
2226
gchar *text, *fname;
2227
const gchar *labels[] = {_("Symlink name:")};
2228
GtkWidget *dialog;
2238
2229
2239
fname = get_utf8 (gnome_cmd_file_get_name (finfo));
2240
text = g_strdup_printf (_("Symlink to %s"), fname);
2241
g_free (fname);
2242
dialog = gnome_cmd_string_dialog_new (_("Create Symbolic Link"),
2243
labels,
2244
1,
2245
(GnomeCmdStringDialogCallback)on_create_symlink_ok,
2246
fs);
2247
gnome_cmd_string_dialog_set_value (GNOME_CMD_STRING_DIALOG (dialog), 0, text);
2248
g_free (text);
2249
fs->priv->sym_file = finfo;
2250
gtk_widget_show (dialog);
2230
fname = get_utf8 (gnome_cmd_file_get_name (finfo));
2231
text = g_strdup_printf (_("Symlink to %s"), fname);
2232
g_free (fname);
2233
dialog = gnome_cmd_string_dialog_new (_("Create Symbolic Link"),
2234
labels,
2235
1,
2236
(GnomeCmdStringDialogCallback)on_create_symlink_ok,
2237
fs);
2238
gnome_cmd_string_dialog_set_value (GNOME_CMD_STRING_DIALOG (dialog), 0, text);
2239
g_free (text);
2240
fs->priv->sym_file = finfo;
2241
gtk_widget_show (dialog);
2251
2242
}
2252
2243
2253
2244
2254
2245
void
2255
2246
gnome_cmd_file_selector_update_conbuttons_visibility (GnomeCmdFileSelector *fs)
2256
2247
{
2257
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2248
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2258
2249
2259
if (!gnome_cmd_data_get_conbuttons_visibility ()) {
2260
if (fs->con_btns_hbox) {
2261
gtk_object_destroy (GTK_OBJECT (fs->con_btns_hbox));
2262
fs->con_btns_hbox = NULL;
2263
}
2264
}
2265
else {
2266
if (!fs->con_btns_hbox) {
2267
fs->con_btns_hbox = create_hbox (GTK_WIDGET (fs), FALSE, 2);
2268
gtk_box_pack_start (GTK_BOX (fs), fs->con_btns_hbox, FALSE, FALSE, 0);
2269
gtk_box_reorder_child (GTK_BOX (fs), fs->con_btns_hbox, 0);
2270
gtk_widget_show (fs->con_btns_hbox);
2271
create_con_buttons (fs);
2272
}
2273
}
2250
if (!gnome_cmd_data_get_conbuttons_visibility ()) {
2251
if (fs->con_btns_hbox) {
2252
gtk_object_destroy (GTK_OBJECT (fs->con_btns_hbox));
2253
fs->con_btns_hbox = NULL;
2254
}
2255
}
2256
else {
2257
if (!fs->con_btns_hbox) {
2258
fs->con_btns_hbox = create_hbox (GTK_WIDGET (fs), FALSE, 2);
2259
gtk_box_pack_start (GTK_BOX (fs), fs->con_btns_hbox, FALSE, FALSE, 0);
2260
gtk_box_reorder_child (GTK_BOX (fs), fs->con_btns_hbox, 0);
2261
gtk_widget_show (fs->con_btns_hbox);
2262
create_con_buttons (fs);
2263
}
2264
}
2274
2265
}
2275
2266
2276
2267
2277
2268
static void
2278
2269
on_filter_box_close (GtkButton *btn, GnomeCmdFileSelector *fs)
2279
2270
{
2280
if (!fs->priv->filter_box) return;
2281
2282
gtk_widget_destroy (fs->priv->filter_box);
2283
fs->priv->filter_box = NULL;
2271
if (!fs->priv->filter_box) return;
2272
2273
gtk_widget_destroy (fs->priv->filter_box);
2274
fs->priv->filter_box = NULL;
2284
2275
}
2285
2276
2286
2277
2287
2278
gboolean
2288
2279
on_filter_box_keypressed (GtkEntry *entry, GdkEventKey *event, GnomeCmdFileSelector *fs)
2289
2280
{
2290
if (state_is_blank (event->state)) {
2291
if (event->keyval == GDK_Escape) {
2292
on_filter_box_close (NULL, fs);
2293
return TRUE;
2294
}
2295
}
2281
if (state_is_blank (event->state)) {
2282
if (event->keyval == GDK_Escape) {
2283
on_filter_box_close (NULL, fs);
2284
return TRUE;
2285
}
2286
}
2296
2287
2297
return FALSE;
2288
return FALSE;
2298
2289
}
2299
2290
2300
2291
2301
2292
void
2302
2293
gnome_cmd_file_selector_show_filter (GnomeCmdFileSelector *fs, gchar c)
2303
2294
{
2304
GtkWidget *close_btn, *entry, *label, *parent;
2305
2306
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2307
2308
parent = GTK_WIDGET (fs);
2309
2310
if (fs->priv->filter_box) return;
2311
2312
fs->priv->filter_box = create_hbox (parent, FALSE, 0);
2313
label = create_label (parent, _("Filter:"));
2314
entry = create_entry (parent, "entry", "");
2315
close_btn = create_button_with_data (
2316
GTK_WIDGET (main_win), "x",
2317
GTK_SIGNAL_FUNC (on_filter_box_close), fs);
2318
2319
gtk_signal_connect (GTK_OBJECT (entry), "key-press-event",
2320
GTK_SIGNAL_FUNC (on_filter_box_keypressed), fs);
2321
gtk_box_pack_start (GTK_BOX (fs->priv->filter_box), label, FALSE, TRUE, 0);
2322
gtk_box_pack_start (GTK_BOX (fs->priv->filter_box), entry, TRUE, TRUE, 0);
2323
gtk_box_pack_start (GTK_BOX (fs->priv->filter_box), close_btn, FALSE, TRUE, 0);
2324
2325
gtk_box_pack_start (GTK_BOX (fs), fs->priv->filter_box, FALSE, TRUE, 0);
2326
2327
gtk_widget_grab_focus (entry);
2295
GtkWidget *close_btn, *entry, *label, *parent;
2296
2297
g_return_if_fail (GNOME_CMD_IS_FILE_SELECTOR (fs));
2298
2299
parent = GTK_WIDGET (fs);
2300
2301
if (fs->priv->filter_box) return;
2302
2303
fs->priv->filter_box = create_hbox (parent, FALSE, 0);
2304
label = create_label (parent, _("Filter:"));
2305
entry = create_entry (parent, "entry", "");
2306
close_btn = create_button_with_data (
2307
GTK_WIDGET (main_win), "x",
2308
GTK_SIGNAL_FUNC (on_filter_box_close), fs);
2309
2310
gtk_signal_connect (GTK_OBJECT (entry), "key-press-event",
2311
GTK_SIGNAL_FUNC (on_filter_box_keypressed), fs);
2312
gtk_box_pack_start (GTK_BOX (fs->priv->filter_box), label, FALSE, TRUE, 0);
2313
gtk_box_pack_start (GTK_BOX (fs->priv->filter_box), entry, TRUE, TRUE, 0);
2314
gtk_box_pack_start (GTK_BOX (fs->priv->filter_box), close_btn, FALSE, TRUE, 0);
2315
2316
gtk_box_pack_start (GTK_BOX (fs), fs->priv->filter_box, FALSE, TRUE, 0);
2317
2318
gtk_widget_grab_focus (entry);
2328
2319
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1