2
* Remmina - The GTK+ Remote Desktop Client
3
* Copyright (C) 2009-2011 Vic Lee
5
* This program is free software; you can redistribute it and/or modify
6
* it under the terms of the GNU General Public License as published by
7
* the Free Software Foundation; either version 2 of the License, or
8
* (at your option) any later version.
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 59 Temple Place, Suite 330,
18
* Boston, MA 02111-1307, USA.
21
#define _FILE_OFFSET_BITS 64
24
#include <glib/gi18n.h>
25
#include <glib/gstdio.h>
26
#include "remmina_public.h"
27
#include "remmina_pref.h"
28
#include "remmina_marshals.h"
29
#include "remmina_file.h"
30
#include "remmina_ftp_client.h"
32
/* -------------------- RemminaCellRendererPixbuf ----------------------- */
33
/* A tiny cell renderer that extends the default pixbuf cell render to accept activation */
35
#define REMMINA_TYPE_CELL_RENDERER_PIXBUF \
36
(remmina_cell_renderer_pixbuf_get_type ())
37
#define REMMINA_CELL_RENDERER_PIXBUF(obj) \
38
(G_TYPE_CHECK_INSTANCE_CAST ((obj), REMMINA_TYPE_CELL_RENDERER_PIXBUF, RemminaCellRendererPixbuf))
39
#define REMMINA_CELL_RENDERER_PIXBUF_CLASS(klass) \
40
(G_TYPE_CHECK_CLASS_CAST ((klass), REMMINA_TYPE_CELL_RENDERER_PIXBUF, RemminaCellRendererPixbufClass))
41
#define REMMINA_IS_CELL_RENDERER_PIXBUF(obj) \
42
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), REMMINA_TYPE_CELL_RENDERER_PIXBUF))
44
typedef struct _RemminaCellRendererPixbuf
46
GtkCellRendererPixbuf renderer;
47
} RemminaCellRendererPixbuf;
49
typedef struct _RemminaCellRendererPixbufClass
51
GtkCellRendererPixbufClass parent_class;
53
void (*activate)(RemminaCellRendererPixbuf *renderer);
54
} RemminaCellRendererPixbufClass;
56
GType remmina_cell_renderer_pixbuf_get_type(void)
59
G_DEFINE_TYPE(RemminaCellRendererPixbuf, remmina_cell_renderer_pixbuf, GTK_TYPE_CELL_RENDERER_PIXBUF)
61
static guint remmina_cell_renderer_pixbuf_signals[1] =
65
static gboolean remmina_cell_renderer_pixbuf_activate(GtkCellRenderer *renderer, GdkEvent *event, GtkWidget *widget,
66
const gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area,
67
GtkCellRendererState flags)
68
#elif GTK_VERSION == 3
69
static gboolean remmina_cell_renderer_pixbuf_activate(GtkCellRenderer *renderer, GdkEvent *event, GtkWidget *widget,
70
const gchar *path, const GdkRectangle *background_area, const GdkRectangle *cell_area,
71
GtkCellRendererState flags)
74
g_signal_emit(G_OBJECT(renderer), remmina_cell_renderer_pixbuf_signals[0], 0, path);
78
static void remmina_cell_renderer_pixbuf_class_init(RemminaCellRendererPixbufClass *klass)
80
GtkCellRendererClass *renderer_class = GTK_CELL_RENDERER_CLASS(klass);
82
renderer_class->activate = remmina_cell_renderer_pixbuf_activate;
84
remmina_cell_renderer_pixbuf_signals[0] = g_signal_new("activate", G_TYPE_FROM_CLASS(klass),
85
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaCellRendererPixbufClass, activate), NULL,
86
NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
89
static void remmina_cell_renderer_pixbuf_init(RemminaCellRendererPixbuf *renderer)
91
g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
94
static GtkCellRenderer*
95
remmina_cell_renderer_pixbuf_new(void)
97
GtkCellRenderer *renderer;
99
renderer = GTK_CELL_RENDERER(g_object_new(REMMINA_TYPE_CELL_RENDERER_PIXBUF, NULL));
103
/* --------------------- RemminaFTPClient ----------------------------*/
104
G_DEFINE_TYPE( RemminaFTPClient, remmina_ftp_client, GTK_TYPE_VBOX)
106
#define BUSY_CURSOR \
107
if (GDK_IS_WINDOW (gtk_widget_get_window (GTK_WIDGET (client)))) \
109
gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (client)), gdk_cursor_new (GDK_WATCH));\
113
#define NORMAL_CURSOR \
114
if (GDK_IS_WINDOW (gtk_widget_get_window (GTK_WIDGET (client)))) \
116
gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (client)), NULL); \
119
struct _RemminaFTPClientPriv
121
GtkWidget *directory_combo;
124
GtkTreeModel *file_list_model;
125
GtkTreeModel *file_list_filter;
126
GtkTreeModel *file_list_sort;
127
GtkWidget *file_list_view;
128
gboolean file_list_show_hidden;
130
GtkTreeModel *task_list_model;
131
GtkWidget *task_list_view;
133
gchar *current_directory;
134
gchar *working_directory;
136
GtkWidget *file_action_widgets[10];
140
static gint remmina_ftp_client_taskid = 1;
144
OPEN_DIR_SIGNAL, NEW_TASK_SIGNAL, CANCEL_TASK_SIGNAL, DELETE_FILE_SIGNAL, LAST_SIGNAL
147
static guint remmina_ftp_client_signals[LAST_SIGNAL] =
150
static void remmina_ftp_client_class_init(RemminaFTPClientClass *klass)
152
remmina_ftp_client_signals[OPEN_DIR_SIGNAL] = g_signal_new("open-dir", G_TYPE_FROM_CLASS(klass),
153
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, open_dir), NULL, NULL,
154
g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
155
remmina_ftp_client_signals[NEW_TASK_SIGNAL] = g_signal_new("new-task", G_TYPE_FROM_CLASS(klass),
156
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, new_task), NULL, NULL,
157
g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
158
remmina_ftp_client_signals[CANCEL_TASK_SIGNAL] = g_signal_new("cancel-task", G_TYPE_FROM_CLASS(klass),
159
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, cancel_task), NULL, NULL,
160
remmina_marshal_BOOLEAN__INT, G_TYPE_BOOLEAN, 1, G_TYPE_INT);
161
remmina_ftp_client_signals[DELETE_FILE_SIGNAL] = g_signal_new("delete-file", G_TYPE_FROM_CLASS(klass),
162
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaFTPClientClass, delete_file), NULL, NULL,
163
remmina_marshal_BOOLEAN__INT_STRING, G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_STRING);
166
static void remmina_ftp_client_destroy(RemminaFTPClient *client, gpointer data)
168
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
169
g_free(priv->current_directory);
170
g_free(priv->working_directory);
174
static void remmina_ftp_client_cell_data_filetype_pixbuf(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
175
GtkTreeIter *iter, gpointer user_data)
179
/* Same as REMMINA_FTP_TASK_COLUMN_TYPE */
180
gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_TYPE, &type, -1);
184
case REMMINA_FTP_FILE_TYPE_DIR:
185
g_object_set(renderer, "stock-id", GTK_STOCK_DIRECTORY, NULL);
188
g_object_set(renderer, "stock-id", GTK_STOCK_FILE, NULL);
193
static void remmina_ftp_client_cell_data_progress_pixbuf(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
194
GtkTreeIter *iter, gpointer user_data)
196
gint tasktype, status;
198
gtk_tree_model_get(model, iter, REMMINA_FTP_TASK_COLUMN_TASKTYPE, &tasktype, REMMINA_FTP_TASK_COLUMN_STATUS, &status,
203
case REMMINA_FTP_TASK_STATUS_WAIT:
204
g_object_set(renderer, "stock-id", GTK_STOCK_MEDIA_PAUSE, NULL);
206
case REMMINA_FTP_TASK_STATUS_RUN:
207
g_object_set(renderer, "stock-id",
208
(tasktype == REMMINA_FTP_TASK_TYPE_UPLOAD ? GTK_STOCK_GO_UP : GTK_STOCK_GO_DOWN), NULL);
210
case REMMINA_FTP_TASK_STATUS_FINISH:
211
g_object_set(renderer, "stock-id", GTK_STOCK_YES, NULL);
213
case REMMINA_FTP_TASK_STATUS_ERROR:
214
g_object_set(renderer, "stock-id", GTK_STOCK_NO, NULL);
220
remmina_ftp_client_size_to_str(gfloat size)
226
str = g_strdup_printf("%i", (gint) size);
229
if (size < 1024.0 * 1024.0)
231
str = g_strdup_printf("%iK", (gint)(size / 1024.0));
234
if (size < 1024.0 * 1024.0 * 1024.0)
236
str = g_strdup_printf("%.1fM", size / 1024.0 / 1024.0);
240
str = g_strdup_printf("%.1fG", size / 1024.0 / 1024.0 / 1024.0);
245
static void remmina_ftp_client_cell_data_size(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
246
GtkTreeIter *iter, gpointer user_data)
251
gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_SIZE, &size, -1);
253
str = remmina_ftp_client_size_to_str(size);
254
g_object_set(renderer, "text", str, NULL);
255
g_object_set(renderer, "xalign", 1.0, NULL);
259
static void remmina_ftp_client_cell_data_permission(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
260
GtkTreeIter *iter, gpointer user_data)
265
gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_PERMISSION, &permission, -1);
267
buf[0] = (permission & 040000 ? 'd' : '-');
268
buf[1] = (permission & 0400 ? 'r' : '-');
269
buf[2] = (permission & 0200 ? 'w' : '-');
270
buf[3] = (permission & 0100 ? 'x' : '-');
271
buf[4] = (permission & 040 ? 'r' : '-');
272
buf[5] = (permission & 020 ? 'w' : '-');
273
buf[6] = (permission & 010 ? 'x' : '-');
274
buf[7] = (permission & 04 ? 'r' : '-');
275
buf[8] = (permission & 02 ? 'w' : '-');
276
buf[9] = (permission & 01 ? 'x' : '-');
279
g_object_set(renderer, "text", buf, NULL);
282
static void remmina_ftp_client_cell_data_size_progress(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
283
GtkTreeIter *iter, gpointer user_data)
286
gfloat size, donesize;
287
gchar *strsize, *strdonesize, *str;
289
gtk_tree_model_get(model, iter, REMMINA_FTP_TASK_COLUMN_STATUS, &status, REMMINA_FTP_TASK_COLUMN_SIZE, &size,
290
REMMINA_FTP_TASK_COLUMN_DONESIZE, &donesize, -1);
292
if (status == REMMINA_FTP_TASK_STATUS_FINISH)
294
str = remmina_ftp_client_size_to_str(size);
298
strsize = remmina_ftp_client_size_to_str(size);
299
strdonesize = remmina_ftp_client_size_to_str(donesize);
300
str = g_strdup_printf("%s / %s", strdonesize, strsize);
305
g_object_set(renderer, "text", str, NULL);
306
g_object_set(renderer, "xalign", 1.0, NULL);
310
static void remmina_ftp_client_cell_data_progress(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
311
GtkTreeIter *iter, gpointer user_data)
314
gfloat size, donesize;
317
gtk_tree_model_get(model, iter, REMMINA_FTP_TASK_COLUMN_STATUS, &status, REMMINA_FTP_TASK_COLUMN_SIZE, &size,
318
REMMINA_FTP_TASK_COLUMN_DONESIZE, &donesize, -1);
319
if (status == REMMINA_FTP_TASK_STATUS_FINISH)
331
progress = (gint)(donesize / size * 100);
336
g_object_set(renderer, "value", progress, NULL);
339
static void remmina_ftp_client_open_dir(RemminaFTPClient *client, const gchar *dir)
342
g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[OPEN_DIR_SIGNAL], 0, dir);
346
static void remmina_ftp_client_dir_on_activate(GtkWidget *widget, RemminaFTPClient *client)
348
remmina_ftp_client_open_dir(client, gtk_entry_get_text(GTK_ENTRY(widget)));
351
static void remmina_ftp_client_dir_on_changed(GtkWidget *widget, RemminaFTPClient *client)
353
GtkWidget *entry = gtk_bin_get_child(GTK_BIN(widget));
355
if (!gtk_widget_is_focus(entry))
357
gtk_widget_grab_focus(entry);
358
/* If the text was changed but the entry is not the focus, it should be changed by the drop-down list.
359
Not sure this will always work in the future, but it works right now :) */
360
remmina_ftp_client_open_dir(client, gtk_entry_get_text(GTK_ENTRY(entry)));
364
static void remmina_ftp_client_set_file_action_sensitive(RemminaFTPClient *client, gboolean sensitive)
367
for (i = 0; client->priv->file_action_widgets[i]; i++)
369
gtk_widget_set_sensitive(client->priv->file_action_widgets[i], sensitive);
371
client->priv->sensitive = sensitive;
374
static void remmina_ftp_client_file_selection_on_changed(GtkTreeSelection *selection, RemminaFTPClient *client)
378
list = gtk_tree_selection_get_selected_rows(selection, NULL);
379
remmina_ftp_client_set_file_action_sensitive(client, (list ? TRUE : FALSE));
384
remmina_ftp_client_get_download_dir(RemminaFTPClient *client)
386
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
388
gchar *localdir = NULL;
390
dialog = gtk_file_chooser_dialog_new(_("Choose download location"),
391
GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
392
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
393
if (priv->working_directory)
395
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), priv->working_directory);
397
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
399
g_free(priv->working_directory);
400
priv->working_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
401
localdir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
403
gtk_widget_destroy(dialog);
407
static void remmina_ftp_client_download(RemminaFTPClient *client, GtkTreeIter *piter, const gchar *localdir)
409
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
410
GtkListStore *store = GTK_LIST_STORE(priv->task_list_model);
416
gtk_tree_model_get(priv->file_list_sort, piter, REMMINA_FTP_FILE_COLUMN_TYPE, &type, REMMINA_FTP_FILE_COLUMN_NAME,
417
&name, REMMINA_FTP_FILE_COLUMN_SIZE, &size, -1);
419
gtk_list_store_append(store, &iter);
420
gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, type, REMMINA_FTP_TASK_COLUMN_NAME, name,
421
REMMINA_FTP_TASK_COLUMN_SIZE, size, REMMINA_FTP_TASK_COLUMN_TASKID, remmina_ftp_client_taskid++,
422
REMMINA_FTP_TASK_COLUMN_TASKTYPE, REMMINA_FTP_TASK_TYPE_DOWNLOAD, REMMINA_FTP_TASK_COLUMN_REMOTEDIR,
423
priv->current_directory, REMMINA_FTP_TASK_COLUMN_LOCALDIR, localdir, REMMINA_FTP_TASK_COLUMN_STATUS,
424
REMMINA_FTP_TASK_STATUS_WAIT, REMMINA_FTP_TASK_COLUMN_DONESIZE, 0.0, REMMINA_FTP_TASK_COLUMN_TOOLTIP,
429
g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[NEW_TASK_SIGNAL], 0);
432
static gboolean remmina_ftp_client_task_list_on_query_tooltip(GtkWidget *widget, gint x, gint y, gboolean keyboard_tip,
433
GtkTooltip *tooltip, RemminaFTPClient *client)
435
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
437
GtkTreePath *path = NULL;
440
if (!gtk_tree_view_get_tooltip_context(GTK_TREE_VIEW(priv->task_list_view), &x, &y, keyboard_tip, NULL, &path, &iter))
445
gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TOOLTIP, &tmp, -1);
449
gtk_tooltip_set_text(tooltip, tmp);
451
gtk_tree_view_set_tooltip_row(GTK_TREE_VIEW(priv->task_list_view), tooltip, path);
453
gtk_tree_path_free(path);
459
static void remmina_ftp_client_action_parent(GObject *object, RemminaFTPClient *client)
461
remmina_ftp_client_open_dir(client, "..");
464
static void remmina_ftp_client_action_home(GObject *object, RemminaFTPClient *client)
466
remmina_ftp_client_open_dir(client, NULL);
469
static void remmina_ftp_client_action_refresh(GObject *object, RemminaFTPClient *client)
471
remmina_ftp_client_open_dir(client, ".");
474
static void remmina_ftp_client_action_download(GObject *object, RemminaFTPClient *client)
476
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
477
GtkTreeSelection *selection;
479
GList *list, *list_iter;
482
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view));
485
list = gtk_tree_selection_get_selected_rows(selection, NULL);
489
localdir = remmina_ftp_client_get_download_dir(client);
496
list_iter = g_list_first(list);
499
gtk_tree_model_get_iter(priv->file_list_sort, &iter, (GtkTreePath*) list_iter->data);
500
remmina_ftp_client_download(client, &iter, localdir);
501
list_iter = g_list_next(list_iter);
507
static void remmina_ftp_client_action_delete(GObject *object, RemminaFTPClient *client)
509
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
511
GtkTreeSelection *selection;
512
GList *list, *list_iter;
520
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view));
523
list = gtk_tree_selection_get_selected_rows(selection, NULL);
527
dialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_DIALOG_MODAL,
528
GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("Are you sure to delete the selected files on server?"));
529
response = gtk_dialog_run(GTK_DIALOG(dialog));
530
gtk_widget_destroy(dialog);
531
if (response != GTK_RESPONSE_YES)
536
list_iter = g_list_first(list);
539
gtk_tree_model_get_iter(priv->file_list_sort, &iter, (GtkTreePath*) list_iter->data);
541
gtk_tree_model_get(priv->file_list_sort, &iter, REMMINA_FTP_FILE_COLUMN_TYPE, &type,
542
REMMINA_FTP_FILE_COLUMN_NAME, &name, -1);
544
path = remmina_public_combine_path(priv->current_directory, name);
545
g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[DELETE_FILE_SIGNAL], 0, type, path, &ret);
551
list_iter = g_list_next(list_iter);
559
remmina_ftp_client_action_refresh(object, client);
563
static void remmina_ftp_client_upload_folder_on_toggled(GtkToggleButton *togglebutton, GtkWidget *widget)
565
gtk_file_chooser_set_action(
566
GTK_FILE_CHOOSER(widget),
567
gtk_toggle_button_get_active(togglebutton) ?
568
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER : GTK_FILE_CHOOSER_ACTION_OPEN);
571
static void remmina_ftp_client_action_upload(GObject *object, RemminaFTPClient *client)
573
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
574
GtkListStore *store = GTK_LIST_STORE(priv->task_list_model);
577
GtkWidget *upload_folder_check;
579
GSList *files = NULL;
585
dialog = gtk_file_chooser_dialog_new(_("Choose a file to upload"),
586
GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,
587
GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
588
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
589
if (priv->working_directory)
591
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), priv->working_directory);
593
upload_folder_check = gtk_check_button_new_with_label(_("Upload folder"));
594
gtk_widget_show(upload_folder_check);
595
g_signal_connect(G_OBJECT(upload_folder_check), "toggled", G_CALLBACK(remmina_ftp_client_upload_folder_on_toggled),
597
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), upload_folder_check);
598
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
600
g_free(priv->working_directory);
601
priv->working_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
602
files = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
604
type = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(upload_folder_check)) ?
605
REMMINA_FTP_FILE_TYPE_DIR : REMMINA_FTP_FILE_TYPE_FILE;
606
gtk_widget_destroy(dialog);
610
for (element = files; element; element = element->next)
612
path = (gchar*) element->data;
614
if (g_stat(path, &st) < 0)
617
name = g_strrstr(path, "/");
629
gtk_list_store_append(store, &iter);
630
gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, type, REMMINA_FTP_TASK_COLUMN_NAME, name,
631
REMMINA_FTP_TASK_COLUMN_SIZE, (gfloat) st.st_size, REMMINA_FTP_TASK_COLUMN_TASKID,
632
remmina_ftp_client_taskid++, REMMINA_FTP_TASK_COLUMN_TASKTYPE, REMMINA_FTP_TASK_TYPE_UPLOAD,
633
REMMINA_FTP_TASK_COLUMN_REMOTEDIR, priv->current_directory, REMMINA_FTP_TASK_COLUMN_LOCALDIR,
634
dir, REMMINA_FTP_TASK_COLUMN_STATUS, REMMINA_FTP_TASK_STATUS_WAIT,
635
REMMINA_FTP_TASK_COLUMN_DONESIZE, 0.0, REMMINA_FTP_TASK_COLUMN_TOOLTIP, NULL, -1);
642
g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[NEW_TASK_SIGNAL], 0);
645
static void remmina_ftp_client_popup_menu(RemminaFTPClient *client, GdkEventButton *event)
651
menu = gtk_menu_new();
653
menuitem = gtk_image_menu_item_new_with_label(_("Download"));
654
gtk_widget_show(menuitem);
655
image = gtk_image_new_from_icon_name("document-save", GTK_ICON_SIZE_MENU);
656
gtk_widget_show(image);
657
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
658
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
659
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_download), client);
661
menuitem = gtk_image_menu_item_new_with_label(_("Upload"));
662
gtk_widget_show(menuitem);
663
image = gtk_image_new_from_icon_name("document-send", GTK_ICON_SIZE_MENU);
664
gtk_widget_show(image);
665
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
666
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
667
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_upload), client);
669
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
670
gtk_widget_show(menuitem);
671
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
672
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(remmina_ftp_client_action_delete), client);
674
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, event->time);
677
static gboolean remmina_ftp_client_file_list_on_button_press(GtkWidget *widget, GdkEventButton *event, RemminaFTPClient *client)
679
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
686
if (event->button == 3)
688
remmina_ftp_client_popup_menu(client, event);
691
if (event->button == 1 && event->type == GDK_2BUTTON_PRESS)
693
list = gtk_tree_selection_get_selected_rows(
694
gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view)), NULL);
697
gtk_tree_model_get_iter(priv->file_list_sort, &iter, (GtkTreePath*) list->data);
698
gtk_tree_model_get(priv->file_list_sort, &iter, REMMINA_FTP_FILE_COLUMN_TYPE, &type,
699
REMMINA_FTP_FILE_COLUMN_NAME, &name, -1);
702
case REMMINA_FTP_FILE_TYPE_DIR:
703
remmina_ftp_client_open_dir(client, name);
705
case REMMINA_FTP_FILE_TYPE_FILE:
707
localdir = remmina_ftp_client_get_download_dir(client);
710
remmina_ftp_client_download(client, &iter, localdir);
723
static void remmina_ftp_client_task_list_cell_on_activate(GtkCellRenderer *renderer, gchar *path, RemminaFTPClient *client)
725
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
727
GtkTreePath *treepath;
729
gboolean ret = FALSE;
731
treepath = gtk_tree_path_new_from_string(path);
732
gtk_tree_model_get_iter(priv->task_list_model, &iter, treepath);
733
gtk_tree_path_free(treepath);
735
gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TASKID, &taskid, -1);
737
g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[CANCEL_TASK_SIGNAL], 0, taskid, &ret);
741
gtk_list_store_remove(GTK_LIST_STORE(priv->task_list_model), &iter);
745
static void remmina_ftp_client_create_toolbar(RemminaFTPClient *client)
752
box = gtk_hbutton_box_new();
753
gtk_widget_show(box);
754
gtk_button_box_set_layout(GTK_BUTTON_BOX(box), GTK_BUTTONBOX_START);
755
gtk_box_pack_start(GTK_BOX(client), box, FALSE, TRUE, 0);
757
button = gtk_button_new_from_stock(GTK_STOCK_HOME);
758
gtk_widget_show(button);
759
gtk_widget_set_tooltip_text(button, _("Go to home folder"));
760
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
761
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
762
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_home), client);
764
button = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
765
gtk_widget_show(button);
766
gtk_widget_set_tooltip_text(button, _("Go to parent folder"));
767
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
768
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
769
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_parent), client);
771
button = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
772
gtk_widget_show(button);
773
gtk_widget_set_tooltip_text(button, _("Refresh current folder"));
774
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
775
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
776
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_refresh), client);
778
button = gtk_button_new_with_label(_("Download"));
779
gtk_widget_show(button);
780
gtk_widget_set_tooltip_text(button, _("Download from server"));
781
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
782
image = gtk_image_new_from_icon_name("document-save", GTK_ICON_SIZE_BUTTON);
783
gtk_button_set_image(GTK_BUTTON(button), image);
784
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
785
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_download), client);
787
client->priv->file_action_widgets[i++] = button;
789
button = gtk_button_new_with_label(_("Upload"));
790
gtk_widget_show(button);
791
gtk_widget_set_tooltip_text(button, _("Upload to server"));
792
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
793
image = gtk_image_new_from_icon_name("document-send", GTK_ICON_SIZE_BUTTON);
794
gtk_button_set_image(GTK_BUTTON(button), image);
795
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
796
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_upload), client);
798
button = gtk_button_new_from_stock(GTK_STOCK_DELETE);
799
gtk_widget_show(button);
800
gtk_widget_set_tooltip_text(button, _("Delete files on server"));
801
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
802
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
803
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remmina_ftp_client_action_delete), client);
805
client->priv->file_action_widgets[i++] = button;
808
void remmina_ftp_client_set_show_hidden(RemminaFTPClient *client, gboolean show_hidden)
810
client->priv->file_list_show_hidden = show_hidden;
811
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(client->priv->file_list_filter));
814
static gboolean remmina_ftp_client_filter_visible_func(GtkTreeModel *model, GtkTreeIter *iter, RemminaFTPClient *client)
817
gboolean result = TRUE;
819
if (client->priv->file_list_show_hidden)
822
gtk_tree_model_get(model, iter, REMMINA_FTP_FILE_COLUMN_NAME, &name, -1);
823
if (name && name[0] == '.')
831
static void remmina_ftp_client_init(RemminaFTPClient *client)
833
RemminaFTPClientPriv *priv;
835
GtkWidget *scrolledwindow;
837
GtkCellRenderer *renderer;
838
GtkTreeViewColumn *column;
841
priv = g_new0(RemminaFTPClientPriv, 1);
845
gtk_box_set_homogeneous(GTK_BOX(client), FALSE);
846
gtk_box_set_spacing(GTK_BOX(client), 4);
849
remmina_ftp_client_create_toolbar(client);
851
/* The Paned to separate File List and Task List */
852
vpaned = gtk_vpaned_new();
853
gtk_widget_show(vpaned);
854
gtk_box_pack_start(GTK_BOX(client), vpaned, TRUE, TRUE, 0);
856
priv->vpaned = vpaned;
859
vbox = gtk_vbox_new(FALSE, 0);
860
gtk_widget_show(vbox);
861
gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE);
863
/* Remote Directory */
864
widget = gtk_combo_box_text_new_with_entry();
865
gtk_widget_show(widget);
866
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/");
867
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
869
priv->directory_combo = widget;
871
/* Remote File List */
872
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
873
gtk_widget_show(scrolledwindow);
874
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
875
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
877
widget = gtk_tree_view_new();
878
gtk_widget_show(widget);
879
gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
881
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE);
883
priv->file_list_view = widget;
885
/* Remote File List - Columns */
886
column = gtk_tree_view_column_new();
887
gtk_tree_view_column_set_title(column, _("File Name"));
888
gtk_tree_view_column_set_expand(column, TRUE);
889
gtk_tree_view_column_set_resizable(column, TRUE);
890
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT);
891
renderer = gtk_cell_renderer_pixbuf_new();
892
gtk_tree_view_column_pack_start(column, renderer, FALSE);
893
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
894
renderer = gtk_cell_renderer_text_new();
895
gtk_tree_view_column_pack_start(column, renderer, FALSE);
896
gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
897
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
899
renderer = gtk_cell_renderer_text_new();
900
column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
901
gtk_tree_view_column_set_alignment(column, 1.0);
902
gtk_tree_view_column_set_resizable(column, TRUE);
903
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL);
904
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE);
905
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
907
renderer = gtk_cell_renderer_text_new();
908
column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL);
909
gtk_tree_view_column_set_resizable(column, TRUE);
910
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER);
911
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
913
renderer = gtk_cell_renderer_text_new();
914
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL);
915
gtk_tree_view_column_set_resizable(column, TRUE);
916
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP);
917
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
919
renderer = gtk_cell_renderer_text_new();
920
column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION,
922
gtk_tree_view_column_set_resizable(column, TRUE);
923
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL);
924
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION);
925
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
927
/* Remote File List - Model */
928
priv->file_list_model = GTK_TREE_MODEL(
929
gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING,
930
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING));
932
priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL);
933
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter),
934
(GtkTreeModelFilterVisibleFunc) remmina_ftp_client_filter_visible_func, client, NULL);
936
priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter);
937
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT,
939
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort);
942
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
943
gtk_widget_show(scrolledwindow);
944
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
945
gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE);
947
widget = gtk_tree_view_new();
948
gtk_widget_show(widget);
949
gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
950
g_object_set(widget, "has-tooltip", TRUE, NULL);
952
priv->task_list_view = widget;
954
/* Task List - Columns */
955
column = gtk_tree_view_column_new();
956
gtk_tree_view_column_set_title(column, _("File Name"));
957
gtk_tree_view_column_set_resizable(column, TRUE);
958
gtk_tree_view_column_set_expand(column, TRUE);
959
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME);
960
renderer = gtk_cell_renderer_pixbuf_new();
961
gtk_tree_view_column_pack_start(column, renderer, FALSE);
962
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL);
963
renderer = gtk_cell_renderer_pixbuf_new();
964
gtk_tree_view_column_pack_start(column, renderer, FALSE);
965
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
966
renderer = gtk_cell_renderer_text_new();
967
gtk_tree_view_column_pack_start(column, renderer, FALSE);
968
gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
969
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
971
renderer = gtk_cell_renderer_text_new();
972
column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR,
974
gtk_tree_view_column_set_resizable(column, TRUE);
975
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR);
976
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
978
renderer = gtk_cell_renderer_text_new();
979
column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL);
980
gtk_tree_view_column_set_resizable(column, TRUE);
981
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR);
982
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
984
renderer = gtk_cell_renderer_text_new();
985
column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
986
gtk_tree_view_column_set_alignment(column, 1.0);
987
gtk_tree_view_column_set_resizable(column, TRUE);
988
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL);
989
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE);
990
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
992
renderer = gtk_cell_renderer_progress_new();
993
column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL);
994
gtk_tree_view_column_set_resizable(column, TRUE);
995
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL);
996
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
998
renderer = remmina_cell_renderer_pixbuf_new();
999
column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL);
1000
g_object_set(G_OBJECT(renderer), "stock-id", GTK_STOCK_CANCEL, NULL);
1001
gtk_tree_view_column_set_resizable(column, FALSE);
1002
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
1004
g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client);
1006
/* Task List - Model */
1007
priv->task_list_model = GTK_TREE_MODEL(
1008
gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT,
1009
G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING));
1010
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model);
1012
/* Setup the internal signals */
1013
g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL);
1014
g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate",
1015
G_CALLBACK(remmina_ftp_client_dir_on_activate), client);
1016
g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client);
1017
g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event",
1018
G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client);
1019
g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed",
1020
G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client);
1021
g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip",
1022
G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client);
1026
remmina_ftp_client_new(void)
1028
RemminaFTPClient *client;
1030
client = REMMINA_FTP_CLIENT(g_object_new(REMMINA_TYPE_FTP_CLIENT, NULL));
1032
return GTK_WIDGET(client);
1035
void remmina_ftp_client_save_state(RemminaFTPClient *client, RemminaFile *remminafile)
1039
pos = gtk_paned_get_position(GTK_PANED(client->priv->vpaned));
1040
remmina_file_set_int(remminafile, "ftp_vpanedpos", pos);
1043
void remmina_ftp_client_load_state(RemminaFTPClient *client, RemminaFile *remminafile)
1048
pos = remmina_file_get_int(remminafile, "ftp_vpanedpos", 0);
1051
gtk_widget_get_allocation(client->priv->vpaned, &a);
1052
if (a.height > 0 && pos > a.height - 60)
1054
pos = a.height - 60;
1056
gtk_paned_set_position(GTK_PANED(client->priv->vpaned), pos);
1060
void remmina_ftp_client_clear_file_list(RemminaFTPClient *client)
1062
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
1064
gtk_list_store_clear(GTK_LIST_STORE(priv->file_list_model));
1065
remmina_ftp_client_set_file_action_sensitive(client, FALSE);
1068
void remmina_ftp_client_add_file(RemminaFTPClient *client, ...)
1070
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
1071
GtkListStore *store = GTK_LIST_STORE (priv->file_list_model);
1078
va_start (args, client);
1079
gtk_list_store_append (store, &iter);
1080
gtk_list_store_set_valist (store, &iter, args);
1083
gtk_tree_model_get (GTK_TREE_MODEL(store), &iter,
1084
REMMINA_FTP_FILE_COLUMN_TYPE, &type,
1085
REMMINA_FTP_FILE_COLUMN_NAME, &name,
1088
ptr = g_strdup_printf("%i%s", type, name);
1089
gtk_list_store_set (store, &iter, REMMINA_FTP_FILE_COLUMN_NAME_SORT, ptr, -1);
1094
void remmina_ftp_client_set_dir(RemminaFTPClient *client, const gchar *dir)
1096
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
1097
GtkTreeModel *model;
1102
if (priv->current_directory && g_strcmp0(priv->current_directory, dir) == 0)
1105
model = gtk_combo_box_get_model(GTK_COMBO_BOX(priv->directory_combo));
1106
for (ret = gtk_tree_model_get_iter_first(model, &iter); ret; ret = gtk_tree_model_iter_next(model, &iter))
1108
gtk_tree_model_get(model, &iter, 0, &t, -1);
1109
if (g_strcmp0(t, dir) == 0)
1111
gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
1118
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(priv->directory_combo), dir);
1119
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->directory_combo), 0);
1121
g_free(priv->current_directory);
1122
priv->current_directory = g_strdup(dir);
1126
remmina_ftp_client_get_dir(RemminaFTPClient *client)
1128
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
1130
return g_strdup(priv->current_directory);
1134
remmina_ftp_client_get_waiting_task(RemminaFTPClient *client)
1136
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
1139
RemminaFTPTask task;
1141
if (!gtk_tree_model_get_iter_first(priv->task_list_model, &iter))
1146
gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, &task.type,
1147
REMMINA_FTP_TASK_COLUMN_NAME, &task.name, REMMINA_FTP_TASK_COLUMN_SIZE, &task.size,
1148
REMMINA_FTP_TASK_COLUMN_TASKID, &task.taskid, REMMINA_FTP_TASK_COLUMN_TASKTYPE, &task.tasktype,
1149
REMMINA_FTP_TASK_COLUMN_REMOTEDIR, &task.remotedir, REMMINA_FTP_TASK_COLUMN_LOCALDIR,
1150
&task.localdir, REMMINA_FTP_TASK_COLUMN_STATUS, &task.status, REMMINA_FTP_TASK_COLUMN_DONESIZE,
1151
&task.donesize, REMMINA_FTP_TASK_COLUMN_TOOLTIP, &task.tooltip, -1);
1152
if (task.status == REMMINA_FTP_TASK_STATUS_WAIT)
1154
path = gtk_tree_model_get_path(priv->task_list_model, &iter);
1155
task.rowref = gtk_tree_row_reference_new(priv->task_list_model, path);
1156
gtk_tree_path_free(path);
1157
return (RemminaFTPTask*) g_memdup(&task, sizeof(RemminaFTPTask));
1159
if (!gtk_tree_model_iter_next(priv->task_list_model, &iter))
1166
void remmina_ftp_client_update_task(RemminaFTPClient *client, RemminaFTPTask* task)
1168
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
1169
GtkListStore *store = GTK_LIST_STORE(priv->task_list_model);
1173
path = gtk_tree_row_reference_get_path(task->rowref);
1176
gtk_tree_model_get_iter(priv->task_list_model, &iter, path);
1177
gtk_tree_path_free(path);
1178
gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_SIZE, task->size, REMMINA_FTP_TASK_COLUMN_STATUS, task->status,
1179
REMMINA_FTP_TASK_COLUMN_DONESIZE, task->donesize, REMMINA_FTP_TASK_COLUMN_TOOLTIP, task->tooltip, -1);
1182
void remmina_ftp_task_free(RemminaFTPTask *task)
1187
g_free(task->remotedir);
1188
g_free(task->localdir);
1189
g_free(task->tooltip);