nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
medit/moo/moofileview/moofileview.c

6247 lines
198 KiB
C
Raw Blame History

/*
* moofileview.c
*
* Copyright (C) 2004-2010 by Yevgen Muntyan <emuntyan@users.sourceforge.net>
*
* This file is part of medit. medit is free software; you can
* redistribute it and/or modify it under the terms of the
* GNU Lesser General Public License as published by the
* Free Software Foundation; either version 2.1 of the License,
* or (at your option) any later version.
*
* You should have received a copy of the GNU Lesser General Public
* License along with medit. If not, see <http://www.gnu.org/licenses/>.
*/
#include "moofileview/moofileview-accels.h"
#include "moofileview/moofileview-dialogs.h"
#include "moofileview/moobookmarkmgr.h"
#include "moofileview/moofilesystem.h"
#include "moofileview/moofile-private.h"
#include "moofileview/moofoldermodel.h"
#include "moofileview/moofileentry.h"
#include "moofileview/mooiconview.h"
#include "moofileview/moofileview-aux.h"
#include "moofileview/moofileview-private.h"
#include "moofileview/moofileview-ui.h"
#include "moofileview/mootreeview.h"
#include "moofileview/moobookmarkview.h"
#include "moofileview/moofileview-tools.h"
#include "mooutils/mooutils-gobject.h"
#include "mooutils/mooutils-fs.h"
#include "mooutils/mooutils-misc.h"
#include "mooutils/mooutils-debug.h"
#include "mooutils/moodialogs.h"
#include "mooutils/moofiltermgr.h"
#include "mooutils/moouixml.h"
#include "mooutils/moospawn.h"
#include "mooutils/moostock.h"
#include "mooutils/mooactionfactory.h"
#include "mooutils/mooaction-private.h"
#include "mooutils/mooeditops.h"
#include "mooutils/mooatom.h"
#include "mooutils/moolist.h"
#include "mooutils/moocompat.h"
#include "marshals.h"
#include "mooutils/mooi18n.h"
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#ifndef __WIN32__
#define TYPEAHEAD_CASE_SENSITIVE_DEFAULT FALSE
#define COMPLETION_CASE_SENSITIVE_DEFAULT TRUE
#else /* __WIN32__ */
#define TYPEAHEAD_CASE_SENSITIVE_DEFAULT FALSE
#define COMPLETION_CASE_SENSITIVE_DEFAULT FALSE
#endif /* __WIN32__ */
#define SORT_FLAG_SET(flag) ((fileview->priv->sort_flags & (flag)) != 0)
enum {
TREEVIEW_PAGE = 0,
ICONVIEW_PAGE = 1,
BOOKMARK_PAGE = 2
};
enum {
TARGET_URI_LIST = 1,
TARGET_TEXT = 2
};
#define CLIPBOARD_ATOM (moo_file_view_clipboard_atom ())
MOO_DEFINE_ATOM (MOO_FILE_VIEW_CLIPBOARD, moo_file_view_clipboard)
static GtkTargetEntry source_targets[] = {
{(char*) "text/uri-list", 0, TARGET_URI_LIST}
};
static GtkTargetEntry dest_targets[] = {
{(char*) "text/uri-list", 0, TARGET_URI_LIST}
};
typedef struct History History;
typedef struct Typeahead Typeahead;
typedef struct Clipboard Clipboard;
MOO_DEFINE_DLIST_FULL(FileList, file_list, MooFile, _moo_file_ref, _moo_file_unref)
struct Clipboard {
MooFolder *folder;
FileList *files;
gboolean cut;
};
struct MooFileViewPrivate {
GtkTreeModel *model;
GtkTreeModel *filter_model;
MooFolder *current_dir;
MooFileSystem *file_system;
Clipboard *clipboard;
guint select_file_idle;
char *select_file;
GtkIconSize icon_size;
GtkNotebook *notebook;
MooFileViewType view_type;
MooFileViewType file_view_type;
MooTreeView *view;
GtkTreeView *treeview;
GtkTreeViewColumn *tree_name_column;
MooIconView *iconview;
MooBookmarkView *bkview;
GtkMenu *bookmarks_menu;
MooBookmarkMgr *bookmark_mgr;
char *home_dir;
History *history;
GString *temp_visible; /* temporary visible name, for interactive search */
MooFilterMgr *filter_mgr;
GtkToggleButton *filter_button;
GtkComboBox *filter_combo;
GtkEntry *filter_entry;
GtkFileFilter *current_filter;
gboolean use_current_filter;
GtkEntry *entry;
int entry_state; /* it can be one of three: nothing, typeahead, or completion,
depending on text entered into the entry */
Typeahead *typeahead;
guint sort_flags : 2;
guint typeahead_case_sensitive : 1;
guint completion_case_sensitive : 1;
guint show_hidden_files : 1;
guint show_two_dots : 1;
MooActionCollection *actions;
MooUiXml *ui_xml;
gboolean has_selection;
gpointer props_dialog;
GtkTargetList *targets;
GSList *drag_dest_widgets;
struct {
GtkWidget *button;
gboolean highlight;
GtkTreeRowReference *row;
guint timeout;
int x;
int y;
gboolean blink_clear;
guint n_blinks;
} drop_to;
};
static void moo_file_view_finalize (GObject *object);
static void moo_file_view_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void moo_file_view_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void moo_file_view_destroy (GtkObject *object);
static void moo_file_view_hide (GtkWidget *widget);
static gboolean moo_file_view_key_press (MooFileView *fileview,
GtkWidget *widget,
GdkEventKey *event);
static gboolean moo_file_view_popup_menu (GtkWidget *widget);
static void moo_file_view_unrealize (GtkWidget *widget);
static void moo_file_view_set_bookmark_mgr (MooFileView *fileview,
MooBookmarkMgr *mgr);
static const char *moo_file_view_get_home_dir (MooFileView *fileview);
static void moo_file_view_set_current_dir (MooFileView *fileview,
MooFolder *folder);
static gboolean moo_file_view_chdir_real (MooFileView *fileview,
const char *dir,
GError **error);
static void moo_file_view_reload (MooFileView *fileview);
static void _moo_file_view_select_display_name (MooFileView *fileview,
const char *name);
static void _moo_file_view_set_show_hidden (MooFileView *fileview,
gboolean show);
static void _moo_file_view_set_show_parent (MooFileView *fileview,
gboolean show);
static void _moo_file_view_set_sort_case_sensitive (MooFileView *fileview,
gboolean case_sensitive);
static void _moo_file_view_set_sort_folders_first (MooFileView *fileview,
gboolean folders_first);
static void _moo_file_view_set_typeahead_case_sensitive (MooFileView *fileview,
gboolean case_sensitive);
static void _moo_file_view_set_view_type (MooFileView *fileview,
MooFileViewType type);
static void moo_file_view_go_up (MooFileView *fileview);
static void moo_file_view_go_home (MooFileView *fileview);
static void moo_file_view_go_back (MooFileView *fileview);
static void moo_file_view_go_forward(MooFileView *fileview);
static void toggle_show_hidden (MooFileView *fileview);
static void bookmark_activate (MooBookmarkMgr *mgr,
MooBookmark *bookmark,
MooFileView *activated,
MooFileView *fileview);
static void bookmark_activated (MooFileView *fileview,
MooBookmark *bookmark);
static void history_init (MooFileView *fileview);
static void history_free (MooFileView *fileview);
static void history_add (MooFileView *fileview,
const char *dirname);
static void history_clear (MooFileView *fileview);
static gboolean filter_visible_func (GtkTreeModel *model,
GtkTreeIter *iter,
MooFileView *fileview);
static gboolean moo_file_view_check_visible (MooFileView *fileview,
MooFile *file,
gboolean ignore_hidden,
gboolean ignore_two_dots);
static void icon_data_func (GObject *column_or_iconview,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
MooFileView *fileview);
static void name_data_func (GObject *column_or_iconview,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
MooFileView *fileview);
#ifdef USE_SIZE_AND_STUFF
static void date_data_func (GObject *column_or_iconview,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
MooFileView *fileview);
static void size_data_func (GObject *column_or_iconview,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
MooFileView *fileview);
#endif
static void init_gui (MooFileView *fileview);
static void focus_to_filter_entry (MooFileView *fileview);
static GtkWidget *create_toolbar (MooFileView *fileview);
static GtkWidget *create_notebook (MooFileView *fileview);
static GtkWidget *create_filter_combo (MooFileView *fileview);
static void init_filter_combo (MooFileView *fileview);
static void filter_button_toggled (MooFileView *fileview);
static void filter_combo_changed (MooFileView *fileview);
static void filter_entry_activate (MooFileView *fileview);
static void fileview_set_filter (MooFileView *fileview,
GtkFileFilter *filter);
static void fileview_set_use_filter (MooFileView *fileview,
gboolean use,
gboolean block_signals);
static GtkWidget *create_treeview (MooFileView *fileview);
static GtkWidget *create_iconview (MooFileView *fileview);
static GtkWidget *create_bookmark_view (MooFileView *fileview);
static GtkWidget *get_view_widget (MooFileView *fileview);
static void file_view_move_selection (MooFileView *fileview,
GtkTreeIter *filter_iter);
static FileList *file_view_get_selected_files(MooFileView *fileview);
static void path_entry_init (MooFileView *fileview);
static void path_entry_deinit (MooFileView *fileview);
static void path_entry_set_text (MooFileView *fileview,
const char *text);
static void stop_path_entry (MooFileView *fileview,
gboolean focus_file_list);
static void path_entry_delete_to_cursor (MooFileView *fileview);
static void file_view_activate_filename (MooFileView *fileview,
const char *display_name);
static void file_added (MooFileView *fileview);
static void file_view_delete_selected_cb(GtkAction *action,
MooFileView *fileview);
static void file_view_delete_selected (MooFileView *fileview);
static void file_view_create_folder (MooFileView *fileview);
static void file_view_properties_dialog (MooFileView *fileview);
static void view_files (MooFileView *fileview);
static void view_bookmarks (MooFileView *fileview);
static void view_bookmarks_handler (MooFileView *fileview);
static void add_bookmark (MooFileView *fileview);
static void edit_bookmarks (MooFileView *fileview);
/* Dnd */
static void icon_drag_begin (MooFileView *fileview,
GdkDragContext *context,
MooIconView *iconview);
static void icon_drag_data_get (MooFileView *fileview,
GdkDragContext *context,
GtkSelectionData *data,
guint info,
guint time,
MooIconView *iconview);
static void icon_drag_end (MooFileView *fileview,
GdkDragContext *context,
MooIconView *iconview);
static void drag_data_received (MooFileView *fileview,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
guint info,
guint time,
MooIconView *view);
static gboolean drag_drop (MooFileView *fileview,
GdkDragContext *context,
int x,
int y,
guint time,
MooIconView *view);
static void drag_leave (MooFileView *fileview,
GdkDragContext *context,
guint time,
GtkWidget *view);
static gboolean drag_motion (GtkWidget *view,
GdkDragContext *context,
int x,
int y,
guint time,
MooFileView *fileview);
static gboolean moo_file_view_drop (MooFileView *fileview,
const char *path,
GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
guint time);
static gboolean moo_file_view_drop_data_received
(MooFileView *fileview,
const char *path,
GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
guint info,
guint time);
static void cancel_drop_open (MooFileView *fileview);
static void button_drag_leave (MooFileView *fileview,
GdkDragContext *context,
guint time,
GtkWidget *button);
static gboolean button_drag_motion (MooFileView *fileview,
GdkDragContext *context,
int x,
int y,
guint time,
GtkWidget *button);
static void sync_dest_targets (MooFileView *fileview);
static void moo_file_view_drop_uris (MooFileView *fileview,
char **uris,
const char *destdir,
GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
guint time);
static gboolean moo_file_view_drop_text (MooFileView *fileview,
const char *text,
const char *destdir,
GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
guint time,
gboolean *delete);
static void file_list_selection_changed (MooFileView *file_view,
MooTreeView *view);
static gboolean file_list_button_press (MooFileView *fileview,
GtkWidget *widget,
GdkEventButton *event,
MooTreeView *view);
static void file_list_row_activated (MooFileView *fileview,
GtkTreePath *filter_path);
static Clipboard *clipboard_new (MooFolder *folder,
FileList *files,
gboolean cut);
static void clipboard_free (Clipboard *cb);
static void file_view_clear_clipboard (MooFileView *fileview);
static gboolean file_view_file_is_cut (MooFileView *fileview,
MooFile *file);
static void copy_files (MooFileView *fileview,
GList *filenames,
const char *destdir);
static void move_files (MooFileView *fileview,
GList *filenames,
const char *destdir);
static void link_files (MooFileView *fileview,
GList *filenames,
const char *destdir);
static void file_view_cut_clipboard (MooFileView *fileview);
static void file_view_copy_clipboard (MooFileView *fileview);
static void file_view_paste_clipboard (MooFileView *fileview);
static void edit_ops_iface_init (MooEditOpsIface *iface);
static void action_file_view_go_up (MooFileView *fileview);
static void action_file_view_go_back (MooFileView *fileview);
static void action_file_view_go_forward (MooFileView *fileview);
static void action_file_view_go_home (MooFileView *fileview);
/* MOO_TYPE_FILE_VIEW */
G_DEFINE_TYPE_WITH_CODE (MooFileView, moo_file_view, GTK_TYPE_VBOX,
G_IMPLEMENT_INTERFACE (MOO_TYPE_EDIT_OPS,
edit_ops_iface_init))
enum {
PROP_0,
PROP_CURRENT_DIRECTORY,
PROP_HOME_DIRECTORY,
PROP_BOOKMARK_MGR,
PROP_SORT_CASE_SENSITIVE,
PROP_SORT_FOLDERS_FIRST,
PROP_TYPEAHEAD_CASE_SENSITIVE,
PROP_COMPLETION_CASE_SENSITIVE,
PROP_SHOW_HIDDEN_FILES,
PROP_SHOW_PARENT_FOLDER,
PROP_VIEW_TYPE,
/* Aux properties */
PROP_HAS_SELECTION,
PROP_CAN_GO_BACK,
PROP_CAN_GO_FORWARD
};
enum {
CHDIR,
ACTIVATE,
POPULATE_POPUP,
GO_UP,
GO_BACK,
GO_FORWARD,
GO_HOME,
FOCUS_TO_FILTER_ENTRY,
FOCUS_TO_FILE_VIEW,
TOGGLE_SHOW_HIDDEN,
TOGGLE_SHOW_BOOKMARKS,
DELETE_TO_CURSOR,
PROPERTIES_DIALOG,
DELETE_SELECTED,
CREATE_FOLDER,
DROP,
DROP_DATA_RECEIVED,
CUT_CLIPBOARD,
COPY_CLIPBOARD,
PASTE_CLIPBOARD,
RELOAD,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
static void
moo_file_view_class_init (MooFileViewClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkObjectClass *gtkobject_class = GTK_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GtkBindingSet *binding_set;
gobject_class->finalize = moo_file_view_finalize;
gobject_class->set_property = moo_file_view_set_property;
gobject_class->get_property = moo_file_view_get_property;
gtkobject_class->destroy = moo_file_view_destroy;
widget_class->hide = moo_file_view_hide;
widget_class->popup_menu = moo_file_view_popup_menu;
widget_class->unrealize = moo_file_view_unrealize;
klass->chdir = moo_file_view_chdir_real;
klass->drop = moo_file_view_drop;
klass->drop_data_received = moo_file_view_drop_data_received;
g_object_class_install_property (gobject_class,
PROP_HAS_SELECTION,
g_param_spec_boolean ("has-selection",
"has-selection", "has-selection",
FALSE, G_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_CAN_GO_BACK,
g_param_spec_boolean ("can-go-back",
"can-go-back", "can-go-back",
FALSE, G_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_CAN_GO_FORWARD,
g_param_spec_boolean ("can-go-forward",
"can-go-forward", "can-go-forward",
FALSE, G_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_CURRENT_DIRECTORY,
g_param_spec_string ("current-directory",
"current-directory",
"current-directory",
NULL,
(GParamFlags) G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_HOME_DIRECTORY,
g_param_spec_string ("home-directory",
"home-directory",
"home-directory",
NULL,
(GParamFlags) G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_BOOKMARK_MGR,
g_param_spec_object ("bookmark-mgr",
"bookmark-mgr",
"bookmark-mgr",
MOO_TYPE_BOOKMARK_MGR,
(GParamFlags) (G_PARAM_CONSTRUCT | G_PARAM_READWRITE)));
g_object_class_install_property (gobject_class,
PROP_TYPEAHEAD_CASE_SENSITIVE,
g_param_spec_boolean ("typeahead-case-sensitive",
"typeahead-case-sensitive",
"typeahead-case-sensitive",
TYPEAHEAD_CASE_SENSITIVE_DEFAULT,
(GParamFlags) (G_PARAM_CONSTRUCT | G_PARAM_READWRITE)));
g_object_class_install_property (gobject_class, PROP_SORT_CASE_SENSITIVE,
g_param_spec_boolean ("sort-case-sensitive", "sort-case-sensitive", "sort-case-sensitive",
0, (GParamFlags) G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, PROP_SORT_FOLDERS_FIRST,
g_param_spec_boolean ("sort-folders-first", "sort-folders-first", "sort-folders-first",
0, (GParamFlags) G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_COMPLETION_CASE_SENSITIVE,
g_param_spec_boolean ("completion-case-sensitive",
"completion-case-sensitive",
"completion-case-sensitive",
COMPLETION_CASE_SENSITIVE_DEFAULT,
(GParamFlags) (G_PARAM_CONSTRUCT | G_PARAM_READWRITE)));
g_object_class_install_property (gobject_class,
PROP_SHOW_HIDDEN_FILES,
g_param_spec_boolean ("show-hidden-files",
"show-hidden-files",
"show-hidden-files",
FALSE,
(GParamFlags) G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_PARENT_FOLDER,
g_param_spec_boolean ("show-parent-folder",
"show-parent-folder",
"show-parent-folder",
FALSE,
(GParamFlags) G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_VIEW_TYPE,
g_param_spec_enum ("view-type",
"view-type",
"view-type",
MOO_TYPE_FILE_VIEW_TYPE,
MOO_FILE_VIEW_ICON,
(GParamFlags) G_PARAM_READWRITE));
signals[CHDIR] =
g_signal_new ("chdir",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (MooFileViewClass, chdir),
NULL, NULL,
_moo_marshal_BOOLEAN__STRING_POINTER,
G_TYPE_BOOLEAN, 2,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_POINTER);
signals[ACTIVATE] =
g_signal_new ("activate",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (MooFileViewClass, activate),
NULL, NULL,
_moo_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[POPULATE_POPUP] =
g_signal_new ("populate-popup",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (MooFileViewClass, populate_popup),
NULL, NULL,
_moo_marshal_VOID__POINTER_OBJECT,
G_TYPE_NONE, 2,
G_TYPE_POINTER,
GTK_TYPE_MENU);
signals[GO_UP] =
_moo_signal_new_cb("go-up",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_up),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[GO_FORWARD] =
_moo_signal_new_cb("go-forward",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_forward),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[GO_BACK] =
_moo_signal_new_cb("go-back",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_back),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[GO_HOME] =
_moo_signal_new_cb("go-home",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_home),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[FOCUS_TO_FILTER_ENTRY] =
_moo_signal_new_cb("focus-to-filter-entry",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (focus_to_filter_entry),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[FOCUS_TO_FILE_VIEW] =
_moo_signal_new_cb("focus-to-file-view",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_focus_files),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[TOGGLE_SHOW_HIDDEN] =
_moo_signal_new_cb("toggle-show-hidden",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (toggle_show_hidden),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[TOGGLE_SHOW_BOOKMARKS] =
_moo_signal_new_cb("toggle-show-bookmarks",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (view_bookmarks_handler),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[DELETE_TO_CURSOR] =
_moo_signal_new_cb("delete-to-cursor",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (path_entry_delete_to_cursor),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[DELETE_SELECTED] =
_moo_signal_new_cb("delete-selected",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_delete_selected),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[CREATE_FOLDER] =
_moo_signal_new_cb("create-folder",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_create_folder),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[PROPERTIES_DIALOG] =
_moo_signal_new_cb("properties-dialog",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_properties_dialog),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[RELOAD] =
_moo_signal_new_cb("reload",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_reload),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[DROP] =
g_signal_new ("drop",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooFileViewClass, drop),
g_signal_accumulator_true_handled, NULL,
_moo_marshal_BOOLEAN__STRING_OBJECT_OBJECT_INT_INT_UINT,
G_TYPE_BOOLEAN, 6,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_WIDGET,
GDK_TYPE_DRAG_CONTEXT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_UINT);
signals[DROP_DATA_RECEIVED] =
g_signal_new ("drop-data-received",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooFileViewClass, drop_data_received),
g_signal_accumulator_true_handled, NULL,
_moo_marshal_BOOLEAN__STRING_OBJECT_OBJECT_INT_INT_POINTER_UINT_UINT,
G_TYPE_BOOLEAN, 8,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_WIDGET,
GDK_TYPE_DRAG_CONTEXT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_POINTER,
G_TYPE_UINT,
G_TYPE_UINT);
signals[CUT_CLIPBOARD] =
_moo_signal_new_cb("cut-clipboard",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_cut_clipboard),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[COPY_CLIPBOARD] =
_moo_signal_new_cb("copy-clipboard",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_copy_clipboard),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[PASTE_CLIPBOARD] =
_moo_signal_new_cb("paste-clipboard",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_paste_clipboard),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set,
GDK_u, GDK_CONTROL_MASK,
"delete-to-cursor", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_PROPERTIES,
"properties-dialog", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_DELETE,
"delete-selected", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_UP,
"go-up", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_UP_KP,
"go-up", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_BACK,
"go-back", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_FORWARD,
"go-forward", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_HOME,
"go-home", 0);
#ifdef MOO_FILE_VIEW_BINDING_GO_BACK_KP
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_BACK_KP,
"go-back", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_FORWARD_KP,
"go-forward", 0);
gtk_binding_entry_add_signal (binding_set,
MOO_FILE_VIEW_BINDING_GO_HOME_KP,
"go-home", 0);
#endif
gtk_binding_entry_add_signal (binding_set,
GDK_f, GDK_MOD1_MASK | GDK_SHIFT_MASK,
"focus-to-filter-entry", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_b, GDK_MOD1_MASK | GDK_SHIFT_MASK,
"focus-to-file-view", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_h, GDK_MOD1_MASK | GDK_SHIFT_MASK,
"toggle-show-hidden", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_k, GDK_MOD1_MASK | GDK_SHIFT_MASK,
"toggle-show-bookmarks", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_c, MOO_ACCEL_CTRL_MASK,
"copy-clipboard", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_Insert, GDK_CONTROL_MASK,
"copy-clipboard", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_x, MOO_ACCEL_CTRL_MASK,
"cut-clipboard", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_Delete, GDK_SHIFT_MASK,
"cut-clipboard", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_v, MOO_ACCEL_CTRL_MASK,
"paste-clipboard", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_Insert, GDK_SHIFT_MASK,
"paste-clipboard", 0);
}
static void
moo_file_view_init (MooFileView *fileview)
{
fileview->priv = g_new0 (MooFileViewPrivate, 1);
fileview->priv->show_hidden_files = FALSE;
fileview->priv->file_view_type = fileview->priv->view_type = MOO_FILE_VIEW_ICON;
fileview->priv->use_current_filter = FALSE;
fileview->priv->icon_size = GTK_ICON_SIZE_MENU;
fileview->priv->typeahead_case_sensitive = TYPEAHEAD_CASE_SENSITIVE_DEFAULT;
fileview->priv->sort_flags = MOO_FOLDER_MODEL_SORT_FLAGS_DEFAULT;
fileview->priv->completion_case_sensitive = COMPLETION_CASE_SENSITIVE_DEFAULT;
history_init (fileview);
fileview->priv->model = g_object_new (MOO_TYPE_FOLDER_MODEL, (const char*) NULL);
g_signal_connect_swapped (fileview->priv->model, "row-inserted",
G_CALLBACK (file_added), fileview);
fileview->priv->filter_model =
_moo_folder_filter_new (MOO_FOLDER_MODEL (fileview->priv->model));
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (fileview->priv->filter_model),
(GtkTreeModelFilterVisibleFunc) filter_visible_func,
fileview, NULL);
fileview->priv->file_system = _moo_file_system_create ();
fileview->priv->targets = gtk_target_list_new (dest_targets, G_N_ELEMENTS (dest_targets));
gtk_target_list_add_text_targets (fileview->priv->targets, TARGET_TEXT);
init_gui (fileview);
path_entry_init (fileview);
_moo_file_view_tools_load (fileview);
}
static void
moo_file_view_destroy (GtkObject *object)
{
MooFileView *fileview = MOO_FILE_VIEW (object);
if (fileview->priv->props_dialog)
{
gtk_widget_destroy (fileview->priv->props_dialog);
fileview->priv->props_dialog = NULL;
}
GTK_OBJECT_CLASS (moo_file_view_parent_class)->destroy (object);
}
static void
moo_file_view_finalize (GObject *object)
{
MooFileView *fileview = MOO_FILE_VIEW (object);
path_entry_deinit (fileview);
if (fileview->priv->select_file_idle)
g_source_remove (fileview->priv->select_file_idle);
g_free (fileview->priv->select_file);
g_object_unref (fileview->priv->model);
g_object_unref (fileview->priv->filter_model);
history_free (fileview);
if (fileview->priv->bookmark_mgr)
{
g_signal_handlers_disconnect_by_func (fileview->priv->bookmark_mgr,
(gpointer) bookmark_activate,
fileview);
_moo_bookmark_mgr_remove_user (fileview->priv->bookmark_mgr,
fileview);
g_object_unref (fileview->priv->bookmark_mgr);
}
if (fileview->priv->filter_mgr)
g_object_unref (fileview->priv->filter_mgr);
if (fileview->priv->current_filter)
g_object_unref (fileview->priv->current_filter);
if (fileview->priv->temp_visible)
g_string_free (fileview->priv->temp_visible, TRUE);
if (fileview->priv->current_dir)
g_object_unref (fileview->priv->current_dir);
g_object_unref (fileview->priv->file_system);
g_free (fileview->priv->home_dir);
g_object_unref (fileview->priv->actions);
g_object_unref (fileview->priv->ui_xml);
gtk_target_list_unref (fileview->priv->targets);
g_slist_free (fileview->priv->drag_dest_widgets);
g_free (fileview->priv);
fileview->priv = NULL;
G_OBJECT_CLASS (moo_file_view_parent_class)->finalize (object);
}
static void
moo_file_view_hide (GtkWidget *widget)
{
cancel_drop_open (MOO_FILE_VIEW (widget));
GTK_WIDGET_CLASS(moo_file_view_parent_class)->hide (widget);
}
static void
moo_file_view_set_current_dir (MooFileView *fileview,
MooFolder *folder)
{
GtkTreeIter filter_iter;
char *path;
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
g_return_if_fail (!folder || MOO_IS_FOLDER (folder));
if (folder == fileview->priv->current_dir)
return;
cancel_drop_open (fileview);
if (fileview->priv->temp_visible)
{
g_string_free (fileview->priv->temp_visible, TRUE);
fileview->priv->temp_visible = NULL;
}
if (!folder)
{
if (fileview->priv->current_dir)
{
g_object_unref (fileview->priv->current_dir);
fileview->priv->current_dir = NULL;
_moo_folder_model_set_folder (MOO_FOLDER_MODEL (fileview->priv->model),
NULL);
}
history_clear (fileview);
path_entry_set_text (fileview, "");
g_object_set (MOO_FILE_ENTRY (fileview->priv->entry),
"current-dir", NULL, NULL);
g_object_notify (G_OBJECT (fileview), "current-directory");
return;
}
if (fileview->priv->current_dir)
g_object_unref (fileview->priv->current_dir);
fileview->priv->current_dir = g_object_ref (folder);
_moo_folder_model_set_folder (MOO_FOLDER_MODEL (fileview->priv->model),
folder);
if (gtk_tree_model_get_iter_first (fileview->priv->filter_model, &filter_iter))
file_view_move_selection (fileview, &filter_iter);
if (gtk_widget_is_focus (GTK_WIDGET (fileview->priv->entry)))
moo_file_view_focus_files (fileview);
path = g_filename_display_name (_moo_folder_get_path (folder));
path_entry_set_text (fileview, path);
g_free (path);
g_object_set (MOO_FILE_ENTRY(fileview->priv->entry)->completion,
"current-dir", _moo_folder_get_path (folder), NULL);
history_add (fileview, _moo_folder_get_path (folder));
g_object_notify (G_OBJECT (fileview), "current-directory");
}
static gboolean
moo_file_view_chdir_real (MooFileView *fileview,
const char *new_dir,
GError **error)
{
char *real_new_dir;
MooFolder *folder;
g_return_val_if_fail (MOO_IS_FILE_VIEW (fileview), FALSE);
if (!new_dir)
{
moo_file_view_set_current_dir (fileview, NULL);
return TRUE;
}
if (_moo_path_is_absolute (new_dir) || !fileview->priv->current_dir)
{
real_new_dir = g_strdup (new_dir);
}
else
{
real_new_dir = g_build_filename (_moo_folder_get_path (fileview->priv->current_dir),
new_dir, NULL);
}
folder = _moo_file_system_get_folder (fileview->priv->file_system,
real_new_dir,
MOO_FILE_ALL_FLAGS,
error);
g_free (real_new_dir);
if (!folder)
return FALSE;
view_files (fileview);
moo_file_view_set_current_dir (fileview, folder);
g_object_unref (folder);
return TRUE;
}
static void
moo_file_view_reload (MooFileView *fileview)
{
if (fileview->priv->current_dir)
_moo_folder_reload (fileview->priv->current_dir);
}
static void
init_actions (MooFileView *fileview)
{
GtkAction *action;
GtkActionGroup *group;
fileview->priv->actions = moo_action_collection_new ("File Selector", _("File Selector"));
fileview->priv->ui_xml = moo_ui_xml_new ();
moo_ui_xml_add_ui_from_string (fileview->priv->ui_xml,
moofileview_ui_xml, -1);
group = moo_action_collection_get_group (fileview->priv->actions, NULL);
moo_action_group_add_action (group, "GoUp",
"label", GTK_STOCK_GO_UP,
"tooltip", _("Go to parent folder"),
"stock-id", GTK_STOCK_GO_UP,
"default-accel", MOO_FILE_VIEW_ACCEL_GO_UP,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", action_file_view_go_up,
NULL);
action = moo_action_group_add_action (group, "GoBack",
"label", GTK_STOCK_GO_BACK,
"tooltip", GTK_STOCK_GO_BACK,
"stock-id", GTK_STOCK_GO_BACK,
"default-accel", MOO_FILE_VIEW_ACCEL_GO_BACK,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", action_file_view_go_back,
NULL);
moo_bind_bool_property (action, "sensitive", fileview, "can-go-back", FALSE);
action = moo_action_group_add_action (group, "GoForward",
"label", GTK_STOCK_GO_FORWARD,
"tooltip", GTK_STOCK_GO_FORWARD,
"stock-id", GTK_STOCK_GO_FORWARD,
"default-accel", MOO_FILE_VIEW_ACCEL_GO_FORWARD,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", action_file_view_go_forward,
NULL);
moo_bind_bool_property (action, "sensitive", fileview, "can-go-forward", FALSE);
moo_action_group_add_action (group, "GoHome",
"label", GTK_STOCK_HOME,
"tooltip", GTK_STOCK_HOME,
"stock-id", GTK_STOCK_HOME,
"default-accel", MOO_FILE_VIEW_ACCEL_GO_HOME,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", action_file_view_go_home,
NULL);
moo_action_group_add_action (group, "NewFolder",
"label", MOO_STOCK_NEW_FOLDER,
"tooltip", MOO_STOCK_NEW_FOLDER,
"stock-id", MOO_STOCK_NEW_FOLDER,
"closure-object", fileview,
"closure-callback", file_view_create_folder,
NULL);
action = moo_action_group_add_action (group, "Delete",
"label", _("Delete..."),
"tooltip", _("Delete selected files"),
"stock-id", GTK_STOCK_DELETE,
"default-accel", MOO_FILE_VIEW_ACCEL_DELETE,
"force-accel-label", TRUE,
NULL);
moo_bind_bool_property (action, "sensitive", fileview, "has-selection", FALSE);
g_signal_connect (action, "activate", G_CALLBACK (file_view_delete_selected_cb), fileview);
action = moo_action_group_add_action (group, "ShowHiddenFiles",
"action-type::", MOO_TYPE_TOGGLE_ACTION,
"label", _("Show Hidden Files"),
"tooltip", _("Show Hidden Files"),
"default-accel", MOO_FILE_VIEW_ACCEL_SHOW_HIDDEN,
"force-accel-label", TRUE,
NULL);
_moo_sync_toggle_action (action, fileview, "show-hidden-files", FALSE);
action = moo_action_group_add_action (group, "ShowParentFolder",
"action-type::", MOO_TYPE_TOGGLE_ACTION,
"label", _("Show Parent Folder"),
"tooltip", _("Show Parent Folder"),
NULL);
_moo_sync_toggle_action (action, fileview, "show-parent-folder", FALSE);
action = moo_action_group_add_action (group, "CaseSensitiveSort",
"action-type::", MOO_TYPE_TOGGLE_ACTION,
"label", _("Case Sensitive Sort"),
"tooltip", _("Case Sensitive Sort"),
NULL);
_moo_sync_toggle_action (action, fileview, "sort-case-sensitive", FALSE);
action = moo_action_group_add_action (group, "SortFoldersFirst",
"action-type::", MOO_TYPE_TOGGLE_ACTION,
"label", _("Show Folders First"),
"tooltip", _("Show Folders First"),
NULL);
_moo_sync_toggle_action (action, fileview, "sort-folders-first", FALSE);
action = moo_action_group_add_action (group, "Properties",
"label", GTK_STOCK_PROPERTIES,
"tooltip", GTK_STOCK_PROPERTIES,
"stock-id", GTK_STOCK_PROPERTIES,
"default-accel", MOO_FILE_VIEW_ACCEL_PROPERTIES,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", file_view_properties_dialog,
NULL);
moo_bind_bool_property (action, "sensitive", fileview, "has-selection", FALSE);
moo_action_group_add_action (group, "BookmarksMenu",
"label", _("Bookmarks"),
"tooltip", _("Bookmarks"),
"stock-id", MOO_STOCK_FILE_BOOKMARK,
"closure-object", fileview,
"closure-callback", view_bookmarks,
"has-submenu", TRUE,
NULL);
moo_action_group_add_action (group, "AddBookmark",
"label", _("Add Bookmark"),
"tooltip", _("Add Bookmark"),
"stock-id", GTK_STOCK_ADD,
"closure-object", fileview,
"closure-callback", add_bookmark,
NULL);
moo_action_group_add_action (group, "EditBookmarks",
"label", _("Edit Bookmarks"),
"tooltip", _("Edit Bookmarks"),
"stock-id", GTK_STOCK_EDIT,
"closure-object", fileview,
"closure-callback", edit_bookmarks,
NULL);
action = moo_action_group_add_action (group, "Cut",
"label", GTK_STOCK_CUT,
"tooltip", GTK_STOCK_CUT,
"stock-id", GTK_STOCK_CUT,
"default-accel", MOO_FILE_VIEW_ACCEL_CUT,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", file_view_cut_clipboard,
NULL);
moo_bind_bool_property (action, "sensitive", fileview, "has-selection", FALSE);
action = moo_action_group_add_action (group, "Copy",
"label", GTK_STOCK_COPY,
"tooltip", GTK_STOCK_COPY,
"stock-id", GTK_STOCK_COPY,
"force-accel-label", TRUE,
"default-accel", MOO_FILE_VIEW_ACCEL_COPY,
"closure-object", fileview,
"closure-callback", file_view_copy_clipboard,
NULL);
moo_bind_bool_property (action, "sensitive", fileview, "has-selection", FALSE);
action = moo_action_group_add_action (group, "Paste",
"label", GTK_STOCK_PASTE,
"tooltip", GTK_STOCK_PASTE,
"stock-id", GTK_STOCK_PASTE,
"default-accel", MOO_FILE_VIEW_ACCEL_PASTE,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", file_view_paste_clipboard,
NULL);
moo_action_group_add_action (group, "Reload",
"label", _("Reload"),
"tooltip", _("Reload"),
"stock-id", GTK_STOCK_REFRESH,
"closure-object", fileview,
"closure-signal", "reload",
NULL);
}
static void
action_file_view_go_up (MooFileView *fileview)
{
g_signal_emit_by_name (fileview, "go-up");
moo_file_view_focus_files (fileview);
}
static void
action_file_view_go_back (MooFileView *fileview)
{
g_signal_emit_by_name (fileview, "go-back");
moo_file_view_focus_files (fileview);
}
static void
action_file_view_go_forward (MooFileView *fileview)
{
g_signal_emit_by_name (fileview, "go-forward");
moo_file_view_focus_files (fileview);
}
static void
action_file_view_go_home (MooFileView *fileview)
{
g_signal_emit_by_name (fileview, "go-home");
moo_file_view_focus_files (fileview);
}
MooUiXml*
moo_file_view_get_ui_xml (MooFileView *fileview)
{
g_return_val_if_fail (MOO_IS_FILE_VIEW (fileview), NULL);
return fileview->priv->ui_xml;
}
MooActionCollection *
moo_file_view_get_actions (MooFileView *fileview)
{
g_return_val_if_fail (MOO_IS_FILE_VIEW (fileview), NULL);
return fileview->priv->actions;
}
static void
init_gui (MooFileView *fileview)
{
GtkBox *box;
GtkWidget *toolbar, *notebook, *filter_combo, *entry;
init_actions (fileview);
box = GTK_BOX (fileview);
toolbar = create_toolbar (fileview);
if (toolbar)
{
gtk_widget_show (toolbar);
gtk_box_pack_start (box, toolbar, FALSE, FALSE, 0);
}
else
{
g_critical ("oops");
}
entry = _moo_file_entry_new ();
g_object_set_data (G_OBJECT (entry), "moo-file-view", fileview);
gtk_widget_show (entry);
gtk_box_pack_start (box, entry, FALSE, FALSE, 0);
fileview->priv->entry = GTK_ENTRY (entry);
notebook = create_notebook (fileview);
gtk_widget_show (notebook);
gtk_box_pack_start (box, notebook, TRUE, TRUE, 0);
fileview->priv->notebook = GTK_NOTEBOOK (notebook);
filter_combo = create_filter_combo (fileview);
gtk_widget_show (filter_combo);
gtk_box_pack_start (box, filter_combo, FALSE, FALSE, 0);
init_filter_combo (fileview);
switch (fileview->priv->view_type)
{
case MOO_FILE_VIEW_ICON:
fileview->priv->file_view_type = MOO_FILE_VIEW_ICON;
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook),
ICONVIEW_PAGE);
_moo_tree_view_set_active (fileview->priv->view,
GTK_WIDGET (fileview->priv->iconview));
break;
case MOO_FILE_VIEW_LIST:
fileview->priv->file_view_type = MOO_FILE_VIEW_LIST;
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook),
TREEVIEW_PAGE);
_moo_tree_view_set_active (fileview->priv->view,
GTK_WIDGET (fileview->priv->treeview));
break;
case MOO_FILE_VIEW_BOOKMARK:
fileview->priv->file_view_type = MOO_FILE_VIEW_ICON;
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook),
BOOKMARK_PAGE);
break;
}
moo_file_view_focus_files (fileview);
}
void
moo_file_view_focus_files (MooFileView *fileview)
{
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
gtk_widget_grab_focus (get_view_widget (fileview));
}
static void
focus_to_filter_entry (MooFileView *fileview)
{
gtk_widget_grab_focus (GTK_WIDGET(fileview->priv->filter_entry));
}
static void
_moo_file_view_set_view_type (MooFileView *fileview,
MooFileViewType type)
{
if (fileview->priv->view_type == type)
return;
cancel_drop_open (fileview);
switch (type)
{
case MOO_FILE_VIEW_LIST:
fileview->priv->file_view_type = MOO_FILE_VIEW_LIST;
_moo_tree_view_set_active (fileview->priv->view,
GTK_WIDGET (fileview->priv->treeview));
gtk_notebook_set_current_page (fileview->priv->notebook,
TREEVIEW_PAGE);
break;
case MOO_FILE_VIEW_ICON:
fileview->priv->file_view_type = MOO_FILE_VIEW_ICON;
_moo_tree_view_set_active (fileview->priv->view,
GTK_WIDGET (fileview->priv->iconview));
gtk_notebook_set_current_page (fileview->priv->notebook,
ICONVIEW_PAGE);
break;
case MOO_FILE_VIEW_BOOKMARK:
fileview->priv->file_view_type = fileview->priv->view_type;
gtk_notebook_set_current_page (fileview->priv->notebook,
BOOKMARK_PAGE);
break;
}
fileview->priv->view_type = type;
}
void
_moo_file_view_setup_button_drag_dest (MooFileView *fileview,
const char *xml_path,
const char *sig_name)
{
GtkWidget *button;
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
g_return_if_fail (xml_path != NULL);
g_return_if_fail (sig_name != NULL);
button = moo_ui_xml_get_widget (fileview->priv->ui_xml,
fileview->toolbar, xml_path);
g_return_if_fail (button != NULL);
g_object_set_data_full (G_OBJECT (button), "moo-fileview-signal",
g_strdup (sig_name), g_free);
gtk_drag_dest_set (button, 0, NULL, 0,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
gtk_drag_dest_set_target_list (button, fileview->priv->targets);
fileview->priv->drag_dest_widgets =
g_slist_prepend (fileview->priv->drag_dest_widgets, button);
g_signal_connect_swapped (button, "drag-motion",
G_CALLBACK (button_drag_motion), fileview);
g_signal_connect_swapped (button, "drag-leave",
G_CALLBACK (button_drag_leave), fileview);
}
static GtkWidget*
create_toolbar (MooFileView *fileview)
{
GtkToolbar *toolbar;
toolbar = GTK_TOOLBAR (
moo_ui_xml_create_widget (fileview->priv->ui_xml,
MOO_UI_TOOLBAR,
"MooFileView/Toolbar",
fileview->priv->actions,
NULL));
g_return_val_if_fail (toolbar != NULL, NULL);
fileview->toolbar = GTK_WIDGET (toolbar);
gtk_toolbar_set_tooltips (toolbar, TRUE);
gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size (toolbar, GTK_ICON_SIZE_MENU);
_moo_file_view_setup_button_drag_dest (fileview, "MooFileView/Toolbar/GoUp", "go-up");
_moo_file_view_setup_button_drag_dest (fileview, "MooFileView/Toolbar/GoBack", "go-back");
_moo_file_view_setup_button_drag_dest (fileview, "MooFileView/Toolbar/GoForward", "go-forward");
_moo_file_view_setup_button_drag_dest (fileview, "MooFileView/Toolbar/GoHome", "go-home");
return fileview->toolbar;
}
static void
create_tree_view_proxy (MooFileView *fileview)
{
fileview->priv->view = _moo_tree_view_new (fileview->priv->filter_model);
g_signal_connect_swapped (fileview->priv->view, "key-press-event",
G_CALLBACK (moo_file_view_key_press),
fileview);
g_signal_connect_swapped (fileview->priv->view, "selection-changed",
G_CALLBACK (file_list_selection_changed), fileview);
g_signal_connect_swapped (fileview->priv->view, "button-press-event",
G_CALLBACK (file_list_button_press), fileview);
g_signal_connect_swapped (fileview->priv->view, "row-activated",
G_CALLBACK (file_list_row_activated), fileview);
}
static GtkWidget *
create_notebook (MooFileView *fileview)
{
GtkWidget *notebook, *swin, *treeview, *iconview, *bkview;
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
create_tree_view_proxy (fileview);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (swin);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), swin, NULL);
treeview = create_treeview (fileview);
gtk_widget_show (treeview);
gtk_container_add (GTK_CONTAINER (swin), treeview);
fileview->priv->treeview = GTK_TREE_VIEW (treeview);
/* gtk+ #313719 */
g_signal_connect_swapped (treeview, "popup-menu",
G_CALLBACK (moo_file_view_popup_menu),
fileview);
_moo_tree_view_add (fileview->priv->view, treeview);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (swin);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_ALWAYS,
GTK_POLICY_AUTOMATIC);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), swin, NULL);
iconview = create_iconview (fileview);
gtk_widget_show (iconview);
gtk_container_add (GTK_CONTAINER (swin), iconview);
fileview->priv->iconview = MOO_ICON_VIEW (iconview);
_moo_tree_view_add (fileview->priv->view, iconview);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (swin);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), swin, NULL);
bkview = create_bookmark_view (fileview);
gtk_widget_show (bkview);
gtk_container_add (GTK_CONTAINER (swin), bkview);
fileview->priv->bkview = MOO_BOOKMARK_VIEW (bkview);
return notebook;
}
static GtkWidget *
create_filter_combo (G_GNUC_UNUSED MooFileView *fileview)
{
GtkWidget *hbox, *button, *combo;
hbox = gtk_hbox_new (FALSE, 0);
button = gtk_toggle_button_new_with_label (_("Filter"));
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
combo = gtk_combo_box_entry_new ();
gtk_widget_show (combo);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
fileview->priv->filter_button = GTK_TOGGLE_BUTTON (button);
fileview->priv->filter_combo = GTK_COMBO_BOX (combo);
fileview->priv->filter_entry = GTK_ENTRY (GTK_BIN (combo)->child);
g_signal_connect_swapped (button, "toggled",
G_CALLBACK (filter_button_toggled),
fileview);
g_signal_connect_data (combo, "changed",
G_CALLBACK (filter_combo_changed),
fileview, NULL,
G_CONNECT_AFTER | G_CONNECT_SWAPPED);
g_signal_connect_swapped (GTK_BIN (combo)->child, "activate",
G_CALLBACK (filter_entry_activate),
fileview);
return hbox;
}
static GtkWidget *create_treeview (MooFileView *fileview)
{
GtkWidget *treeview;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkCellRenderer *cell;
treeview = gtk_tree_view_new ();
#if 0
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview),
GDK_CONTROL_MASK,
source_targets,
G_N_ELEMENTS (source_targets),
GDK_ACTION_COPY | GDK_ACTION_MOVE |
GDK_ACTION_LINK);
#endif
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Name");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
fileview->priv->tree_name_column = column;
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, cell,
(GtkTreeCellDataFunc) icon_data_func,
fileview, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (column, cell,
(GtkTreeCellDataFunc) name_data_func,
fileview, NULL);
#ifdef USE_SIZE_AND_STUFF
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Size");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, cell,
(GtkTreeCellDataFunc) size_data_func,
fileview, NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Date");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, cell,
(GtkTreeCellDataFunc) date_data_func,
fileview, NULL);
#endif
return treeview;
}
static void
file_list_selection_changed (MooFileView *fileview,
MooTreeView *view)
{
gboolean has_selection;
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
g_return_if_fail (MOO_IS_TREE_VIEW (view));
if (fileview->priv->select_file_idle)
g_source_remove (fileview->priv->select_file_idle);
fileview->priv->select_file_idle = 0;
g_free (fileview->priv->select_file);
fileview->priv->select_file = NULL;
has_selection = !_moo_tree_view_selection_is_empty (view);
if (fileview->priv->has_selection != has_selection)
{
fileview->priv->has_selection = has_selection;
moo_edit_ops_can_do_op_changed (G_OBJECT (fileview), MOO_EDIT_OP_CUT);
moo_edit_ops_can_do_op_changed (G_OBJECT (fileview), MOO_EDIT_OP_COPY);
g_object_notify (G_OBJECT (fileview), "has-selection");
}
}
static GtkWidget*
create_iconview (MooFileView *fileview)
{
GtkWidget *iconview;
GtkCellRenderer *cell;
iconview = _moo_icon_view_new (NULL);
_moo_icon_view_set_selection_mode (MOO_ICON_VIEW (iconview),
GTK_SELECTION_MULTIPLE);
_moo_icon_view_set_cell_data_func (MOO_ICON_VIEW (iconview),
MOO_ICON_VIEW_CELL_PIXBUF,
(MooIconCellDataFunc) icon_data_func,
fileview, NULL);
_moo_icon_view_set_cell_data_func (MOO_ICON_VIEW (iconview),
MOO_ICON_VIEW_CELL_TEXT,
(MooIconCellDataFunc) name_data_func,
fileview, NULL);
cell = _moo_icon_view_get_cell (MOO_ICON_VIEW (iconview),
MOO_ICON_VIEW_CELL_TEXT);
g_object_set (cell, "xalign", 0.0, NULL);
cell = _moo_icon_view_get_cell (MOO_ICON_VIEW (iconview),
MOO_ICON_VIEW_CELL_PIXBUF);
g_object_set (cell, "xpad", 1, "ypad", 1, NULL);
_moo_icon_view_enable_drag_source (MOO_ICON_VIEW (iconview),
GDK_BUTTON1_MASK,
source_targets,
G_N_ELEMENTS (source_targets),
GDK_ACTION_ASK | GDK_ACTION_COPY |
GDK_ACTION_MOVE | GDK_ACTION_LINK);
_moo_icon_view_enable_drag_dest (MOO_ICON_VIEW (iconview), NULL, 0,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
_moo_icon_view_set_dest_targets (MOO_ICON_VIEW (iconview),
fileview->priv->targets);
g_signal_connect_swapped (iconview, "drag-begin",
G_CALLBACK (icon_drag_begin),
fileview);
g_signal_connect_swapped (iconview, "drag-data-get",
G_CALLBACK (icon_drag_data_get),
fileview);
g_signal_connect_swapped (iconview, "drag-end",
G_CALLBACK (icon_drag_end),
fileview);
g_signal_connect_swapped (iconview, "drag-data-received",
G_CALLBACK (drag_data_received),
fileview);
g_signal_connect_swapped (iconview, "drag-drop",
G_CALLBACK (drag_drop),
fileview);
g_signal_connect_swapped (iconview, "drag-leave",
G_CALLBACK (drag_leave),
fileview);
g_signal_connect_after (iconview, "drag-motion",
G_CALLBACK (drag_motion),
fileview);
return iconview;
}
static GtkWidget *
create_bookmark_view (MooFileView *fileview)
{
GtkWidget *bkview;
bkview = _moo_bookmark_view_new (NULL);
#if 0
// gtk_tree_view_enable_drag_source (GTK_TREE_VIEW (bkview),
// GDK_BUTTON1_MASK,
// source_targets,
// G_N_ELEMENTS (source_targets),
// GDK_ACTION_ASK | GDK_ACTION_COPY |
// GDK_ACTION_MOVE | GDK_ACTION_LINK);
#endif
gtk_drag_dest_set (bkview, 0, NULL, 0,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
gtk_drag_dest_set_target_list (bkview, fileview->priv->targets);
#if 0
// g_signal_connect_swapped (bkview, "drag-data-received",
// G_CALLBACK (drag_data_received),
// fileview);
// g_signal_connect_swapped (bkview, "drag-drop",
// G_CALLBACK (drag_drop),
// fileview);
#endif
g_signal_connect_swapped (bkview, "drag-leave",
G_CALLBACK (drag_leave),
fileview);
g_signal_connect_after (bkview, "drag-motion",
G_CALLBACK (drag_motion),
fileview);
g_signal_connect_swapped (bkview, "bookmark-activated",
G_CALLBACK (bookmark_activated), fileview);
return bkview;
}
static gboolean
moo_file_view_check_visible (MooFileView *fileview,
MooFile *file,
gboolean ignore_hidden,
gboolean ignore_two_dots)
{
if (!file)
return FALSE;
if (!strcmp (_moo_file_name (file), ".."))
{
if (!ignore_two_dots)
return fileview->priv->show_two_dots;
else
return FALSE;
}
if (!ignore_hidden && MOO_FILE_IS_HIDDEN (file))
return fileview->priv->show_hidden_files;
if (MOO_FILE_IS_DIR (file))
return TRUE;
if (fileview->priv->current_filter && fileview->priv->use_current_filter)
{
GtkFileFilterInfo filter_info;
GtkFileFilter *filter = fileview->priv->current_filter;
filter_info.contains = gtk_file_filter_get_needed (filter);
filter_info.filename = _moo_file_name (file);
filter_info.uri = NULL;
filter_info.display_name = _moo_file_display_name (file);
filter_info.mime_type = _moo_file_get_mime_type (file);
return gtk_file_filter_filter (fileview->priv->current_filter,
&filter_info);
}
return TRUE;
}
static gboolean
filter_visible_func (GtkTreeModel *model,
GtkTreeIter *iter,
MooFileView *fileview)
{
MooFile *file;
gboolean visible = TRUE;
gtk_tree_model_get (model, iter, COLUMN_FILE, &file, -1);
if (file && fileview->priv->temp_visible &&
!strncmp (_moo_file_name (file),
fileview->priv->temp_visible->str,
fileview->priv->temp_visible->len))
{
visible = moo_file_view_check_visible (fileview, file, TRUE, TRUE);
}
else
{
visible = moo_file_view_check_visible (fileview, file, FALSE, FALSE);
}
_moo_file_unref (file);
return visible;
}
static void
icon_data_func (G_GNUC_UNUSED GObject *column_or_iconview,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
MooFileView *fileview)
{
MooFile *file = NULL;
GdkPixbuf *pixbuf = NULL;
gboolean dim_icon = FALSE;
gtk_tree_model_get (model, iter, COLUMN_FILE, &file, -1);
if (file)
{
pixbuf = _moo_file_get_icon (file, GTK_WIDGET (fileview),
fileview->priv->icon_size);
dim_icon = file_view_file_is_cut (fileview, file);
}
g_object_set (cell, "pixbuf", pixbuf, "sensitive", !dim_icon, NULL);
_moo_file_unref (file);
}
static void
name_data_func (G_GNUC_UNUSED GObject *column_or_iconview,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
G_GNUC_UNUSED MooFileView *fileview)
{
MooFile *file = NULL;
const char *name = NULL;
gtk_tree_model_get (model, iter, COLUMN_FILE, &file, -1);
if (file)
name = _moo_file_display_name (file);
g_object_set (cell, "text", name, NULL);
_moo_file_unref (file);
}
#ifdef USE_SIZE_AND_STUFF
static void date_data_func (G_GNUC_UNUSED GObject *column_or_iconview,
G_GNUC_UNUSED GtkCellRenderer *cell,
G_GNUC_UNUSED GtkTreeModel *model,
G_GNUC_UNUSED GtkTreeIter *iter,
G_GNUC_UNUSED MooFileView *fileview)
{
}
static void size_data_func (G_GNUC_UNUSED GObject *column_or_iconview,
G_GNUC_UNUSED GtkCellRenderer *cell,
G_GNUC_UNUSED GtkTreeModel *model,
G_GNUC_UNUSED GtkTreeIter *iter,
G_GNUC_UNUSED MooFileView *fileview)
{
}
#endif
gboolean
moo_file_view_chdir (MooFileView *fileview,
GFile *file,
GError **error)
{
gboolean result;
char *dir;
moo_return_error_if_fail (MOO_IS_FILE_VIEW (fileview));
dir = g_file_get_path (file);
moo_return_error_if_fail (dir != NULL);
result = moo_file_view_chdir_path (fileview, dir, error);
g_free (dir);
return result;
}
gboolean
moo_file_view_chdir_path (MooFileView *fileview,
const char *path,
GError **error)
{
gboolean result;
moo_return_error_if_fail (MOO_IS_FILE_VIEW (fileview));
g_signal_emit (fileview, signals[CHDIR], 0, path, error, &result);
return result;
}
/* TODO */
static void
moo_file_view_go_up (MooFileView *fileview)
{
MooFolder *parent = NULL;
if (fileview->priv->entry_state)
stop_path_entry (fileview, TRUE);
if (fileview->priv->view_type == MOO_FILE_VIEW_BOOKMARK)
{
view_files (fileview);
return;
}
if (fileview->priv->current_dir)
parent = _moo_folder_get_parent (fileview->priv->current_dir,
MOO_FILE_HAS_ICON);
if (!parent)
parent = _moo_file_system_get_root_folder (fileview->priv->file_system,
MOO_FILE_HAS_ICON);
g_return_if_fail (parent != NULL);
if (parent != fileview->priv->current_dir)
{
const char *path = _moo_folder_get_path (parent);
char *name = g_path_get_basename (_moo_folder_get_path (fileview->priv->current_dir));
if (moo_file_view_chdir_path (fileview, path, NULL))
_moo_file_view_select_name (fileview, name);
g_free (name);
}
g_object_unref (parent);
}
static void
moo_file_view_go_home (MooFileView *fileview)
{
GError *error = NULL;
if (fileview->priv->entry_state)
stop_path_entry (fileview, TRUE);
if (!moo_file_view_chdir_path (fileview, moo_file_view_get_home_dir (fileview), &error))
{
g_warning ("could not go home: %s", moo_error_message (error));
g_error_free (error);
}
}
static void
file_list_row_activated (MooFileView *fileview,
GtkTreePath *filter_path)
{
MooFile *file = NULL;
GtkTreeIter iter;
if (!gtk_tree_model_get_iter (fileview->priv->filter_model,
&iter, filter_path))
{
g_return_if_reached ();
}
gtk_tree_model_get (fileview->priv->filter_model,
&iter, COLUMN_FILE, &file, -1);
g_return_if_fail (file != NULL);
if (!strcmp (_moo_file_name (file), ".."))
{
g_signal_emit_by_name (fileview, "go-up");
}
else if (MOO_FILE_IS_DIR (file))
{
GError *error = NULL;
if (!moo_file_view_chdir_path (fileview, _moo_file_name (file), &error))
{
g_warning ("could not go into '%s': %s",
_moo_file_name (file),
moo_error_message (error));
g_error_free (error);
_moo_folder_check_exists (fileview->priv->current_dir,
_moo_file_name (file));
}
}
else
{
char *path;
g_assert (fileview->priv->current_dir != NULL);
path = g_build_filename (_moo_folder_get_path (fileview->priv->current_dir),
_moo_file_name (file), NULL);
g_signal_emit (fileview, signals[ACTIVATE], 0, path);
g_free (path);
}
_moo_file_unref (file);
}
struct History {
GSList *back;
GSList *fwd;
char *current;
guint block;
};
static void
history_init (MooFileView *fileview)
{
fileview->priv->history = g_new0 (History, 1);
}
static void
history_clear (MooFileView *fileview)
{
g_slist_foreach (fileview->priv->history->back, (GFunc) g_free, NULL);
g_slist_foreach (fileview->priv->history->fwd, (GFunc) g_free, NULL);
g_slist_free (fileview->priv->history->back);
g_slist_free (fileview->priv->history->fwd);
fileview->priv->history->back = NULL;
fileview->priv->history->fwd = NULL;
g_free (fileview->priv->history->current);
fileview->priv->history->current = NULL;
}
static void
history_free (MooFileView *fileview)
{
history_clear (fileview);
g_free (fileview->priv->history);
fileview->priv->history = NULL;
}
static const char*
history_get (MooFileView *fileview,
int where)
{
History *hist = fileview->priv->history;
g_assert (where == 1 || where == -1);
if (where == 1)
{
if (!hist->fwd)
return NULL;
else
return hist->fwd->data;
}
else
{
if (!hist->back)
return NULL;
else
return hist->back->data;
}
}
static void
history_go (MooFileView *fileview,
int where)
{
History *hist = fileview->priv->history;
char *tmp;
GSList **pop_from, **push_to;
gboolean could_go_forward, could_go_back;
gboolean can_go_forward, can_go_back;
g_assert (where == 1 || where == -1);
g_assert (hist->current != NULL);
could_go_forward = hist->fwd != NULL;
could_go_back = hist->back != NULL;
if (where == 1)
{
if (!hist->fwd)
return;
pop_from = &hist->fwd;
push_to = &hist->back;
}
else
{
if (!hist->back)
return;
pop_from = &hist->back;
push_to = &hist->fwd;
}
tmp = (*pop_from)->data;
*pop_from = g_slist_delete_link (*pop_from, *pop_from);
*push_to = g_slist_prepend (*push_to, hist->current);
hist->current = tmp;
can_go_forward = hist->fwd != NULL;
can_go_back = hist->back != NULL;
g_object_freeze_notify (G_OBJECT (fileview));
if (could_go_forward != can_go_forward)
g_object_notify (G_OBJECT (fileview), "can-go-forward");
if (could_go_back != can_go_back)
g_object_notify (G_OBJECT (fileview), "can-go-back");
g_object_thaw_notify (G_OBJECT (fileview));
}
static void
history_add (MooFileView *fileview,
const char *dirname)
{
History *hist = fileview->priv->history;
gboolean could_go_forward = FALSE, could_go_back, can_go_back;
g_return_if_fail (dirname != NULL);
if (hist->block)
return;
/* XXX strcmp */
if (hist->current && !strcmp (dirname, hist->current))
return;
if (hist->fwd)
{
could_go_forward = TRUE;
g_slist_foreach (hist->fwd, (GFunc) g_free, NULL);
g_slist_free (hist->fwd);
hist->fwd = NULL;
}
could_go_back = hist->back != NULL;
if (hist->current)
{
hist->back = g_slist_prepend (hist->back, hist->current);
hist->current = g_strdup (dirname);
}
else
{
hist->current = g_strdup (dirname);
}
can_go_back = hist->back != NULL;
g_object_freeze_notify (G_OBJECT (fileview));
if (could_go_back != can_go_back)
g_object_notify (G_OBJECT (fileview), "can-go-back");
if (could_go_forward)
g_object_notify (G_OBJECT (fileview), "can-go-forward");
g_object_thaw_notify (G_OBJECT (fileview));
}
static void
moo_file_view_go (MooFileView *fileview,
int where)
{
const char *dir;
GError *error = NULL;
g_assert (where == 1 || where == -1);
if (fileview->priv->entry_state)
stop_path_entry (fileview, TRUE);
if (fileview->priv->view_type == MOO_FILE_VIEW_BOOKMARK)
{
view_files (fileview);
return;
}
dir = history_get (fileview, where);
if (dir)
{
fileview->priv->history->block++;
if (!moo_file_view_chdir_path (fileview, dir, &error))
{
g_warning ("could not go into '%s': %s", dir, moo_error_message (error));
g_error_free (error);
}
else
{
history_go (fileview, where);
}
fileview->priv->history->block--;
}
}
static void
moo_file_view_go_back (MooFileView *fileview)
{
moo_file_view_go (fileview, -1);
}
static void
moo_file_view_go_forward (MooFileView *fileview)
{
moo_file_view_go (fileview, 1);
}
static void
moo_file_view_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MooFileView *fileview = MOO_FILE_VIEW (object);
switch (prop_id)
{
case PROP_CURRENT_DIRECTORY:
moo_file_view_chdir_path (fileview, g_value_get_string (value), NULL);
break;
case PROP_HOME_DIRECTORY:
MOO_ASSIGN_STRING (fileview->priv->home_dir, g_value_get_string (value));
g_object_notify (object, "home-directory");
break;
case PROP_BOOKMARK_MGR:
moo_file_view_set_bookmark_mgr (fileview, g_value_get_object (value));
break;
case PROP_SORT_CASE_SENSITIVE:
_moo_file_view_set_sort_case_sensitive (fileview, g_value_get_boolean (value));
break;
case PROP_SORT_FOLDERS_FIRST:
_moo_file_view_set_sort_folders_first (fileview, g_value_get_boolean (value));
break;
case PROP_TYPEAHEAD_CASE_SENSITIVE:
_moo_file_view_set_typeahead_case_sensitive (fileview, g_value_get_boolean (value));
break;
case PROP_COMPLETION_CASE_SENSITIVE:
g_object_set (MOO_FILE_ENTRY(fileview->priv->entry)->completion,
"case-sensitive", g_value_get_boolean (value), NULL);
g_object_notify (object, "completion-case-sensitive");
break;
case PROP_SHOW_HIDDEN_FILES:
_moo_file_view_set_show_hidden (fileview, g_value_get_boolean (value));
break;
case PROP_SHOW_PARENT_FOLDER:
_moo_file_view_set_show_parent (fileview, g_value_get_boolean (value));
break;
case PROP_VIEW_TYPE:
_moo_file_view_set_view_type (fileview, g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
moo_file_view_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MooFileView *fileview = MOO_FILE_VIEW (object);
gboolean val;
switch (prop_id)
{
case PROP_CURRENT_DIRECTORY:
if (fileview->priv->current_dir)
g_value_set_string (value, _moo_folder_get_path (fileview->priv->current_dir));
else
g_value_set_string (value, NULL);
break;
case PROP_HOME_DIRECTORY:
g_value_set_string (value, moo_file_view_get_home_dir (fileview));
break;
case PROP_BOOKMARK_MGR:
g_value_set_object (value, fileview->priv->bookmark_mgr);
break;
case PROP_SORT_CASE_SENSITIVE:
g_value_set_boolean (value, SORT_FLAG_SET (MOO_FOLDER_MODEL_SORT_CASE_SENSITIVE));
break;
case PROP_SORT_FOLDERS_FIRST:
g_value_set_boolean (value, SORT_FLAG_SET (MOO_FOLDER_MODEL_SORT_FOLDERS_FIRST));
break;
case PROP_TYPEAHEAD_CASE_SENSITIVE:
g_value_set_boolean (value, fileview->priv->typeahead_case_sensitive);
break;
case PROP_COMPLETION_CASE_SENSITIVE:
g_object_get (MOO_FILE_ENTRY(fileview->priv->entry)->completion,
"case-sensitive", &val, NULL);
g_value_set_boolean (value, val);
break;
case PROP_HAS_SELECTION:
if (fileview->priv->current_dir)
g_value_set_boolean (value,
!_moo_tree_view_selection_is_empty (fileview->priv->view));
else
g_value_set_boolean (value, FALSE);
break;
case PROP_CAN_GO_BACK:
g_value_set_boolean (value, history_get (fileview, -1) != NULL);
break;
case PROP_CAN_GO_FORWARD:
g_value_set_boolean (value, history_get (fileview, 1) != NULL);
break;
case PROP_SHOW_HIDDEN_FILES:
g_value_set_boolean (value, fileview->priv->show_hidden_files);
break;
case PROP_SHOW_PARENT_FOLDER:
g_value_set_boolean (value, fileview->priv->show_two_dots);
break;
case PROP_VIEW_TYPE:
g_value_set_enum (value, fileview->priv->file_view_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static const char *
moo_file_view_get_home_dir (MooFileView *fileview)
{
if (!fileview->priv->home_dir)
{
const char *dir = NULL;
#ifdef __WIN32__
dir = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
if (!dir)
dir = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
#endif
if (!dir)
dir = g_get_home_dir ();
fileview->priv->home_dir = g_strdup (dir);
}
return fileview->priv->home_dir;
}
/*****************************************************************************/
/* Clipboard
*/
static void
edit_ops_do_op (MooEditOps *obj,
MooEditOpType type)
{
MooFileView *fileview = MOO_FILE_VIEW (obj);
switch (type)
{
case MOO_EDIT_OP_CUT:
g_signal_emit_by_name (fileview, "cut-clipboard");
break;
case MOO_EDIT_OP_COPY:
g_signal_emit_by_name (fileview, "copy-clipboard");
break;
case MOO_EDIT_OP_PASTE:
g_signal_emit_by_name (fileview, "paste-clipboard");
break;
case MOO_EDIT_OP_DELETE:
g_signal_emit_by_name (fileview, "delete-selected");
break;
case MOO_EDIT_OP_SELECT_ALL:
_moo_icon_view_select_all (fileview->priv->iconview);
break;
}
}
static gboolean
edit_ops_can_do_op (MooEditOps *obj,
MooEditOpType type)
{
MooFileView *fileview = MOO_FILE_VIEW (obj);
switch (type)
{
case MOO_EDIT_OP_CUT:
return !_moo_tree_view_selection_is_empty (fileview->priv->view);
case MOO_EDIT_OP_COPY:
return !_moo_tree_view_selection_is_empty (fileview->priv->view);
case MOO_EDIT_OP_PASTE:
return TRUE;
case MOO_EDIT_OP_DELETE:
return !_moo_tree_view_selection_is_empty (fileview->priv->view);
case MOO_EDIT_OP_SELECT_ALL:
return TRUE;
}
g_return_val_if_reached (FALSE);
}
static void
edit_ops_iface_init (MooEditOpsIface *iface)
{
iface->do_op = edit_ops_do_op;
iface->can_do_op = edit_ops_can_do_op;
}
enum {
CB_TARGET_CLIPBOARD = 1,
CB_TARGET_URI_LIST = 2,
CB_TARGET_TEXT = 3
};
static GtkTargetEntry clipboard_targets[] = {
{(char*) "MOO_FILE_VIEW_CLIPBOARD", GTK_TARGET_SAME_APP, CB_TARGET_CLIPBOARD},
{(char*) "text/uri-list", 0, CB_TARGET_URI_LIST},
{(char*) "UTF8_STRING", 0, CB_TARGET_TEXT},
{(char*) "TEXT", 0, CB_TARGET_TEXT},
{(char*) "COMPOUND_TEXT", 0, CB_TARGET_TEXT},
{(char*) "text/plain", 0, CB_TARGET_TEXT},
{(char*) "text/plain;charset=utf-8", 0, CB_TARGET_TEXT},
{(char*) "GDK_TARGET_STRING", 0, CB_TARGET_TEXT}
};
static void
moo_file_view_unrealize (GtkWidget *widget)
{
file_view_clear_clipboard (MOO_FILE_VIEW (widget));
GTK_WIDGET_CLASS(moo_file_view_parent_class)->unrealize (widget);
}
static Clipboard *
clipboard_new (MooFolder *folder,
FileList *files,
gboolean cut)
{
Clipboard *cb;
g_return_val_if_fail (MOO_IS_FOLDER (folder), NULL);
cb = g_new0 (Clipboard, 1);
cb->folder = g_object_ref (folder);
cb->files = file_list_copy (files);
cb->cut = cut != 0;
return cb;
}
static void
clipboard_free (Clipboard *cb)
{
if (cb)
{
g_object_unref (cb->folder);
file_list_free (cb->files);
g_free (cb);
}
}
static void
file_view_clear_clipboard (MooFileView *fileview)
{
if (fileview->priv->clipboard)
{
GtkClipboard *cb = gtk_widget_get_clipboard (GTK_WIDGET (fileview),
GDK_SELECTION_CLIPBOARD);
if (gtk_clipboard_get_owner (cb) == G_OBJECT (fileview))
gtk_clipboard_clear (cb);
if (fileview->priv->clipboard)
{
clipboard_free (fileview->priv->clipboard);
fileview->priv->clipboard = NULL;
}
}
}
static gboolean
file_view_file_is_cut (MooFileView *fileview,
MooFile *file)
{
FileList *l;
Clipboard *cb = fileview->priv->clipboard;
if (!cb || !cb->cut || fileview->priv->current_dir != cb->folder)
return FALSE;
for (l = cb->files; l != NULL; l = l->next)
if (strcmp (_moo_file_name (file), _moo_file_name (l->data)) == 0)
return TRUE;
return FALSE;
}
static void
clear_clipboard_cb (G_GNUC_UNUSED GtkClipboard *clipboard,
MooFileView *fileview)
{
clipboard_free (fileview->priv->clipboard);
fileview->priv->clipboard = NULL;
gtk_widget_queue_draw (GTK_WIDGET (fileview));
}
static void
set_selection_data_from_clipboard (GtkSelectionData *data,
Clipboard *cb)
{
FileList *l;
char **uris;
int n_uris, i;
n_uris = file_list_length (cb->files);
g_return_if_fail (n_uris > 0);
uris = g_new0 (char*, n_uris + 1);
for (i = 0, l = cb->files; l != NULL; l = l->next, ++i)
uris[i] = _moo_folder_get_file_uri (cb->folder, l->data);
gtk_selection_data_set_uris (data, uris);
g_strfreev (uris);
}
static void
set_text_from_clipboard (GtkSelectionData *data,
Clipboard *cb)
{
FileList *l;
GString *str;
str = g_string_new (NULL);
for (l = cb->files; l != NULL; l = l->next)
{
char *path;
char *display_path;
path = _moo_folder_get_file_path (cb->folder, l->data);
g_return_if_fail (path != NULL);
display_path = g_filename_display_name (path);
g_return_if_fail (display_path != NULL);
if (str->len != 0)
g_string_append_c (str, '\n');
g_string_append (str, display_path);
g_free (display_path);
g_free (path);
}
gtk_selection_data_set_text (data, str->str, str->len);
g_string_free (str, TRUE);
}
static void
get_clipboard_cb (G_GNUC_UNUSED GtkClipboard *clipboard,
GtkSelectionData *selection_data,
guint info,
MooFileView *fileview)
{
g_return_if_fail (fileview->priv->clipboard != NULL);
switch (info)
{
case CB_TARGET_CLIPBOARD:
moo_selection_data_set_pointer (selection_data,
CLIPBOARD_ATOM,
fileview);
break;
case CB_TARGET_URI_LIST:
set_selection_data_from_clipboard (selection_data,
fileview->priv->clipboard);
break;
case CB_TARGET_TEXT:
set_text_from_clipboard (selection_data,
fileview->priv->clipboard);
break;
default:
g_return_if_reached ();
}
}
static void
file_view_cut_or_copy_clipboard (MooFileView *fileview,
gboolean cut)
{
FileList *files;
MooFolder *folder;
gboolean result;
GtkClipboard *clipboard;
g_return_if_fail (GTK_WIDGET_REALIZED (fileview));
folder = fileview->priv->current_dir;
files = file_view_get_selected_files (fileview);
if (!folder || !files)
return;
if (fileview->priv->clipboard)
{
clipboard_free (fileview->priv->clipboard);
fileview->priv->clipboard = NULL;
}
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (fileview),
GDK_SELECTION_CLIPBOARD);
result = gtk_clipboard_set_with_owner (clipboard, clipboard_targets,
G_N_ELEMENTS (clipboard_targets),
(GtkClipboardGetFunc) get_clipboard_cb,
(GtkClipboardClearFunc) clear_clipboard_cb,
G_OBJECT (fileview));
if (result)
fileview->priv->clipboard = clipboard_new (folder, files, cut);
gtk_widget_queue_draw (GTK_WIDGET (fileview));
file_list_free (files);
}
static void
file_view_cut_clipboard (MooFileView *fileview)
{
file_view_cut_or_copy_clipboard (fileview, TRUE);
}
static void
file_view_copy_clipboard (MooFileView *fileview)
{
file_view_cut_or_copy_clipboard (fileview, FALSE);
}
static void
file_view_paste_clipboard (MooFileView *fileview)
{
GtkClipboard *clipboard;
GtkSelectionData *data = NULL;
g_return_if_fail (fileview->priv->current_dir != NULL);
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (fileview),
GDK_SELECTION_CLIPBOARD);
data = gtk_clipboard_wait_for_contents (clipboard, CLIPBOARD_ATOM);
if (data)
{
Clipboard *cb;
MooFileView *remote;
FileList *l;
GList *filenames;
const char *destdir;
remote = moo_selection_data_get_pointer (data, CLIPBOARD_ATOM);
g_return_if_fail (remote != NULL);
cb = remote->priv->clipboard;
if (cb->folder == fileview->priv->current_dir)
goto out;
for (filenames = NULL, l = cb->files; l != NULL; l = l->next)
{
MooFile *file = l->data;
char *path = _moo_folder_get_file_path (cb->folder, file);
if (path)
filenames = g_list_prepend (filenames, path);
}
filenames = g_list_reverse (filenames);
destdir = _moo_folder_get_path (fileview->priv->current_dir);
if (cb->cut)
{
remote->priv->clipboard = NULL;
gtk_clipboard_clear (clipboard);
move_files (fileview, filenames, destdir);
clipboard_free (cb);
}
else
{
copy_files (fileview, filenames, destdir);
}
g_list_foreach (filenames, (GFunc) g_free, NULL);
g_list_free (filenames);
goto out;
}
data = gtk_clipboard_wait_for_contents (clipboard, moo_atom_uri_list ());
if (data)
{
char **uris = gtk_selection_data_get_uris (data);
GList *filenames;
char **u;
const char *destdir;
for (u = uris, filenames = NULL; u && *u; u++)
{
char *name = g_filename_from_uri (*u, NULL, NULL);
if (name)
filenames = g_list_prepend (filenames, name);
}
filenames = g_list_reverse (filenames);
destdir = _moo_folder_get_path (fileview->priv->current_dir);
if (filenames)
copy_files (fileview, filenames, destdir);
g_strfreev (uris);
g_list_foreach (filenames, (GFunc) g_free, NULL);
g_list_free (filenames);
goto out;
}
out:
if (data)
gtk_selection_data_free (data);
}
/*****************************************************************************/
/* Sorting and stuff
*/
static void
_moo_file_view_set_sort_case_sensitive (MooFileView *fileview,
gboolean case_sensitive)
{
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
if (case_sensitive != SORT_FLAG_SET (MOO_FOLDER_MODEL_SORT_CASE_SENSITIVE))
{
if (case_sensitive)
fileview->priv->sort_flags |= MOO_FOLDER_MODEL_SORT_CASE_SENSITIVE;
else
fileview->priv->sort_flags &= ~MOO_FOLDER_MODEL_SORT_CASE_SENSITIVE;
_moo_folder_model_set_sort_flags (MOO_FOLDER_MODEL (fileview->priv->model),
fileview->priv->sort_flags);
g_object_notify (G_OBJECT (fileview), "sort-case-sensitive");
}
}
static void
_moo_file_view_set_sort_folders_first (MooFileView *fileview,
gboolean folders_first)
{
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
if (folders_first != SORT_FLAG_SET (MOO_FOLDER_MODEL_SORT_FOLDERS_FIRST))
{
if (folders_first)
fileview->priv->sort_flags |= MOO_FOLDER_MODEL_SORT_FOLDERS_FIRST;
else
fileview->priv->sort_flags &= ~MOO_FOLDER_MODEL_SORT_FOLDERS_FIRST;
_moo_folder_model_set_sort_flags (MOO_FOLDER_MODEL (fileview->priv->model),
fileview->priv->sort_flags);
g_object_notify (G_OBJECT (fileview), "sort-folders-first");
}
}
/*****************************************************************************/
/* Filters
*/
static void
block_filter_signals (MooFileView *fileview)
{
g_signal_handlers_block_by_func (fileview->priv->filter_combo,
(gpointer) filter_button_toggled,
fileview);
g_signal_handlers_block_by_func (fileview->priv->filter_combo,
(gpointer) filter_combo_changed,
fileview);
g_signal_handlers_block_by_func (fileview->priv->filter_combo,
(gpointer) filter_entry_activate,
fileview);
}
static void
unblock_filter_signals (MooFileView *fileview)
{
g_signal_handlers_unblock_by_func (fileview->priv->filter_combo,
(gpointer) filter_button_toggled,
fileview);
g_signal_handlers_unblock_by_func (fileview->priv->filter_combo,
(gpointer) filter_combo_changed,
fileview);
g_signal_handlers_unblock_by_func (fileview->priv->filter_combo,
(gpointer) filter_entry_activate,
fileview);
}
static void
init_filter_combo (MooFileView *fileview)
{
MooFilterMgr *mgr;
GtkFileFilter *filter;
mgr = moo_filter_mgr_default ();
fileview->priv->filter_mgr = g_object_ref (mgr);
block_filter_signals (fileview);
moo_filter_mgr_init_filter_combo (mgr, fileview->priv->filter_combo,
"MooFileView");
if (fileview->priv->current_filter)
g_object_unref (fileview->priv->current_filter);
fileview->priv->current_filter = NULL;
fileview->priv->use_current_filter = FALSE;
gtk_toggle_button_set_active (fileview->priv->filter_button, FALSE);
gtk_entry_set_text (fileview->priv->filter_entry, "");
unblock_filter_signals (fileview);
filter = moo_filter_mgr_get_last_filter (mgr, "MooFileView");
if (filter)
fileview_set_filter (fileview, filter);
}
static void
filter_button_toggled (MooFileView *fileview)
{
gboolean active =
gtk_toggle_button_get_active (fileview->priv->filter_button);
if (active == fileview->priv->use_current_filter)
return;
/* TODO check entry content */
fileview_set_use_filter (fileview, active, TRUE);
moo_file_view_focus_files (fileview);
}
static void
filter_combo_changed (MooFileView *fileview)
{
GtkTreeIter iter;
GtkFileFilter *filter;
MooFilterMgr *mgr = fileview->priv->filter_mgr;
GtkComboBox *combo = fileview->priv->filter_combo;
if (!gtk_combo_box_get_active_iter (combo, &iter))
return;
filter = moo_filter_mgr_get_filter (mgr, &iter, "MooFileView");
g_return_if_fail (filter != NULL);
moo_filter_mgr_set_last_filter (mgr, &iter, "MooFileView");
fileview_set_filter (fileview, filter);
moo_file_view_focus_files (fileview);
}
static void
filter_entry_activate (MooFileView *fileview)
{
const char *text;
GtkFileFilter *filter;
MooFilterMgr *mgr = fileview->priv->filter_mgr;
text = gtk_entry_get_text (fileview->priv->filter_entry);
if (text && text[0])
filter = moo_filter_mgr_new_user_filter (mgr, text, "MooFileView");
else
filter = NULL;
fileview_set_filter (fileview, filter);
moo_file_view_focus_files (fileview);
}
static void
fileview_set_filter (MooFileView *fileview,
GtkFileFilter *filter)
{
GtkFileFilter *null_filter;
if (filter && filter == fileview->priv->current_filter)
{
fileview_set_use_filter (fileview, TRUE, TRUE);
return;
}
null_filter = moo_filter_mgr_get_null_filter (fileview->priv->filter_mgr);
g_return_if_fail (null_filter != NULL);
if (filter == null_filter)
{
fileview_set_filter (fileview, NULL);
return;
}
if (filter && (gtk_file_filter_get_needed (filter) & GTK_FILE_FILTER_URI))
{
g_warning ("The filter set wants uri, but i do not know "
"how to work with uri's. Ignoring");
return;
}
block_filter_signals (fileview);
if (fileview->priv->current_filter)
g_object_unref (fileview->priv->current_filter);
fileview->priv->current_filter = filter;
if (filter)
{
const char *name;
g_object_ref_sink (filter);
name = gtk_file_filter_get_name (filter);
gtk_entry_set_text (fileview->priv->filter_entry, name);
fileview_set_use_filter (fileview, TRUE, FALSE);
}
else
{
gtk_entry_set_text (fileview->priv->filter_entry, "");
fileview_set_use_filter (fileview, FALSE, FALSE);
}
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER
(fileview->priv->filter_model));
unblock_filter_signals (fileview);
}
static void
fileview_set_use_filter (MooFileView *fileview,
gboolean use,
gboolean block_signals)
{
if (block_signals)
block_filter_signals (fileview);
gtk_toggle_button_set_active (fileview->priv->filter_button, use);
if (fileview->priv->use_current_filter != use)
{
if (fileview->priv->current_filter)
{
fileview->priv->use_current_filter = use;
if (block_signals)
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER
(fileview->priv->filter_model));
}
else
{
fileview->priv->use_current_filter = FALSE;
gtk_toggle_button_set_active (fileview->priv->filter_button, FALSE);
}
}
if (block_signals)
unblock_filter_signals (fileview);
}
/*****************************************************************************/
/* File manager functionality
*/
GList *
_moo_file_view_get_filenames (MooFileView *fileview)
{
FileList *files;
GList *names = NULL;
MooFolder *folder;
g_return_val_if_fail (MOO_IS_FILE_VIEW (fileview), NULL);
folder = fileview->priv->current_dir;
g_return_val_if_fail (folder != NULL, NULL);
files = file_view_get_selected_files (fileview);
while (files)
{
names = g_list_prepend (names, _moo_folder_get_file_path (folder, files->data));
_moo_file_unref (files->data);
files = file_list_delete_link (files, files);
}
return g_list_reverse (names);
}
GList *
_moo_file_view_get_files (MooFileView *fileview)
{
return file_list_to_glist (file_view_get_selected_files (fileview));
}
/* path in the filter model; result must be unrefed */
static MooFile *
file_view_get_file_at_path (MooFileView *fileview,
GtkTreePath *path)
{
GtkTreeIter iter;
MooFile *file = NULL;
g_return_val_if_fail (path != NULL, NULL);
gtk_tree_model_get_iter (fileview->priv->filter_model, &iter, path);
gtk_tree_model_get (fileview->priv->filter_model, &iter, COLUMN_FILE, &file, -1);
return file;
}
static void
prepend_file (GtkTreeModel *model,
G_GNUC_UNUSED GtkTreePath *path,
GtkTreeIter *iter,
gpointer user_data)
{
FileList **list = user_data;
MooFile *file = NULL;
gtk_tree_model_get (model, iter, COLUMN_FILE, &file, -1);
if (file)
*list = file_list_prepend (*list, file);
}
/* returned files must be unrefed and list freed */
static FileList *
file_view_get_selected_files (MooFileView *fileview)
{
FileList *files = NULL;
_moo_tree_view_selected_foreach (fileview->priv->view,
prepend_file, &files);
return files;
}
static gboolean
ask_delete_files (MooFileView *fileview,
FileList *files,
gboolean trash)
{
gboolean one;
char *primary = NULL;
char *secondary = NULL;
GtkWidget *dialog;
int response;
one = (files->next == NULL);
if (trash)
{
if (one)
{
if (MOO_FILE_IS_DIR (files->data) && !MOO_FILE_IS_LINK (files->data))
primary = g_strdup_printf (_("Move folder %s to Trash?"),
_moo_file_display_name (files->data));
else
primary = g_strdup_printf (_("Move file %s to Trash?"),
_moo_file_display_name (files->data));
}
else
{
primary = g_strdup (_("Move selected files to Trash?"));
}
}
else
{
if (one)
{
if (MOO_FILE_IS_DIR (files->data) && !MOO_FILE_IS_LINK (files->data))
primary = g_strdup_printf (_("Delete folder %s and all its content?"),
_moo_file_display_name (files->data));
else
primary = g_strdup_printf (_("Delete file %s?"),
_moo_file_display_name (files->data));
}
else
{
primary = g_strdup (_("Delete selected files?"));
}
}
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE,
"%s", primary);
if (secondary)
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
"%s", secondary);
moo_window_set_parent (dialog, GTK_WIDGET (fileview));
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_DELETE, GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_free (secondary);
g_free (primary);
return response == GTK_RESPONSE_OK;
}
static void
file_view_do_delete_selected (MooFileView *fileview,
gboolean trash)
{
FileList *files, *l;
if (!fileview->priv->current_dir)
return;
files = file_view_get_selected_files (fileview);
if (!files)
return;
if (ask_delete_files (fileview, files, trash))
{
for (l = files; l != NULL; l = l->next)
{
char *path = g_build_filename (_moo_folder_get_path (fileview->priv->current_dir),
_moo_file_name (l->data), NULL);
MooDeleteFileFlags flags = MOO_DELETE_RECURSIVE;
GError *error = NULL;
if (trash)
flags |= MOO_DELETE_TO_TRASH;
if (!_moo_file_system_delete_file (fileview->priv->file_system, path, flags, &error))
{
char *text;
char *path_utf8;
path_utf8 = g_filename_display_name (path);
if (MOO_FILE_IS_DIR (l->data))
text = g_strdup_printf (_("Could not delete folder %s"),
path_utf8);
else
text = g_strdup_printf (_("Could not delete file %s"),
path_utf8);
moo_error_dialog (text,
moo_error_message (error),
GTK_WIDGET (fileview));
g_free (path_utf8);
g_free (text);
}
g_free (path);
if (error)
g_error_free (error);
}
}
file_list_free (files);
}
static void
file_view_delete_selected (MooFileView *fileview)
{
gboolean trash = TRUE;
GdkModifierType mods = _moo_get_modifiers (GTK_WIDGET (fileview));
if (mods & GDK_SHIFT_MASK)
trash = FALSE;
file_view_do_delete_selected (fileview, trash);
}
static void
file_view_delete_selected_cb (GtkAction *action,
MooFileView *fileview)
{
gboolean trash = FALSE;
if (g_object_get_data (G_OBJECT (action), "moo-file-view-trash-selected"))
trash = TRUE;
file_view_do_delete_selected (fileview, trash);
}
static void
update_delete_action (MooFileView *fileview,
GtkWidget *menu)
{
gboolean trash = FALSE;
GtkAction *action;
GdkModifierType mods;
action = moo_action_collection_get_action (fileview->priv->actions, "Delete");
g_return_if_fail (action != NULL);
if (menu)
mods = _moo_get_modifiers (menu);
else
mods = _moo_get_modifiers (GTK_WIDGET (fileview));
if (!(mods & GDK_SHIFT_MASK))
trash = TRUE;
if (trash)
g_object_set (action,
"label", _("Move to Trash..."),
"tooltip", _("Move selected files to Trash"),
"stock-id", GTK_STOCK_DELETE,
NULL);
else
g_object_set (action,
"label", _("Delete..."),
"tooltip", _("Delete selected files"),
"stock-id", GTK_STOCK_DELETE,
NULL);
g_object_set_data (G_OBJECT (action),
"moo-file-view-trash-selected",
GINT_TO_POINTER (trash));
}
static void
file_view_create_folder (MooFileView *fileview)
{
GError *error = NULL;
char *path, *name;
if (!fileview->priv->current_dir)
return;
name = _moo_file_view_create_folder_dialog (GTK_WIDGET (fileview),
fileview->priv->current_dir);
if (!name || !name[0])
{
g_free (name);
return;
}
path = _moo_file_system_make_path (fileview->priv->file_system,
_moo_folder_get_path (fileview->priv->current_dir),
name, &error);
if (!path)
{
_moo_message ("could not make path for '%s': %s", name, moo_error_message (error));
goto out;
}
if (!_moo_file_system_create_folder (fileview->priv->file_system, path, &error))
{
_moo_message ("could not create folder '%s': %s", name, moo_error_message (error));
goto out;
}
_moo_file_view_select_display_name (fileview, name);
out:
if (error)
g_error_free (error);
g_free (path);
g_free (name);
}
static void
props_dialog_destroyed (GtkWidget *dialog,
MooFileView *fileview)
{
g_signal_handlers_disconnect_by_func (dialog,
(gpointer) props_dialog_destroyed,
fileview);
if (fileview->priv->props_dialog == dialog)
fileview->priv->props_dialog = NULL;
}
/* XXX */
static void
file_view_properties_dialog (MooFileView *fileview)
{
FileList *files;
if (!fileview->priv->current_dir)
return;
files = file_view_get_selected_files (fileview);
if (!files)
{
g_print ("no files\n");
return;
}
if (files->next)
{
g_print ("many files\n");
file_list_free (files);
return;
}
if (!fileview->priv->props_dialog)
{
fileview->priv->props_dialog = _moo_file_props_dialog_new (GTK_WIDGET (fileview));
g_signal_connect (fileview->priv->props_dialog, "destroy",
G_CALLBACK (props_dialog_destroyed), fileview);
}
_moo_file_props_dialog_set_file (fileview->priv->props_dialog,
files->data,
fileview->priv->current_dir);
gtk_window_present (GTK_WINDOW (fileview->priv->props_dialog));
file_list_free (files);
}
/*****************************************************************************/
/* Popup menu
*/
/* TODO */
static void
menu_position_func (G_GNUC_UNUSED GtkMenu *menu,
gint *x,
gint *y,
gboolean *push_in,
gpointer user_data)
{
GdkWindow *window;
struct {
MooFileView *fileview;
GList *rows;
} *data = user_data;
window = GTK_WIDGET(data->fileview)->window;
gdk_window_get_origin (window, x, y);
*push_in = TRUE;
}
static void
do_popup (MooFileView *fileview,
GdkEventButton *event,
GList *selected)
{
GtkWidget *menu;
FileList *files = NULL;
GList *l;
struct {
MooFileView *fileview;
GList *rows;
} position_data;
for (l = selected; l != NULL; l = l->next)
{
GtkTreeIter iter;
MooFile *file = NULL;
gtk_tree_model_get_iter (fileview->priv->filter_model, &iter, l->data);
gtk_tree_model_get (fileview->priv->filter_model, &iter,
COLUMN_FILE, &file, -1);
if (file)
files = file_list_prepend (files, file);
}
menu = moo_ui_xml_create_widget (fileview->priv->ui_xml,
MOO_UI_MENU, "MooFileView/Menu",
fileview->priv->actions,
NULL);
g_object_ref_sink (menu);
g_signal_connect_swapped (menu, "alternate-toggled",
G_CALLBACK (update_delete_action),
fileview);
update_delete_action (fileview, NULL);
_moo_file_view_tools_check (fileview);
g_signal_emit (fileview, signals[POPULATE_POPUP], 0, files, menu);
position_data.fileview = fileview;
position_data.rows = selected;
if (event)
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
event->button, event->time);
else
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
menu_position_func,
&position_data, 0,
gtk_get_current_event_time ());
g_object_unref (menu);
file_list_free (files);
}
static gboolean
moo_file_view_popup_menu (GtkWidget *widget)
{
GList *selected;
MooFileView *fileview = MOO_FILE_VIEW (widget);
selected = _moo_tree_view_get_selected_rows (fileview->priv->view);
do_popup (fileview, NULL, selected);
g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
g_list_free (selected);
return TRUE;
}
static gboolean
file_list_button_press (MooFileView *fileview,
G_GNUC_UNUSED GtkWidget *widget,
GdkEventButton *event,
MooTreeView *view)
{
GtkTreePath *filter_path = NULL;
GList *selected;
if (event->button != 3)
return FALSE;
if (_moo_tree_view_get_path_at_pos (view, (int) event->x, (int) event->y, &filter_path))
{
if (!_moo_tree_view_path_is_selected (view, filter_path))
{
_moo_tree_view_unselect_all (view);
_moo_tree_view_set_cursor (view, filter_path, FALSE);
}
}
else
{
_moo_tree_view_unselect_all (view);
}
selected = _moo_tree_view_get_selected_rows (view);
do_popup (fileview, event, selected);
gtk_tree_path_free (filter_path);
g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
g_list_free (selected);
return TRUE;
}
static void
_moo_file_view_set_show_hidden (MooFileView *fileview,
gboolean show)
{
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
show = show ? TRUE : FALSE;
if (fileview->priv->show_hidden_files != show)
{
fileview->priv->show_hidden_files = show;
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (
fileview->priv->filter_model));
g_object_notify (G_OBJECT (fileview), "show-hidden-files");
}
}
static void
_moo_file_view_set_show_parent (MooFileView *fileview,
gboolean show)
{
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
show = show ? TRUE : FALSE;
if (fileview->priv->show_two_dots != show)
{
fileview->priv->show_two_dots = show;
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (
fileview->priv->filter_model));
g_object_notify (G_OBJECT (fileview), "show-parent-folder");
}
}
static void
toggle_show_hidden (MooFileView *fileview)
{
_moo_file_view_set_show_hidden (fileview,
!fileview->priv->show_hidden_files);
}
static GtkWidget *
get_view_widget (MooFileView *fileview)
{
switch (fileview->priv->view_type)
{
case MOO_FILE_VIEW_ICON:
return GTK_WIDGET(fileview->priv->iconview);
case MOO_FILE_VIEW_LIST:
return GTK_WIDGET(fileview->priv->treeview);
case MOO_FILE_VIEW_BOOKMARK:
return GTK_WIDGET(fileview->priv->bkview);
}
g_return_val_if_reached (NULL);
}
/*****************************************************************************/
/* Bookmarks menu
*/
static void
moo_file_view_set_bookmark_mgr (MooFileView *fileview,
MooBookmarkMgr *mgr)
{
if (!mgr)
{
mgr = _moo_bookmark_mgr_new ();
moo_file_view_set_bookmark_mgr (fileview, mgr);
g_object_unref (mgr);
return;
}
if (fileview->priv->bookmark_mgr == mgr)
return;
if (fileview->priv->bookmark_mgr)
{
g_signal_handlers_disconnect_by_func (fileview->priv->bookmark_mgr,
(gpointer) bookmark_activate,
fileview);
_moo_bookmark_mgr_remove_user (fileview->priv->bookmark_mgr,
fileview);
g_object_unref (fileview->priv->bookmark_mgr);
}
fileview->priv->bookmark_mgr = g_object_ref (mgr);
_moo_bookmark_mgr_add_user (fileview->priv->bookmark_mgr, fileview,
fileview->priv->actions, fileview->priv->ui_xml,
"MooFileView/Toolbar/BookmarksMenu/Bookmarks");
g_signal_connect (fileview->priv->bookmark_mgr,
"activate", G_CALLBACK (bookmark_activate),
fileview);
_moo_bookmark_view_set_mgr (fileview->priv->bkview, mgr);
g_object_set_data (G_OBJECT (fileview),
"moo-file-view-bookmarks-editor",
NULL);
g_object_notify (G_OBJECT (fileview), "bookmark-mgr");
}
static void
view_bookmarks_handler (MooFileView *fileview)
{
view_bookmarks (fileview);
}
static void
view_bookmarks (MooFileView *fileview)
{
MooFileViewType new_type;
if (fileview->priv->view_type == MOO_FILE_VIEW_BOOKMARK)
new_type = fileview->priv->file_view_type;
else
new_type = MOO_FILE_VIEW_BOOKMARK;
_moo_file_view_set_view_type (fileview, new_type);
}
static void
view_files (MooFileView *fileview)
{
if (fileview->priv->view_type == MOO_FILE_VIEW_BOOKMARK)
_moo_file_view_set_view_type (fileview, fileview->priv->file_view_type);
}
static void
add_bookmark (MooFileView *fileview)
{
const char *path;
char *display_path;
MooBookmark *bookmark;
g_return_if_fail (fileview->priv->current_dir != NULL);
path = _moo_folder_get_path (fileview->priv->current_dir);
display_path = g_filename_display_name (path);
bookmark = _moo_bookmark_new (display_path, path, MOO_STOCK_FOLDER);
_moo_bookmark_mgr_add (fileview->priv->bookmark_mgr,
bookmark);
_moo_bookmark_free (bookmark);
g_free (display_path);
}
static void
edit_bookmarks (MooFileView *fileview)
{
GtkWidget *dialog;
dialog = g_object_get_data (G_OBJECT (fileview),
"moo-file-view-bookmarks-editor");
if (!dialog)
{
dialog = _moo_bookmark_mgr_get_editor (fileview->priv->bookmark_mgr);
g_object_ref_sink (dialog);
g_object_set_data_full (G_OBJECT (fileview),
"moo-file-view-bookmarks-editor",
dialog, g_object_unref);
g_signal_connect (dialog, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
}
moo_window_set_parent (dialog, GTK_WIDGET (fileview));
gtk_window_present (GTK_WINDOW (dialog));
}
static void
bookmark_activate (G_GNUC_UNUSED MooBookmarkMgr *mgr,
MooBookmark *bookmark,
MooFileView *activated,
MooFileView *fileview)
{
if (activated != fileview)
return;
moo_file_view_chdir_path (fileview, bookmark->path, NULL);
}
static void
bookmark_activated (MooFileView *fileview,
MooBookmark *bookmark)
{
g_return_if_fail (bookmark != NULL && bookmark->path != NULL);
moo_file_view_chdir_path (fileview, bookmark->path, NULL);
}
/****************************************************************************/
/* Auxiliary stuff
*/
static void
file_view_move_selection (MooFileView *fileview,
GtkTreeIter *filter_iter)
{
GtkTreePath *path = NULL;
if (filter_iter)
{
path = gtk_tree_model_get_path (fileview->priv->filter_model,
filter_iter);
g_return_if_fail (path != NULL);
}
_moo_tree_view_unselect_all (fileview->priv->view);
if (path)
{
_moo_tree_view_set_cursor (fileview->priv->view, path, FALSE);
_moo_tree_view_scroll_to_cell (fileview->priv->view, path);
}
gtk_tree_path_free (path);
}
static void
file_view_select_iter (MooFileView *fileview,
GtkTreeIter *iter)
{
if (iter)
{
GtkTreeIter filter_iter;
GtkTreePath *filter_path, *path;
path = gtk_tree_model_get_path (fileview->priv->model, iter);
g_return_if_fail (path != NULL);
filter_path = gtk_tree_model_filter_convert_child_path_to_path (
GTK_TREE_MODEL_FILTER (fileview->priv->filter_model), path);
if (!filter_path && _moo_tree_view_selection_is_empty (fileview->priv->view))
{
if (gtk_tree_model_get_iter_first (fileview->priv->filter_model, &filter_iter))
file_view_move_selection (fileview, &filter_iter);
}
else if (filter_path)
{
gtk_tree_model_get_iter (fileview->priv->filter_model,
&filter_iter, filter_path);
file_view_move_selection (fileview, &filter_iter);
gtk_tree_path_free (filter_path);
}
gtk_tree_path_free (path);
}
else
{
file_view_move_selection (fileview, NULL);
}
}
void
_moo_file_view_select_name (MooFileView *fileview,
const char *name)
{
GtkTreeIter iter;
MooFolderModel *model;
if (!name)
{
file_view_select_iter (fileview, NULL);
return;
}
model = MOO_FOLDER_MODEL (fileview->priv->model);
if (_moo_folder_model_get_iter_by_name (model, name, &iter))
{
file_view_select_iter (fileview, &iter);
return;
}
g_free (fileview->priv->select_file);
fileview->priv->select_file = g_strdup (name);
}
static void
_moo_file_view_select_display_name (MooFileView *fileview,
const char *name)
{
GtkTreeIter iter;
MooFolderModel *model;
if (!name)
{
file_view_select_iter (fileview, NULL);
return;
}
model = MOO_FOLDER_MODEL (fileview->priv->model);
if (_moo_folder_model_get_iter_by_display_name (model, name, &iter))
{
file_view_select_iter (fileview, &iter);
return;
}
g_free (fileview->priv->select_file);
fileview->priv->select_file = g_filename_from_utf8 (name, -1, NULL, NULL, NULL);
}
static gboolean
do_select_name (MooFileView *fileview)
{
GtkTreeIter iter;
fileview->priv->select_file_idle = 0;
if (!fileview->priv->select_file)
return FALSE;
if (_moo_folder_model_get_iter_by_name (MOO_FOLDER_MODEL (fileview->priv->model),
fileview->priv->select_file, &iter))
{
g_free (fileview->priv->select_file);
fileview->priv->select_file = NULL;
file_view_select_iter (fileview, &iter);
}
return FALSE;
}
static void
file_added (MooFileView *fileview)
{
if (fileview->priv->select_file && !fileview->priv->select_file_idle)
fileview->priv->select_file_idle =
g_idle_add ((GSourceFunc) do_select_name, fileview);
}
static const char*
get_selected_display_name (MooFileView *fileview)
{
GtkTreeModel *model = fileview->priv->filter_model;
GtkTreePath *filter_path;
GtkTreeIter filter_iter;
const char *name;
MooFile *file = NULL;
filter_path = _moo_tree_view_get_selected_path (fileview->priv->view);
if (!filter_path)
return NULL;
gtk_tree_model_get_iter (model, &filter_iter, filter_path);
gtk_tree_path_free (filter_path);
gtk_tree_model_get (model, &filter_iter, COLUMN_FILE, &file, -1);
g_return_val_if_fail (file != NULL, NULL);
name = _moo_file_display_name (file);
_moo_file_unref (file);
return name;
}
/****************************************************************************/
/* Path entry
*/
enum {
ENTRY_STATE_NONE = 0,
ENTRY_STATE_TYPEAHEAD = 1,
ENTRY_STATE_COMPLETION = 2
};
static void typeahead_create (MooFileView *fileview);
static void typeahead_destroy (MooFileView *fileview);
static void typeahead_try (MooFileView *fileview,
gboolean need_to_refilter);
static void typeahead_tab_key (MooFileView *fileview);
static gboolean typeahead_stop_tab_cycle(MooFileView *fileview);
static void entry_changed (GtkEntry *entry,
MooFileView *fileview);
static gboolean entry_key_press (GtkEntry *entry,
GdkEventKey *event,
MooFileView *fileview);
static gboolean entry_focus_out (GtkWidget *entry,
GdkEventFocus *event,
MooFileView *fileview);
static void entry_activate (GtkEntry *entry,
MooFileView *fileview);
static gboolean entry_stop_tab_cycle (MooFileView *fileview);
static gboolean entry_tab_key (GtkEntry *entry,
MooFileView *fileview);
static gboolean looks_like_path (const char *text);
static void
path_entry_init (MooFileView *fileview)
{
GtkEntry *entry = fileview->priv->entry;
/* XXX after? */
g_signal_connect (entry, "changed",
G_CALLBACK (entry_changed), fileview);
g_signal_connect (entry, "key-press-event",
G_CALLBACK (entry_key_press), fileview);
g_signal_connect (entry, "focus-out-event",
G_CALLBACK (entry_focus_out), fileview);
g_signal_connect (entry, "activate",
G_CALLBACK (entry_activate), fileview);
typeahead_create (fileview);
}
static void
path_entry_deinit (MooFileView *fileview)
{
typeahead_destroy (fileview);
}
static void
entry_changed (GtkEntry *entry,
MooFileView *fileview)
{
gboolean need_to_refilter = FALSE;
const char *text = gtk_entry_get_text (entry);
/*
First, decide what's going on (doesn't look like something can be
going on, but, anyway).
Then:
1) If text typed in is a beginning of some file in the list,
select that file (like treeview interactive search).
2) If text is a beginning of some hidden files (but not filtered
out, those are always ignored), show those hidden files and
select first of them.
3) Otherwise, parse text as <path>/<file> (<file> may be empty),
and do the entry completion stuff.
Tab completion doesn't interfere with this code - tab completion sets
entry text while this handler is blocked.
*/
/* Check if some file was shown temporarily, and hide it */
if (fileview->priv->temp_visible)
{
g_string_free (fileview->priv->temp_visible, TRUE);
fileview->priv->temp_visible = NULL;
need_to_refilter = TRUE;
}
if (!text[0])
{
if (need_to_refilter)
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER
(fileview->priv->filter_model));
file_view_move_selection (fileview, NULL);
return;
}
/* TODO take ~file into account */
/* If entered text looks like path, do completion stuff */
if (looks_like_path (text))
{
if (need_to_refilter)
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER
(fileview->priv->filter_model));
file_view_move_selection (fileview, NULL);
fileview->priv->entry_state = ENTRY_STATE_COMPLETION;
/* XXX call complete() or something, for automatic popup */
return;
}
else
{
fileview->priv->entry_state = ENTRY_STATE_TYPEAHEAD;
typeahead_try (fileview, need_to_refilter);
return;
}
}
static gboolean
entry_key_press (GtkEntry *entry,
GdkEventKey *event,
MooFileView *fileview)
{
GtkWidget *filewidget;
const char *name;
if (event->state & MOO_ACCEL_MODS_MASK)
return FALSE;
if (event->keyval != GDK_Tab)
{
if (entry_stop_tab_cycle (fileview))
g_signal_emit_by_name (entry, "changed");
}
switch (event->keyval)
{
case GDK_Escape:
stop_path_entry (fileview, TRUE);
return TRUE;
case GDK_Up:
case GDK_KP_Up:
case GDK_Down:
case GDK_KP_Down:
filewidget = get_view_widget (fileview);
GTK_WIDGET_CLASS(G_OBJECT_GET_CLASS (filewidget))->
key_press_event (filewidget, event);
name = get_selected_display_name (fileview);
g_return_val_if_fail (name != NULL, TRUE);
path_entry_set_text (fileview, name);
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
return TRUE;
case GDK_Tab:
return entry_tab_key (entry, fileview);
default:
return FALSE;
}
}
static gboolean
entry_stop_tab_cycle (MooFileView *fileview)
{
switch (fileview->priv->entry_state)
{
case ENTRY_STATE_TYPEAHEAD:
return typeahead_stop_tab_cycle (fileview);
case ENTRY_STATE_COMPLETION:
fileview->priv->entry_state = 0;
return FALSE;
default:
return FALSE;
}
}
static gboolean
entry_tab_key (GtkEntry *entry,
MooFileView *fileview)
{
const char *text;
if (!fileview->priv->entry_state)
{
text = gtk_entry_get_text (entry);
if (text[0])
{
g_signal_emit_by_name (entry, "changed");
g_return_val_if_fail (fileview->priv->entry_state != 0, FALSE);
return entry_tab_key (entry, fileview);
}
else
{
return FALSE;
}
}
if (fileview->priv->entry_state == ENTRY_STATE_TYPEAHEAD)
{
typeahead_tab_key (fileview);
return TRUE;
}
return FALSE;
}
static void
path_entry_set_text (MooFileView *fileview,
const char *text)
{
GtkEntry *entry = fileview->priv->entry;
g_signal_handlers_block_by_func (entry, (gpointer) entry_changed,
fileview);
gtk_entry_set_text (entry, text);
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
g_signal_handlers_unblock_by_func (entry, (gpointer) entry_changed,
fileview);
}
static void
path_entry_delete_to_cursor (MooFileView *fileview)
{
GtkEditable *entry = GTK_EDITABLE (fileview->priv->entry);
if (gtk_widget_is_focus (GTK_WIDGET (entry)))
gtk_editable_delete_text (entry, 0,
gtk_editable_get_position (entry));
}
static void
entry_activate (GtkEntry *entry,
MooFileView *fileview)
{
char *filename = NULL;
GtkTreePath *selected;
selected = _moo_tree_view_get_selected_path (fileview->priv->view);
if (selected)
{
GtkTreeIter iter;
MooFile *file = NULL;
gtk_tree_model_get_iter (fileview->priv->filter_model, &iter, selected);
gtk_tree_model_get (fileview->priv->filter_model, &iter, COLUMN_FILE, &file, -1);
gtk_tree_path_free (selected);
g_return_if_fail (file != NULL);
/* XXX display_name() */
filename = g_strdup (_moo_file_display_name (file));
_moo_file_unref (file);
}
else
{
filename = g_strdup (gtk_entry_get_text (entry));
}
stop_path_entry (fileview, TRUE);
file_view_activate_filename (fileview, filename);
g_free (filename);
}
#if 0
#define PRINT_KEY_EVENT(event) \
g_print ("%s%s%s%s\n", \
event->state & GDK_SHIFT_MASK ? "<Shift>" : "", \
event->state & GDK_CONTROL_MASK ? "<Control>" : "", \
event->state & GDK_MOD1_MASK ? "<Alt>" : "", \
gdk_keyval_name (event->keyval))
#else
#define PRINT_KEY_EVENT(event)
#endif
static gboolean
moo_file_view_key_press (MooFileView *fileview,
GtkWidget *widget,
GdkEventKey *event)
{
if (fileview->priv->entry_state)
{
g_warning ("oops");
stop_path_entry (fileview, FALSE);
return FALSE;
}
/* return immediately if event doesn't look like text typed in */
if (event->state & MOO_ACCEL_MODS_MASK & ~GDK_SHIFT_MASK)
return FALSE;
switch (event->keyval)
{
case GDK_VoidSymbol:
case GDK_BackSpace:
case GDK_Tab:
case GDK_Linefeed:
case GDK_Clear:
case GDK_Return:
case GDK_Pause:
case GDK_Scroll_Lock:
case GDK_Sys_Req:
case GDK_Escape:
case GDK_Delete:
case GDK_Multi_key:
case GDK_Codeinput:
case GDK_SingleCandidate:
case GDK_MultipleCandidate:
case GDK_PreviousCandidate:
case GDK_Kanji:
case GDK_Muhenkan:
case GDK_Henkan_Mode:
case GDK_Romaji:
case GDK_Hiragana:
case GDK_Katakana:
case GDK_Hiragana_Katakana:
case GDK_Zenkaku:
case GDK_Hankaku:
case GDK_Zenkaku_Hankaku:
case GDK_Touroku:
case GDK_Massyo:
case GDK_Kana_Lock:
case GDK_Kana_Shift:
case GDK_Eisu_Shift:
case GDK_Eisu_toggle:
case GDK_Home:
case GDK_Left:
case GDK_Up:
case GDK_Right:
case GDK_Down:
case GDK_Page_Up:
case GDK_Page_Down:
case GDK_End:
case GDK_Begin:
case GDK_Select:
case GDK_Print:
case GDK_Execute:
case GDK_Insert:
case GDK_Undo:
case GDK_Redo:
case GDK_Menu:
case GDK_Find:
case GDK_Cancel:
case GDK_Help:
case GDK_Break:
case GDK_Mode_switch:
case GDK_Num_Lock:
case GDK_KP_Tab:
case GDK_KP_Enter:
case GDK_KP_F1:
case GDK_KP_F2:
case GDK_KP_F3:
case GDK_KP_F4:
case GDK_KP_Home:
case GDK_KP_Left:
case GDK_KP_Up:
case GDK_KP_Right:
case GDK_KP_Down:
case GDK_KP_Page_Up:
case GDK_KP_Page_Down:
case GDK_KP_End:
case GDK_KP_Begin:
case GDK_KP_Insert:
case GDK_KP_Delete:
case GDK_F1:
case GDK_F2:
case GDK_F3:
case GDK_F4:
case GDK_F5:
case GDK_F6:
case GDK_F7:
case GDK_F8:
case GDK_F9:
case GDK_F10:
case GDK_F11:
case GDK_F12:
case GDK_F13:
case GDK_F14:
case GDK_F15:
case GDK_F16:
case GDK_F17:
case GDK_F18:
case GDK_F19:
case GDK_F20:
case GDK_F21:
case GDK_F22:
case GDK_F23:
case GDK_F24:
case GDK_F25:
case GDK_F26:
case GDK_F27:
case GDK_F28:
case GDK_F29:
case GDK_F30:
case GDK_F31:
case GDK_F32:
case GDK_F33:
case GDK_F34:
case GDK_F35:
case GDK_Shift_L:
case GDK_Shift_R:
case GDK_Control_L:
case GDK_Control_R:
case GDK_Caps_Lock:
case GDK_Shift_Lock:
case GDK_Meta_L:
case GDK_Meta_R:
case GDK_Alt_L:
case GDK_Alt_R:
case GDK_Super_L:
case GDK_Super_R:
case GDK_Hyper_L:
case GDK_Hyper_R:
case GDK_ISO_Lock:
case GDK_ISO_Level2_Latch:
case GDK_ISO_Level3_Shift:
case GDK_ISO_Level3_Latch:
case GDK_ISO_Level3_Lock:
case GDK_ISO_Group_Latch:
case GDK_ISO_Group_Lock:
case GDK_ISO_Next_Group:
case GDK_ISO_Next_Group_Lock:
case GDK_ISO_Prev_Group:
case GDK_ISO_Prev_Group_Lock:
case GDK_ISO_First_Group:
case GDK_ISO_First_Group_Lock:
case GDK_ISO_Last_Group:
case GDK_ISO_Last_Group_Lock:
case GDK_ISO_Left_Tab:
case GDK_ISO_Move_Line_Up:
case GDK_ISO_Move_Line_Down:
case GDK_ISO_Partial_Line_Up:
case GDK_ISO_Partial_Line_Down:
case GDK_ISO_Partial_Space_Left:
case GDK_ISO_Partial_Space_Right:
case GDK_ISO_Set_Margin_Left:
case GDK_ISO_Set_Margin_Right:
case GDK_ISO_Release_Margin_Left:
case GDK_ISO_Release_Margin_Right:
case GDK_ISO_Release_Both_Margins:
case GDK_ISO_Fast_Cursor_Left:
case GDK_ISO_Fast_Cursor_Right:
case GDK_ISO_Fast_Cursor_Up:
case GDK_ISO_Fast_Cursor_Down:
case GDK_ISO_Continuous_Underline:
case GDK_ISO_Discontinuous_Underline:
case GDK_ISO_Emphasize:
case GDK_ISO_Center_Object:
case GDK_ISO_Enter:
case GDK_First_Virtual_Screen:
case GDK_Prev_Virtual_Screen:
case GDK_Next_Virtual_Screen:
case GDK_Last_Virtual_Screen:
case GDK_Terminate_Server:
case GDK_AccessX_Enable:
case GDK_AccessX_Feedback_Enable:
case GDK_RepeatKeys_Enable:
case GDK_SlowKeys_Enable:
case GDK_BounceKeys_Enable:
case GDK_StickyKeys_Enable:
case GDK_MouseKeys_Enable:
case GDK_MouseKeys_Accel_Enable:
case GDK_Overlay1_Enable:
case GDK_Overlay2_Enable:
case GDK_AudibleBell_Enable:
case GDK_Pointer_Left:
case GDK_Pointer_Right:
case GDK_Pointer_Up:
case GDK_Pointer_Down:
case GDK_Pointer_UpLeft:
case GDK_Pointer_UpRight:
case GDK_Pointer_DownLeft:
case GDK_Pointer_DownRight:
case GDK_Pointer_Button_Dflt:
case GDK_Pointer_Button1:
case GDK_Pointer_Button2:
case GDK_Pointer_Button3:
case GDK_Pointer_Button4:
case GDK_Pointer_Button5:
case GDK_Pointer_DblClick_Dflt:
case GDK_Pointer_DblClick1:
case GDK_Pointer_DblClick2:
case GDK_Pointer_DblClick3:
case GDK_Pointer_DblClick4:
case GDK_Pointer_DblClick5:
case GDK_Pointer_Drag_Dflt:
case GDK_Pointer_Drag1:
case GDK_Pointer_Drag2:
case GDK_Pointer_Drag3:
case GDK_Pointer_Drag4:
case GDK_Pointer_Drag5:
case GDK_Pointer_EnableKeys:
case GDK_Pointer_Accelerate:
case GDK_Pointer_DfltBtnNext:
case GDK_Pointer_DfltBtnPrev:
case GDK_3270_Duplicate:
case GDK_3270_FieldMark:
case GDK_3270_Right2:
case GDK_3270_Left2:
case GDK_3270_BackTab:
case GDK_3270_EraseEOF:
case GDK_3270_EraseInput:
case GDK_3270_Reset:
case GDK_3270_Quit:
case GDK_3270_PA1:
case GDK_3270_PA2:
case GDK_3270_PA3:
case GDK_3270_Test:
case GDK_3270_Attn:
case GDK_3270_CursorBlink:
case GDK_3270_AltCursor:
case GDK_3270_KeyClick:
case GDK_3270_Jump:
case GDK_3270_Ident:
case GDK_3270_Rule:
case GDK_3270_Copy:
case GDK_3270_Play:
case GDK_3270_Setup:
case GDK_3270_Record:
case GDK_3270_ChangeScreen:
case GDK_3270_DeleteWord:
case GDK_3270_ExSelect:
case GDK_3270_CursorSelect:
case GDK_3270_PrintScreen:
case GDK_3270_Enter:
return FALSE;
}
PRINT_KEY_EVENT (event);
if (GTK_WIDGET_CLASS(G_OBJECT_GET_CLASS (widget))->key_press_event (widget, event))
return TRUE;
if (GTK_WIDGET_CLASS(G_OBJECT_GET_CLASS (fileview))->key_press_event (widget, event))
return TRUE;
if (event->string && event->length)
{
GdkEvent *copy;
GtkWidget *entry = GTK_WIDGET (fileview->priv->entry);
g_return_val_if_fail (event != NULL, FALSE);
g_return_val_if_fail (GTK_WIDGET_REALIZED (entry), FALSE);
copy = gdk_event_copy ((GdkEvent*) event);
g_object_unref (copy->key.window);
copy->key.window = g_object_ref (entry->window);
gtk_widget_grab_focus (entry);
path_entry_set_text (fileview, "");
gtk_widget_event (entry, copy);
gdk_event_free (copy);
return TRUE;
}
return FALSE;
}
static gboolean
entry_focus_out (GtkWidget *entry,
G_GNUC_UNUSED GdkEventFocus *event,
MooFileView *fileview)
{
/* focus may be lost due to switching to other window, do nothing then */
if (!gtk_widget_is_focus (entry))
stop_path_entry (fileview, TRUE);
return FALSE;
}
static void
stop_path_entry (MooFileView *fileview,
gboolean focus_file_list)
{
char *text;
typeahead_stop_tab_cycle (fileview);
fileview->priv->entry_state = 0;
if (fileview->priv->current_dir)
text = g_filename_display_name (_moo_folder_get_path (fileview->priv->current_dir));
else
text = g_strdup ("");
path_entry_set_text (fileview, text);
if (focus_file_list)
moo_file_view_focus_files (fileview);
g_free (text);
}
/* WIN32_XXX */
static void
file_view_activate_filename (MooFileView *fileview,
const char *display_name)
{
GError *error = NULL;
char *dirname, *basename;
char *path = NULL;
const char *current_dir = NULL;
if (fileview->priv->current_dir)
current_dir = _moo_folder_get_path (fileview->priv->current_dir);
path = _moo_file_system_get_absolute_path (fileview->priv->file_system,
display_name, current_dir);
if (!path || !g_file_test (path, G_FILE_TEST_EXISTS))
{
g_free (path);
return;
}
if (g_file_test (path, G_FILE_TEST_IS_DIR))
{
if (!moo_file_view_chdir_path (fileview, path, &error))
{
g_warning ("could not chdir to %s: %s", path, moo_error_message (error));
g_error_free (error);
}
g_free (path);
return;
}
dirname = g_path_get_dirname (path);
basename = g_path_get_basename (path);
if (!dirname || !basename)
{
g_free (path);
g_free (dirname);
g_free (basename);
g_return_if_reached ();
}
if (!moo_file_view_chdir_path (fileview, dirname, &error))
{
g_warning ("could not chdir to %s: %s", dirname, moo_error_message (error));
g_error_free (error);
g_free (path);
g_free (dirname);
g_free (basename);
return;
}
_moo_file_view_select_name (fileview, basename);
g_signal_emit (fileview, signals[ACTIVATE], 0, path);
g_free (path);
g_free (dirname);
g_free (basename);
}
static gboolean
looks_like_path (const char *text)
{
if (strchr (text, '/'))
return TRUE;
#ifdef __WIN32__
else if (strchr (text, '\\'))
return TRUE;
#endif
else
return FALSE;
}
/*********************************************************************/
/* Typeahead
*/
struct Typeahead {
MooFileView *fileview;
GtkEntry *entry;
GString *matched_prefix;
int matched_prefix_char_len;
TextFuncs text_funcs;
gboolean case_sensitive;
};
static gboolean typeahead_find_match_visible (MooFileView *fileview,
const char *text,
GtkTreeIter *filter_iter,
gboolean exact_match);
static gboolean typeahead_find_match_hidden (MooFileView *fileview,
const char *text,
GtkTreeIter *iter,
gboolean exact_match);
static void
typeahead_try (MooFileView *fileview,
gboolean need_to_refilter)
{
const char *text;
Typeahead *stuff = fileview->priv->typeahead;
GtkEntry *entry = stuff->entry;
GtkTreeIter filter_iter, iter;
g_assert (fileview->priv->entry_state == ENTRY_STATE_TYPEAHEAD);
if (stuff->matched_prefix)
{
g_string_free (stuff->matched_prefix, TRUE);
stuff->matched_prefix = NULL;
}
text = gtk_entry_get_text (entry);
g_assert (text[0] != 0);
/* TODO windows */
if (fileview->priv->show_hidden_files || text[0] != '.' || !text[1])
{
if (need_to_refilter)
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER
(fileview->priv->filter_model));
if (typeahead_find_match_visible (fileview, text, &filter_iter, FALSE))
file_view_move_selection (fileview, &filter_iter);
else
file_view_move_selection (fileview, NULL);
return;
}
/* check if partial name of hidden file was typed in */
if (typeahead_find_match_hidden (fileview, text, &iter, FALSE))
{
fileview->priv->temp_visible = g_string_new (text);
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER
(fileview->priv->filter_model));
gtk_tree_model_filter_convert_child_iter_to_iter (
GTK_TREE_MODEL_FILTER (fileview->priv->filter_model),
&filter_iter, &iter);
file_view_move_selection (fileview, &filter_iter);
}
else
{
if (need_to_refilter)
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER
(fileview->priv->filter_model));
file_view_move_selection (fileview, NULL);
}
}
static void
typeahead_tab_key (MooFileView *fileview)
{
const char *text;
Typeahead *stuff = fileview->priv->typeahead;
GtkEntry *entry = stuff->entry;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
MooFile *file = NULL;
const char *name;
g_assert (fileview->priv->entry_state == ENTRY_STATE_TYPEAHEAD);
model = fileview->priv->filter_model;
if (!gtk_tree_model_get_iter_first (model, &iter))
return;
/* see if it's cycling over matched names */
if (stuff->matched_prefix)
{
gboolean found = FALSE;
path = _moo_tree_view_get_selected_path (fileview->priv->view);
/* check if there is next name in the list to jump to */
if (path && gtk_tree_model_get_iter (model, &iter, path) &&
gtk_tree_model_iter_next (model, &iter))
{
found = model_find_next_match (model, &iter,
stuff->matched_prefix->str,
stuff->matched_prefix->len,
&stuff->text_funcs,
FALSE);
}
/* if nothing found, start cycling again */
if (!found)
found = typeahead_find_match_visible (fileview,
stuff->matched_prefix->str,
&iter, FALSE);
gtk_tree_path_free (path);
if (!found)
goto error;
else
file_view_move_selection (fileview, &iter);
}
else
{
gboolean unique;
text = gtk_entry_get_text (entry);
if (!text[0])
return;
stuff->matched_prefix =
model_find_max_prefix (fileview->priv->filter_model,
text, &stuff->text_funcs, &unique, &iter);
if (!stuff->matched_prefix)
return;
stuff->matched_prefix_char_len =
g_utf8_strlen (stuff->matched_prefix->str, stuff->matched_prefix->len);
/* if match is unique and it's a directory, append a slash */
if (unique)
{
file = NULL;
gtk_tree_model_get (model, &iter, COLUMN_FILE, &file, -1);
if (!file)
goto error;
name = _moo_file_display_name (file);
#if 0
if (!file || !stuff->file_equals (file, stuff->matched_prefix->str))
goto error;
#endif
if (MOO_FILE_IS_DIR (file))
{
char *new_text = g_strdup_printf ("%s%c", name, G_DIR_SEPARATOR);
g_string_free (stuff->matched_prefix, TRUE);
stuff->matched_prefix = NULL;
path_entry_set_text (fileview, new_text);
g_free (new_text);
_moo_file_unref (file);
g_signal_emit_by_name (entry, "changed");
return;
}
_moo_file_unref (file);
file = NULL;
}
path = _moo_tree_view_get_selected_path (fileview->priv->view);
if (!path && !typeahead_find_match_visible (fileview, stuff->matched_prefix->str, &iter, FALSE))
goto error;
if (path)
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
}
gtk_tree_model_get (model, &iter, COLUMN_FILE, &file, -1);
if (!file)
goto error;
#if 0
// if (!stuff->file_has_prefix (file, stuff->matched_prefix->str, stuff->matched_prefix->len))
// goto error;
#endif
name = _moo_file_display_name (file);
path_entry_set_text (fileview, name);
gtk_editable_select_region (GTK_EDITABLE (entry),
stuff->matched_prefix_char_len,
-1);
_moo_file_unref (file);
return;
error:
if (stuff->matched_prefix)
g_string_free (stuff->matched_prefix, TRUE);
stuff->matched_prefix = NULL;
_moo_file_unref (file);
g_return_if_reached ();
}
static gboolean
typeahead_stop_tab_cycle (MooFileView *fileview)
{
Typeahead *stuff = fileview->priv->typeahead;
if (stuff->matched_prefix)
{
g_string_free (stuff->matched_prefix, TRUE);
stuff->matched_prefix = NULL;
stuff->matched_prefix_char_len = 0;
return TRUE;
}
else
{
return FALSE;
}
}
static void
typeahead_create (MooFileView *fileview)
{
Typeahead *stuff = g_new0 (Typeahead, 1);
stuff->fileview = fileview;
stuff->entry = fileview->priv->entry;
stuff->case_sensitive = fileview->priv->typeahead_case_sensitive;
set_text_funcs (&stuff->text_funcs, stuff->case_sensitive);
fileview->priv->typeahead = stuff;
}
static void
typeahead_destroy (MooFileView *fileview)
{
Typeahead *stuff = fileview->priv->typeahead;
if (stuff->matched_prefix)
g_string_free (stuff->matched_prefix, TRUE);
g_free (stuff);
fileview->priv->typeahead = NULL;
}
static void
_moo_file_view_set_typeahead_case_sensitive (MooFileView *fileview,
gboolean case_sensitive)
{
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
if (case_sensitive != fileview->priv->typeahead_case_sensitive)
{
Typeahead *stuff = fileview->priv->typeahead;
fileview->priv->typeahead_case_sensitive = case_sensitive;
stuff->case_sensitive = case_sensitive;
set_text_funcs (&stuff->text_funcs, case_sensitive);
g_object_notify (G_OBJECT (fileview), "typeahead-case-sensitive");
}
}
static gboolean
typeahead_find_match_visible (MooFileView *fileview,
const char *text,
GtkTreeIter *filter_iter,
gboolean exact_match)
{
gsize len;
g_return_val_if_fail (text && text[0], FALSE);
if (!gtk_tree_model_get_iter_first (fileview->priv->filter_model, filter_iter))
return FALSE;
len = strlen (text);
return model_find_next_match (fileview->priv->filter_model,
filter_iter, text, len,
&fileview->priv->typeahead->text_funcs,
exact_match);
}
static gboolean
typeahead_find_match_hidden (MooFileView *fileview,
const char *text,
GtkTreeIter *iter,
gboolean exact)
{
gsize len;
GtkTreeModel *model = fileview->priv->model;
g_return_val_if_fail (text && text[0], FALSE);
if (!gtk_tree_model_get_iter_first (model, iter))
return FALSE;
len = strlen (text);
while (TRUE)
{
MooFile *file = NULL;
if (!model_find_next_match (model, iter, text, len,
&fileview->priv->typeahead->text_funcs,
exact))
return FALSE;
gtk_tree_model_get (model, iter, COLUMN_FILE, &file, -1);
if (file && moo_file_view_check_visible (fileview, file, TRUE, TRUE))
{
_moo_file_unref (file);
return TRUE;
}
_moo_file_unref (file);
if (!gtk_tree_model_iter_next (model, iter))
return FALSE;
}
}
/***************************************************************************/
/* Drag source
*/
static void
icon_drag_begin (MooFileView *fileview,
G_GNUC_UNUSED GdkDragContext *context,
G_GNUC_UNUSED MooIconView *iconview)
{
FileList *files, *l;
char **uris;
guint n_files, i;
MooFolder *folder;
folder = fileview->priv->current_dir;
g_return_if_fail (folder != NULL);
files = file_view_get_selected_files (fileview);
g_return_if_fail (files != NULL);
n_files = file_list_length (files);
uris = g_new0 (char*, n_files + 1);
for (l = files, i = 0; l != NULL; i++, l = l->next)
{
MooFile *file = l->data;
uris[i] = _moo_folder_get_file_uri (folder, file);
}
g_object_set_data_full (G_OBJECT (fileview), "moo-file-view-source-uris",
uris, (GDestroyNotify) g_strfreev);
g_object_set_data_full (G_OBJECT (fileview), "moo-file-view-source-dir",
g_object_ref (folder), g_object_unref);
file_list_free (files);
}
static void
icon_drag_data_get (MooFileView *fileview,
G_GNUC_UNUSED GdkDragContext *context,
GtkSelectionData *data,
G_GNUC_UNUSED guint info,
G_GNUC_UNUSED guint time,
G_GNUC_UNUSED MooIconView *iconview)
{
char **uris;
uris = g_object_get_data (G_OBJECT (fileview), "moo-file-view-source-uris");
g_return_if_fail (uris && *uris);
gtk_selection_data_set_uris (data, uris);
}
static void
icon_drag_end (MooFileView *fileview,
G_GNUC_UNUSED GdkDragContext *context,
G_GNUC_UNUSED MooIconView *iconview)
{
g_object_set_data (G_OBJECT (fileview), "moo-file-view-source-uris", NULL);
g_object_set_data (G_OBJECT (fileview), "moo-file-view-source-dir", NULL);
}
/***************************************************************************/
/* Drag destination
*/
#define DROP_OPEN_TIMEOUT 500
#define DROP_OPEN_BLINK_TIME 80
static gboolean
drop_open_timeout_func2 (MooFileView *fileview)
{
GtkTreeRowReference *ref;
GtkWidget *button;
ref = fileview->priv->drop_to.row;
fileview->priv->drop_to.row = NULL;
button = fileview->priv->drop_to.button;
cancel_drop_open (fileview);
if (ref)
{
MooFile *file = NULL;
const char *goto_dir = NULL;
GtkTreePath *path;
MooFolder *current_dir;
GtkTreeIter iter;
path = gtk_tree_row_reference_get_path (ref);
gtk_tree_row_reference_free (ref);
g_return_val_if_fail (path != NULL, FALSE);
if (!gtk_tree_model_get_iter (fileview->priv->filter_model, &iter, path))
{
gtk_tree_path_free (path);
g_return_val_if_reached (FALSE);
}
gtk_tree_path_free (path);
current_dir = fileview->priv->current_dir;
g_return_val_if_fail (current_dir != NULL, FALSE);
gtk_tree_model_get (fileview->priv->filter_model,
&iter, COLUMN_FILE, &file, -1);
g_return_val_if_fail (file != NULL, FALSE);
if (!strcmp (_moo_file_name (file), "..") || MOO_FILE_IS_DIR (file))
{
goto_dir = _moo_file_name (file);
}
else
{
g_warning ("oops");
}
if (goto_dir && moo_file_view_chdir_path (fileview, goto_dir, NULL))
_moo_file_view_select_name (fileview, NULL);
if (file)
_moo_file_unref (file);
}
else if (button)
{
g_signal_emit_by_name (button, "clicked");
_moo_file_view_select_name (fileview, NULL);
}
else
{
g_return_val_if_reached (FALSE);
}
return FALSE;
}
static gboolean
drop_open_timeout_func (MooFileView *fileview)
{
fileview->priv->drop_to.timeout = 0;
if (fileview->priv->drop_to.row)
{
GtkTreePath *path;
path = gtk_tree_row_reference_get_path (fileview->priv->drop_to.row);
if (!path)
{
cancel_drop_open (fileview);
_moo_icon_view_set_drag_dest_row (fileview->priv->iconview, NULL);
g_return_val_if_reached (FALSE);
}
if (fileview->priv->drop_to.blink_clear)
{
fileview->priv->drop_to.blink_clear = FALSE;
_moo_icon_view_set_drag_dest_row (fileview->priv->iconview, path);
if (++fileview->priv->drop_to.n_blinks > 1)
fileview->priv->drop_to.timeout =
g_timeout_add (DROP_OPEN_BLINK_TIME,
(GSourceFunc) drop_open_timeout_func2,
fileview);
}
else
{
fileview->priv->drop_to.blink_clear = TRUE;
_moo_icon_view_set_drag_dest_row (fileview->priv->iconview, NULL);
}
}
else if (fileview->priv->drop_to.button)
{
if (!fileview->priv->drop_to.highlight)
{
fileview->priv->drop_to.highlight = TRUE;
gtk_drag_highlight (fileview->priv->drop_to.button);
if (++fileview->priv->drop_to.n_blinks > 1)
fileview->priv->drop_to.timeout =
g_timeout_add (DROP_OPEN_BLINK_TIME,
(GSourceFunc) drop_open_timeout_func2,
fileview);
}
else
{
fileview->priv->drop_to.highlight = FALSE;
gtk_drag_unhighlight (fileview->priv->drop_to.button);
}
}
else
{
g_return_val_if_reached (FALSE);
}
if (!fileview->priv->drop_to.timeout)
fileview->priv->drop_to.timeout =
g_timeout_add (DROP_OPEN_BLINK_TIME,
(GSourceFunc) drop_open_timeout_func,
fileview);
return FALSE;
}
static void
drag_data_received (MooFileView *fileview,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
guint info,
guint time,
MooIconView *view)
{
gboolean dummy;
char *dir = NULL;
GtkTreePath *path = NULL;
MooFolder *current_dir;
cancel_drop_open (fileview);
current_dir = fileview->priv->current_dir;
if (!current_dir)
{
g_critical ("oops");
_moo_file_view_drag_finish (fileview, context, FALSE, FALSE, time);
return;
}
if (_moo_icon_view_get_path_at_pos (view, x, y, &path, NULL, NULL, NULL))
{
MooFile *file = file_view_get_file_at_path (fileview, path);
if (MOO_FILE_IS_DIR (file))
{
dir = _moo_folder_get_file_path (current_dir, file);
_moo_icon_view_set_drag_dest_row (view, path);
}
_moo_file_unref (file);
}
if (!dir)
dir = g_strdup (_moo_folder_get_path (current_dir));
g_signal_emit (fileview, signals[DROP_DATA_RECEIVED], 0,
dir, view, context, x, y, data, info, time, &dummy);
gtk_tree_path_free (path);
g_free (dir);
}
static gboolean
drag_drop (MooFileView *fileview,
GdkDragContext *context,
int x,
int y,
guint time,
MooIconView *view)
{
gboolean dummy;
char *dir = NULL;
GtkTreePath *path = NULL;
MooFolder *current_dir;
cancel_drop_open (fileview);
current_dir = fileview->priv->current_dir;
if (!current_dir)
{
g_critical ("oops");
_moo_file_view_drag_finish (fileview, context, FALSE, FALSE, time);
return FALSE;
}
if (_moo_icon_view_get_path_at_pos (view, x, y, &path, NULL, NULL, NULL))
{
MooFile *file = file_view_get_file_at_path (fileview, path);
if (MOO_FILE_IS_DIR (file))
{
dir = _moo_folder_get_file_path (current_dir, file);
_moo_icon_view_set_drag_dest_row (view, path);
}
_moo_file_unref (file);
}
if (!dir)
dir = g_strdup (_moo_folder_get_path (current_dir));
g_signal_emit (fileview, signals[DROP], 0, dir, view, context, x, y, time, &dummy);
gtk_tree_path_free (path);
g_free (dir);
return TRUE;
}
static gboolean
moo_file_view_drop (MooFileView *fileview,
G_GNUC_UNUSED const char *path,
GtkWidget *widget,
GdkDragContext *context,
G_GNUC_UNUSED int x,
G_GNUC_UNUSED int y,
guint time)
{
GdkAtom target;
target = gtk_drag_dest_find_target (widget, context, fileview->priv->targets);
if (target != GDK_NONE)
{
gtk_drag_get_data (widget, context, target, time);
return TRUE;
}
else
{
g_warning ("oops");
return FALSE;
}
}
static gboolean
moo_file_view_drop_data_received (MooFileView *fileview,
const char *path,
GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
G_GNUC_UNUSED guint info,
guint time)
{
gboolean success = FALSE;
gboolean delete = FALSE;
if (data->target == moo_atom_uri_list ())
{
char **uris = gtk_selection_data_get_uris (data);
if (uris)
{
/* it has to call drag_finish in order to be able to show menu */
moo_file_view_drop_uris (fileview, uris, path, widget,
context, x, y, time);
g_strfreev (uris);
return TRUE;
}
else
{
g_critical ("oops");
}
g_strfreev (uris);
}
else
{
char *text = (char*) gtk_selection_data_get_text (data);
delete = context->suggested_action & GDK_ACTION_MOVE;
if (text)
success = moo_file_view_drop_text (fileview, text, path, widget,
context, x, y, time, &delete);
else
g_critical ("oops");
g_free (text);
}
_moo_file_view_drag_finish (fileview, context, success, delete, time);
return TRUE;
}
void
_moo_file_view_drag_finish (MooFileView *fileview,
GdkDragContext *context,
gboolean success,
gboolean delete_data,
guint time)
{
GtkTreePath *path;
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
path = _moo_icon_view_get_drag_dest_row (fileview->priv->iconview);
_moo_icon_view_set_drag_dest_row (fileview->priv->iconview, NULL);
gtk_drag_finish (context, success, delete_data, time);
if (success && path)
{
_moo_icon_view_unselect_all (fileview->priv->iconview);
_moo_icon_view_set_cursor (fileview->priv->iconview, path, FALSE);
}
if (path)
gtk_tree_path_free (path);
}
static void
drag_leave (MooFileView *fileview,
G_GNUC_UNUSED GdkDragContext *context,
G_GNUC_UNUSED guint time,
GtkWidget *widget)
{
_moo_tree_view_set_drag_dest_row (widget, NULL);
cancel_drop_open (fileview);
}
static void
cancel_drop_open (MooFileView *fileview)
{
if (fileview->priv->drop_to.row)
gtk_tree_row_reference_free (fileview->priv->drop_to.row);
if (fileview->priv->drop_to.timeout)
g_source_remove (fileview->priv->drop_to.timeout);
if (fileview->priv->drop_to.highlight && fileview->priv->drop_to.button)
gtk_drag_unhighlight (fileview->priv->drop_to.button);
fileview->priv->drop_to.button = NULL;
fileview->priv->drop_to.highlight = FALSE;
fileview->priv->drop_to.blink_clear = FALSE;
fileview->priv->drop_to.n_blinks = 0;
fileview->priv->drop_to.row = NULL;
fileview->priv->drop_to.timeout = 0;
}
static gboolean
check_drop_targets (MooFileView *fileview,
GdkDragContext *context,
GtkWidget *widget)
{
GdkAtom target;
target = gtk_drag_dest_find_target (widget, context, fileview->priv->targets);
return target != GDK_NONE;
}
static gboolean
drag_motion (GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
guint time,
MooFileView *fileview)
{
MooFolder *source_dir;
MooFolder *current_dir;
GtkTreePath *path = NULL;
gboolean highlight_target = FALSE;
gboolean can_drop = FALSE;
int abs_x, abs_y;
if (!check_drop_targets (fileview, context, widget))
{
_moo_tree_view_set_drag_dest_row (widget, NULL);
return FALSE;
}
_moo_tree_view_widget_to_abs_coords (widget, x, y, &abs_x, &abs_y);
_moo_tree_view_get_path_at_pos (widget, x, y, &path);
if (MOO_IS_ICON_VIEW (widget))
{
current_dir = fileview->priv->current_dir;
source_dir = g_object_get_data (G_OBJECT (fileview), "moo-file-view-source-dir");
if (!current_dir)
goto out;
if (path)
{
MooFile *file = file_view_get_file_at_path (fileview, path);
if (MOO_FILE_IS_DIR (file))
{
highlight_target = TRUE;
can_drop = TRUE;
}
_moo_file_unref (file);
}
if (source_dir != current_dir)
can_drop = TRUE;
}
else if (MOO_IS_BOOKMARK_VIEW (widget))
{
highlight_target = TRUE;
can_drop = path != NULL;
}
if (highlight_target && path)
_moo_tree_view_set_drag_dest_row (widget, path);
else
_moo_tree_view_set_drag_dest_row (widget, NULL);
if (can_drop)
gdk_drag_status (context, context->actions & GDK_ACTION_MOVE ?
GDK_ACTION_MOVE : context->suggested_action, time);
else
gdk_drag_status (context, 0, time);
if (highlight_target)
{
gboolean new_timeout = TRUE;
if (fileview->priv->drop_to.row)
{
GtkTreePath *old_path = gtk_tree_row_reference_get_path (fileview->priv->drop_to.row);
if (old_path && !gtk_tree_path_compare (path, old_path) &&
!gtk_drag_check_threshold (widget,
fileview->priv->drop_to.x,
fileview->priv->drop_to.y,
abs_x,
abs_y))
{
new_timeout = FALSE;
g_assert (fileview->priv->drop_to.timeout != 0);
}
}
if (new_timeout)
{
cancel_drop_open (fileview);
fileview->priv->drop_to.row =
gtk_tree_row_reference_new (_moo_tree_view_get_model (widget), path);
fileview->priv->drop_to.timeout =
g_timeout_add (DROP_OPEN_TIMEOUT,
(GSourceFunc) drop_open_timeout_func,
fileview);
fileview->priv->drop_to.x = abs_x;
fileview->priv->drop_to.y = abs_y;
}
}
else
{
cancel_drop_open (fileview);
}
out:
if (path)
gtk_tree_path_free (path);
return TRUE;
}
static void
button_drag_leave (MooFileView *fileview,
G_GNUC_UNUSED GdkDragContext *context,
G_GNUC_UNUSED guint time,
G_GNUC_UNUSED GtkWidget *button)
{
cancel_drop_open (fileview);
}
static gboolean
button_drag_motion (MooFileView *fileview,
GdkDragContext *context,
G_GNUC_UNUSED int x,
G_GNUC_UNUSED int y,
guint time,
GtkWidget *button)
{
gboolean new_timeout = TRUE;
if (!check_drop_targets (fileview, context, button))
{
cancel_drop_open (fileview);
return FALSE;
}
if (fileview->priv->drop_to.button == button)
{
new_timeout = FALSE;
g_assert (fileview->priv->drop_to.timeout != 0);
}
if (new_timeout)
{
cancel_drop_open (fileview);
if (!fileview->priv->drop_to.highlight)
{
gtk_drag_highlight (button);
fileview->priv->drop_to.highlight = TRUE;
}
fileview->priv->drop_to.button = button;
fileview->priv->drop_to.timeout =
g_timeout_add (DROP_OPEN_TIMEOUT,
(GSourceFunc) drop_open_timeout_func,
fileview);
}
gdk_drag_status (context, context->suggested_action, time);
return TRUE;
}
void
_moo_file_view_add_target (MooFileView *fileview,
GdkAtom target,
guint flags,
guint info)
{
g_return_if_fail (MOO_IS_FILE_VIEW (fileview));
gtk_target_list_add (fileview->priv->targets, target, flags, info);
sync_dest_targets (fileview);
}
static void
sync_dest_targets (MooFileView *fileview)
{
GSList *l;
_moo_icon_view_set_dest_targets (fileview->priv->iconview,
fileview->priv->targets);
gtk_drag_dest_set_target_list (GTK_WIDGET (fileview->priv->bkview),
fileview->priv->targets);
for (l = fileview->priv->drag_dest_widgets; l != NULL; l = l->next)
gtk_drag_dest_set_target_list (l->data, fileview->priv->targets);
}
/***************************************************************************/
/* Dropping stuff
*/
#ifndef __WIN32__
static void
run_command_on_files (MooFileView *fileview,
GList *filenames,
const char *destdir,
const char **first_args,
int n_first_args)
{
GError *error = NULL;
char **argv;
int list_len, n_args, i;
GList *l;
g_return_if_fail (filenames != NULL);
g_return_if_fail (destdir != NULL);
g_return_if_fail (n_first_args > 0);
list_len = g_list_length (filenames);
n_args = list_len + n_first_args + 1;
argv = g_new (char*, n_args + 1);
for (i = 0; i < n_first_args; ++i)
{
g_assert (first_args[i] != NULL);
argv[i] = (char*) first_args[i];
}
argv[n_args-1] = (char*) destdir;
argv[n_args] = NULL;
for (i = 0, l = filenames; l != NULL; l = l->next, i++)
argv[n_first_args + i] = l->data;
if (!_moo_unix_spawn_async (argv, G_SPAWN_SEARCH_PATH, &error))
{
g_critical ("could not spawn '%s': %s", first_args[0], moo_error_message (error));
g_error_free (error);
goto out;
}
/* XXX strcmp */
if (fileview->priv->current_dir &&
!strcmp (destdir, _moo_folder_get_path (fileview->priv->current_dir)) &&
list_len == 1)
{
char *basename = g_path_get_basename (filenames->data);
if (basename)
_moo_file_view_select_name (fileview, basename);
g_free (basename);
}
out:
g_free (argv);
}
static void
copy_files (MooFileView *fileview,
GList *filenames,
const char *destdir)
{
const char *args[] = {"cp", "-R", "--"};
run_command_on_files (fileview, filenames, destdir,
args, G_N_ELEMENTS (args));
}
static void
move_files (MooFileView *fileview,
GList *filenames,
const char *destdir)
{
const char *args[] = {"mv", "--"};
run_command_on_files (fileview, filenames, destdir,
args, G_N_ELEMENTS (args));
}
static void
link_files (MooFileView *fileview,
GList *filenames,
const char *destdir)
{
const char *args[] = {"ln", "-s", "--"};
run_command_on_files (fileview, filenames, destdir,
args, G_N_ELEMENTS (args));
}
#endif /* __WIN32__ */
#ifdef __WIN32__
static void
copy_or_move_files (MooFileView *fileview,
GList *filenames,
const char *destdir,
gboolean copy)
{
gboolean single_file;
g_return_if_fail (filenames != NULL);
single_file = filenames->next == NULL;
if (copy)
_moo_copy_files_ui (filenames, destdir, GTK_WIDGET (fileview));
else
_moo_move_files_ui (filenames, destdir, GTK_WIDGET (fileview));
/* XXX strcmp */
if (single_file &&
fileview->priv->current_dir &&
strcmp (destdir, _moo_folder_get_path (fileview->priv->current_dir)) == 0)
{
char *basename = g_path_get_basename (filenames->data);
if (basename)
_moo_file_view_select_name (fileview, basename);
g_free (basename);
}
}
static void
copy_files (MooFileView *fileview,
GList *filenames,
const char *destdir)
{
copy_or_move_files (fileview, filenames, destdir, TRUE);
}
static void
move_files (MooFileView *fileview,
GList *filenames,
const char *destdir)
{
copy_or_move_files (fileview, filenames, destdir, FALSE);
}
static void
link_files (G_GNUC_UNUSED MooFileView *fileview,
G_GNUC_UNUSED GList *filenames,
G_GNUC_UNUSED const char *destdir)
{
g_return_if_reached ();
}
#endif /* __WIN32__ */
static void
free_string_list (GList *list)
{
g_list_foreach (list, (GFunc) g_free, NULL);
g_list_free (list);
}
static void
drop_item_activated (GObject *item,
MooFileView *fileview)
{
GdkDragAction action;
gpointer data;
GList *filenames;
char *destdir;
data = g_object_get_data (item, "moo-file-view-drop-action");
filenames = g_object_get_data (item, "moo-file-view-drop-files");
destdir = g_object_get_data (item, "moo-file-view-drop-dir");
g_return_if_fail (filenames != NULL && destdir != NULL);
action = GPOINTER_TO_INT (data);
switch (action)
{
case GDK_ACTION_COPY:
copy_files (fileview, filenames, destdir);
break;
case GDK_ACTION_MOVE:
move_files (fileview, filenames, destdir);
break;
case GDK_ACTION_LINK:
link_files (fileview, filenames, destdir);
break;
default:
g_return_if_reached ();
}
}
#if 0
// /* XXX */
// static gboolean
// same_path (const char *path1,
// const char *path2)
// {
// return !strcmp (path1, path2);
// }
//
//
// static void
// copy_file (MooFileView *fileview,
// const char *src,
// const char *destdir)
// {
// const char *args[] = {"cp", "-R", "--"};
// char *name = NULL;
// GList *list = NULL;
//
// name = _moo_file_view_copy_file_dialog (GTK_WIDGET (fileview), src, destdir);
//
// if (!name)
// goto out;
//
// if (g_file_test (name, G_FILE_TEST_EXISTS))
// {
// g_critical ("oops");
// goto out;
// }
//
// list = g_list_prepend (NULL, (char*) src);
// run_command_on_files (fileview, list, name, args, G_N_ELEMENTS (args));
//
// out:
// g_free (name);
// g_list_free (list);
// }
#endif
static void
moo_file_view_drop_uris (MooFileView *fileview,
char **uris,
const char *destdir,
GtkWidget *widget,
GdkDragContext *context,
G_GNUC_UNUSED int x,
G_GNUC_UNUSED int y,
guint time)
{
char **u;
GList *filenames = NULL;
GError *error = NULL;
GdkModifierType mask;
GdkDragAction action;
gboolean success = FALSE;
g_assert (uris != NULL);
for (u = uris; *u; ++u)
{
char *file = g_filename_from_uri (*u, NULL, &error);
if (!file)
{
g_warning ("%s", moo_error_message (error));
g_error_free (error);
goto out;
}
filenames = g_list_prepend (filenames, file);
}
if (!filenames)
{
g_warning ("got empty uri list");
goto out;
}
#if 0
// if (!filenames->next)
// {
// char *dirname;
//
// if (same_path (destdir, filenames->data))
// {
// g_warning ("dragging folder to itself");
// goto out;
// }
//
// dirname = g_path_get_dirname (filenames->data);
//
// if (same_path (destdir, dirname))
// {
// success = TRUE;
// copy_file (fileview, filenames->data, destdir);
// g_free (dirname);
// goto out;
// }
//
// g_free (dirname);
// }
#endif
mask = _moo_get_modifiers (widget);
#if 0
#define ACTION_NAME(ac) (ac == GDK_ACTION_DEFAULT ? "DEFAULT" : \
(ac == GDK_ACTION_COPY ? "COPY" : \
(ac == GDK_ACTION_MOVE ? "MOVE" : \
(ac == GDK_ACTION_LINK ? "LINK" : \
(ac == GDK_ACTION_PRIVATE ? "PRIVATE" : \
(ac == GDK_ACTION_ASK ? "ASK" : "???"))))))
g_print ("suggested: %s\naction: %s\n",
ACTION_NAME (context->suggested_action),
ACTION_NAME (context->action));
g_print ("actions: %s%s%s%s%s%s\n",
context->actions & GDK_ACTION_DEFAULT ? "DEFAULT " : "",
context->actions & GDK_ACTION_COPY ? "COPY " : "",
context->actions & GDK_ACTION_MOVE ? "MOVE " : "",
context->actions & GDK_ACTION_LINK ? "LINK " : "",
context->actions & GDK_ACTION_PRIVATE ? "PRIVATE " : "",
context->actions & GDK_ACTION_ASK ? "ASK " : "");
g_print ("modifiers: %s%s%s\n",
mask & GDK_SHIFT_MASK ? "SHIFT " : "",
mask & GDK_CONTROL_MASK ? "CONTROL " : "",
mask & GDK_MOD1_MASK ? "MOD1 " : "");
#endif
if (mask & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK))
action = context->suggested_action;
else
action = GDK_ACTION_ASK;
switch (action)
{
case GDK_ACTION_COPY:
case GDK_ACTION_MOVE:
case GDK_ACTION_LINK:
case GDK_ACTION_ASK:
break;
default:
g_warning ("oops");
action = GDK_ACTION_ASK;
}
if (action == GDK_ACTION_ASK)
{
GtkWidget *menu, *item;
char *dir_copy = g_strdup (destdir);
menu = gtk_menu_new ();
g_object_ref_sink (menu);
g_object_set_data_full (G_OBJECT (menu), "moo-file-view-drop-files",
filenames, (GDestroyNotify) free_string_list);
g_object_set_data_full (G_OBJECT (menu), "moo-file-view-drop-dir",
dir_copy, g_free);
#define CREATE_IT(stock,action,accel_label) \
item = gtk_image_menu_item_new_from_stock (stock, NULL); \
g_object_set_data (G_OBJECT (item), "moo-file-view-drop-files", filenames); \
g_object_set_data (G_OBJECT (item), "moo-file-view-drop-dir", dir_copy); \
g_object_set_data (G_OBJECT (item), "moo-file-view-drop-action", \
GINT_TO_POINTER (action)); \
g_signal_connect (item, "activate", G_CALLBACK (drop_item_activated), fileview); \
gtk_widget_show (item); \
_moo_menu_item_set_accel_label (item, accel_label); \
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
CREATE_IT (MOO_STOCK_FILE_MOVE, GDK_ACTION_MOVE, "Shift");
CREATE_IT (MOO_STOCK_FILE_COPY, GDK_ACTION_COPY, "Control");
CREATE_IT (MOO_STOCK_FILE_LINK, GDK_ACTION_LINK, "Control+Shift");
#undef CREATE_IT
item = gtk_separator_menu_item_new ();
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_CANCEL, NULL);
gtk_widget_show (item);
_moo_menu_item_set_accel_label (item, "Escape");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
_moo_file_view_drag_finish (fileview, context, TRUE, FALSE, time);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, 0);
g_object_unref (menu);
return;
}
switch (action)
{
case GDK_ACTION_COPY:
copy_files (fileview, filenames, destdir);
break;
case GDK_ACTION_MOVE:
move_files (fileview, filenames, destdir);
break;
case GDK_ACTION_LINK:
link_files (fileview, filenames, destdir);
break;
default:
g_assert_not_reached ();
}
success = TRUE;
out:
free_string_list (filenames);
_moo_file_view_drag_finish (fileview, context, success, FALSE, time);
}
static gboolean
moo_file_view_drop_text (G_GNUC_UNUSED MooFileView *fileview,
const char *text,
const char *destdir,
GtkWidget *widget,
G_GNUC_UNUSED GdkDragContext *context,
G_GNUC_UNUSED int x,
G_GNUC_UNUSED int y,
G_GNUC_UNUSED guint time,
G_GNUC_UNUSED gboolean *delete)
{
char *name = NULL;
gboolean result = FALSE;
GError *error = NULL;
g_return_val_if_fail (text != NULL, FALSE);
while (TRUE)
{
name = _moo_file_view_save_drop_dialog (widget, destdir);
if (!name)
return FALSE;
if (g_file_test (name, G_FILE_TEST_EXISTS))
{
g_critical ("oops");
goto out;
}
if (!_moo_save_file_utf8 (name, text, -1, &error))
{
char *utf8_name = g_filename_display_name (name);
char *err_text = g_strdup_printf ("Could not save file\n%s", utf8_name);
moo_error_dialog (err_text, error->message, widget);
g_free (err_text);
g_free (utf8_name);
g_free (name);
g_error_free (error);
name = NULL;
error = NULL;
}
else
{
result = TRUE;
goto out;
}
}
out:
g_free (name);
return result;
}
#if 0
static void
bookmark_drag_data_received (MooFileView *fileview,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
guint info,
guint time,
MooBookmarkView *bkview);
static gboolean
bookmark_drag_drop (MooFileView *fileview,
GdkDragContext *context,
int x,
int y,
guint time,
MooBookmarkView *bkview);
static void
bookmark_drag_leave (MooFileView *fileview,
GdkDragContext *context,
guint time,
MooBookmarkView *bkview);
static gboolean
bookmark_drag_motion (MooBookmarkView *bkview,
GdkDragContext *context,
int x,
int y,
guint time,
MooFileView *fileview)
{
MooFolder *source_dir;
MooFolder *current_dir;
GtkTreePath *path = NULL;
MooIconViewCell cell;
int cell_x, cell_y;
gboolean new_timeout = TRUE;
if (!check_drop_targets (fileview, context, GTK_WIDGET (bkview)) ||
!_moo_tree_view_get_path_at_pos (bkview, x, y, &path, &cell_x, &cell_y))
{
_moo_tree_view_set_drag_dest_row (bkview, NULL);
cancel_drop_open (fileview);
return FALSE;
}
_moo_tree_view_set_drag_dest_row (bkview, path);
gdk_drag_status (context, context->actions & GDK_ACTION_MOVE ?
GDK_ACTION_MOVE : context->suggested_action, time);
if (fileview->priv->drop_to.row)
{
GtkTreePath *old_path = gtk_tree_row_reference_get_path (fileview->priv->drop_to.row);
if (old_path && !gtk_tree_path_compare (path, old_path) &&
fileview->priv->drop_to.cell == cell &&
!gtk_drag_check_threshold (GTK_WIDGET (bkview),
fileview->priv->drop_to.x,
fileview->priv->drop_to.y,
cell_x,
cell_y))
{
new_timeout = FALSE;
g_assert (fileview->priv->drop_to.timeout != 0);
}
}
if (new_timeout)
{
cancel_drop_open (fileview);
fileview->priv->drop_to.row =
gtk_tree_row_reference_new (_moo_tree_view_get_model (bkview), path);
fileview->priv->drop_to.timeout =
g_timeout_add (DROP_OPEN_TIMEOUT,
(GSourceFunc) drop_open_timeout_func,
fileview);
fileview->priv->drop_to.x = cell_x;
fileview->priv->drop_to.y = cell_y;
fileview->priv->drop_to.cell = cell;
}
out:
if (path)
gtk_tree_path_free (path);
return TRUE;
}
#endif
GType
_moo_file_view_type_get_type (void)
{
static GType type;
if (G_UNLIKELY (!type))
{
static const GEnumValue values[] = {
{ MOO_FILE_VIEW_LIST, (char*) "MOO_FILE_VIEW_LIST", (char*) "list" },
{ MOO_FILE_VIEW_ICON, (char*) "MOO_FILE_VIEW_ICON", (char*) "icon" },
{ MOO_FILE_VIEW_BOOKMARK, (char*) "MOO_FILE_VIEW_BOOKMARK", (char*) "bookmark" },
{ 0, NULL, NULL }
};
type = g_enum_register_static ("MooFileViewType", values);
}
return type;
}
Reference in New Issue View Git Blame Copy Permalink