nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use GIO to move files to trash

master
Yevgen Muntyan 2008-09-07 10:56:37 -05:00
parent dab6821b66
commit f2efeff52d
15 changed files with 411 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
m4/moo-flags.m4
View File

@ -33,11 +33,6 @@ AC_DEFUN_ONCE([MOO_AC_PRIV_FLAGS],[
fi fi
MOO_CFLAGS="$MOO_CFLAGS $MOO_PCRE_CFLAGS -DXDG_PREFIX=_moo_edit_xdg -DG_LOG_DOMAIN=\\\"Moo\\\"" MOO_CFLAGS="$MOO_CFLAGS $MOO_PCRE_CFLAGS -DXDG_PREFIX=_moo_edit_xdg -DG_LOG_DOMAIN=\\\"Moo\\\""
if test "x$GLIB_2_16" = xyes; then
PKG_CHECK_MODULES(GIO,[gio-2.0],[:],[:])
fi
MOO_LIBS="$MOO_LIBS $GTK_LIBS $GTHREAD_LIBS $GIO_LIBS $MOO_PCRE_LIBS -lm" MOO_LIBS="$MOO_LIBS $GTK_LIBS $GTHREAD_LIBS $GIO_LIBS $MOO_PCRE_LIBS -lm"
if test "x$build_mooedit" != "xno"; then if test "x$build_mooedit" != "xno"; then

12
m4/moo-gtk.m4
View File

@ -72,4 +72,16 @@ esac
AM_CONDITIONAL(GDK_X11, $GDK_X11) AM_CONDITIONAL(GDK_X11, $GDK_X11)
AM_CONDITIONAL(GDK_WIN32, $GDK_WIN32) AM_CONDITIONAL(GDK_WIN32, $GDK_WIN32)
AM_CONDITIONAL(GDK_QUARTZ, $GDK_QUARTZ) AM_CONDITIONAL(GDK_QUARTZ, $GDK_QUARTZ)
MOO_USE_GIO=false
if test "x$GLIB_2_16" = xyes; then
PKG_CHECK_MODULES(GIO,[gio-2.0],[
MOO_USE_GIO=true
MOO_CHECK_VERSION(GIO, gio-2.0, [16, 18])
],[:])
fi
AM_CONDITIONAL([MOO_USE_GIO], [$MOO_USE_GIO])
if $MOO_USE_GIO; then
AC_DEFINE([MOO_USE_GIO], [1], [Use GIO library])
fi
]) ])

2
moo/mooedit/plugins/moofileselector-prefs.c
View File

@ -73,7 +73,7 @@ _moo_file_selector_prefs_page (MooPlugin *plugin)
g_signal_connect_swapped (page, "apply", G_CALLBACK (prefs_page_apply), gxml); g_signal_connect_swapped (page, "apply", G_CALLBACK (prefs_page_apply), gxml);
g_signal_connect_swapped (page, "init", G_CALLBACK (prefs_page_init), gxml); g_signal_connect_swapped (page, "init", G_CALLBACK (prefs_page_init), gxml);
moo_help_set_id (GTK_WIDGET (page), HELP_SECTION_PREFS_FILE_SELECTOR); moo_help_set_id (page, HELP_SECTION_PREFS_FILE_SELECTOR);
column = gtk_tree_view_column_new (); column = gtk_tree_view_column_new ();
gtk_tree_view_append_column (gxml->treeview, column); gtk_tree_view_append_column (gxml->treeview, column);

28
moo/mooedit/plugins/moofileselector.c
View File

@ -31,6 +31,7 @@
#include "mooutils/mooactionfactory.h" #include "mooutils/mooactionfactory.h"
#include "mooutils/mooi18n.h" #include "mooutils/mooi18n.h"
#include "mooutils/moo-mime.h" #include "mooutils/moo-mime.h"
#include "mooutils/moomenu.h"
#include "plugins/moofileselector-gxml.h" #include "plugins/moofileselector-gxml.h"
#include "mooutils/moohelp.h" #include "mooutils/moohelp.h"
#include "help-sections.h" #include "help-sections.h"
@ -1059,28 +1060,15 @@ create_menu_item (MooFileSelector *filesel,
return item; return item;
} }
static gboolean static void
menu_key_event (GtkWidget *menu, alternate_toggled (GtkWidget *menu)
GdkEventKey *event)
{ {
GdkModifierType mask; GdkModifierType mask;
gboolean alternate; gboolean alternate;
GSList *items, *l; GSList *items, *l;
switch (event->keyval)
{
case GDK_Shift_L:
case GDK_Shift_R:
case GDK_Control_L:
case GDK_Control_R:
break;
default:
return FALSE;
}
mask = _moo_get_modifiers (menu); mask = _moo_get_modifiers (menu);
alternate = (mask & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) != 0; alternate = (mask & GDK_SHIFT_MASK) != 0;
items = g_object_get_data (G_OBJECT (menu), "moo-menu-items"); items = g_object_get_data (G_OBJECT (menu), "moo-menu-items");
@ -1098,8 +1086,6 @@ menu_key_event (GtkWidget *menu,
GINT_TO_POINTER (alternate)); GINT_TO_POINTER (alternate));
_moo_menu_item_set_label (item, label, FALSE); _moo_menu_item_set_label (item, label, FALSE);
} }
return FALSE;
} }
static GtkWidget * static GtkWidget *
@ -1110,10 +1096,8 @@ create_drop_doc_menu (MooFileSelector *filesel,
GtkWidget *menu, *item; GtkWidget *menu, *item;
GSList *items = NULL; GSList *items = NULL;
menu = gtk_menu_new (); menu = moo_menu_new ();
g_signal_connect (menu, "alternate-toggled", G_CALLBACK (alternate_toggled), NULL);
g_signal_connect (menu, "key-press-event", G_CALLBACK (menu_key_event), NULL);
g_signal_connect (menu, "key-release-event", G_CALLBACK (menu_key_event), NULL);
item = create_menu_item (filesel, doc, destdir, item = create_menu_item (filesel, doc, destdir,
MOO_STOCK_FILE_MOVE, MOO_STOCK_FILE_MOVE,

12
moo/mooedit/plugins/moofileselector.h
View File

@ -32,12 +32,12 @@ G_BEGIN_DECLS
#define MOO_FILE_SELECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_FILE_SELECTOR, MooFileSelectorClass)) #define MOO_FILE_SELECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_FILE_SELECTOR, MooFileSelectorClass))
typedef struct _MooFileSelector MooFileSelector; typedef struct MooFileSelector MooFileSelector;
typedef struct _MooFileSelectorClass MooFileSelectorClass; typedef struct MooFileSelectorClass MooFileSelectorClass;
struct _MooFileSelector struct MooFileSelector
{ {
MooFileView parent; MooFileView base;
MooEditWindow *window; MooEditWindow *window;
@ -45,9 +45,9 @@ struct _MooFileSelector
gboolean waiting_for_tab; gboolean waiting_for_tab;
}; };
struct _MooFileSelectorClass struct MooFileSelectorClass
{ {
MooFileViewClass parent_class; MooFileViewClass base_class;
}; };

44
moo/moofileview/moofilesystem.c
View File

@ -31,6 +31,10 @@
#include <shellapi.h> #include <shellapi.h>
#endif #endif
#ifdef MOO_USE_GIO
#include <gio/gio.h>
#endif
#if 0 && MOO_DEBUG_ENABLED #if 0 && MOO_DEBUG_ENABLED
#define DEBUG_MESSAGE g_message #define DEBUG_MESSAGE g_message
#else #else
@ -75,7 +79,7 @@ static MooFolder *get_parent_folder (MooFileSystem *fs,
MooFileFlags flags); MooFileFlags flags);
static gboolean delete_file (MooFileSystem *fs, static gboolean delete_file (MooFileSystem *fs,
const char *path, const char *path,
gboolean recursive, MooDeleteFileFlags flags,
GError **error); GError **error);
static gboolean move_file_unix (MooFileSystem *fs, static gboolean move_file_unix (MooFileSystem *fs,
@ -336,14 +340,14 @@ _moo_file_system_create_folder (MooFileSystem *fs,
gboolean gboolean
_moo_file_system_delete_file (MooFileSystem *fs, _moo_file_system_delete_file (MooFileSystem *fs,
const char *path, const char *path,
gboolean recursive, MooDeleteFileFlags flags,
GError **error) GError **error)
{ {
g_return_val_if_fail (MOO_IS_FILE_SYSTEM (fs), FALSE); g_return_val_if_fail (MOO_IS_FILE_SYSTEM (fs), FALSE);
g_return_val_if_fail (path != NULL, FALSE); g_return_val_if_fail (path != NULL, FALSE);
return MOO_FILE_SYSTEM_GET_CLASS(fs)->delete_file (fs, path, recursive, error); return MOO_FILE_SYSTEM_GET_CLASS(fs)->delete_file (fs, path, flags, error);
} }
@ -725,17 +729,35 @@ delete_file_win32 (const char *path,
static gboolean static gboolean
delete_file (G_GNUC_UNUSED MooFileSystem *fs, delete_file (G_GNUC_UNUSED MooFileSystem *fs,
const char *path, const char *path,
gboolean recursive, MooDeleteFileFlags flags,
GError **error) GError **error)
{ {
gboolean isdir; gboolean isdir;
g_return_val_if_fail (path != NULL, FALSE); g_return_val_if_fail (path != NULL, FALSE);
g_return_val_if_fail (_moo_path_is_absolute (path), FALSE); g_return_val_if_fail (_moo_path_is_absolute (path), FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
if (flags & MOO_DELETE_TO_TRASH)
#if !defined(MOO_USE_GIO)
{
g_set_error (error, MOO_FILE_ERROR,
MOO_FILE_ERROR_NOT_IMPLEMENTED,
"Moving files to trash is not implemented");
return FALSE;
}
#else
{
GFile *file = g_file_new_for_path (path);
gboolean retval = g_file_trash (file, NULL, error);
g_object_unref (file);
return retval;
}
#endif
#if defined(__WIN32__) && 0 #if defined(__WIN32__) && 0
return delete_file_win32 (path, recursive, error); return delete_file_win32 (path, (flags & MOO_DELETE_RECURSIVE) != 0, error);
#endif #endif
if (g_file_test (path, G_FILE_TEST_IS_SYMLINK)) if (g_file_test (path, G_FILE_TEST_IS_SYMLINK))
@ -744,7 +766,7 @@ delete_file (G_GNUC_UNUSED MooFileSystem *fs,
isdir = g_file_test (path, G_FILE_TEST_IS_DIR); isdir = g_file_test (path, G_FILE_TEST_IS_DIR);
if (isdir) if (isdir)
return _moo_remove_dir (path, recursive, error); return _moo_remove_dir (path, (flags & MOO_DELETE_RECURSIVE) != 0, error);
if (_moo_remove (path)) if (_moo_remove (path))
{ {

9
moo/moofileview/moofilesystem.h
View File

@ -45,6 +45,11 @@ typedef struct _MooFileSystem MooFileSystem;
typedef struct _MooFileSystemPrivate MooFileSystemPrivate; typedef struct _MooFileSystemPrivate MooFileSystemPrivate;
typedef struct _MooFileSystemClass MooFileSystemClass; typedef struct _MooFileSystemClass MooFileSystemClass;
typedef enum {
MOO_DELETE_RECURSIVE = 1 << 0,
MOO_DELETE_TO_TRASH = 1 << 1
} MooDeleteFileFlags;
struct _MooFileSystem struct _MooFileSystem
{ {
GObject parent; GObject parent;
@ -78,7 +83,7 @@ struct _MooFileSystemClass
GError **error); GError **error);
gboolean (*delete_file) (MooFileSystem *fs, gboolean (*delete_file) (MooFileSystem *fs,
const char *path, const char *path,
gboolean recursive, MooDeleteFileFlags flags,
GError **error); GError **error);
gboolean (*move_file) (MooFileSystem *fs, gboolean (*move_file) (MooFileSystem *fs,
const char *old_path, const char *old_path,
@ -115,7 +120,7 @@ gboolean _moo_file_system_create_folder (MooFileSystem *fs,
GError **error); GError **error);
gboolean _moo_file_system_delete_file (MooFileSystem *fs, gboolean _moo_file_system_delete_file (MooFileSystem *fs,
const char *path, const char *path,
gboolean recursive, MooDeleteFileFlags flags,
GError **error); GError **error);
gboolean _moo_file_system_move_file (MooFileSystem *fs, gboolean _moo_file_system_move_file (MooFileSystem *fs,
const char *old_path, const char *old_path,

6
moo/moofileview/moofileview-impl.h
View File

@ -21,16 +21,16 @@
#define MOO_FILE_VIEW_IMPL_H #define MOO_FILE_VIEW_IMPL_H
typedef struct _MooFileViewPrivate MooFileViewPrivate; typedef struct MooFileViewPrivate MooFileViewPrivate;
struct _MooFileView struct MooFileView
{ {
GtkVBox vbox; GtkVBox vbox;
GtkWidget *toolbar; GtkWidget *toolbar;
MooFileViewPrivate *priv; MooFileViewPrivate *priv;
}; };
struct _MooFileViewClass struct MooFileViewClass
{ {
GtkVBoxClass vbox_class; GtkVBoxClass vbox_class;

237
moo/moofileview/moofileview.c
View File

@ -86,17 +86,17 @@ static GtkTargetEntry dest_targets[] = {
}; };
typedef struct _History History; typedef struct History History;
typedef struct _Typeahead Typeahead; typedef struct Typeahead Typeahead;
typedef struct _Clipboard Clipboard; typedef struct Clipboard Clipboard;
struct _Clipboard { struct Clipboard {
MooFolder *folder; MooFolder *folder;
GList *files; GList *files;
gboolean cut; gboolean cut;
}; };
struct _MooFileViewPrivate { struct MooFileViewPrivate {
GtkTreeModel *model; GtkTreeModel *model;
GtkTreeModel *filter_model; GtkTreeModel *filter_model;
MooFolder *current_dir; MooFolder *current_dir;
@ -299,6 +299,8 @@ static void file_view_activate_filename (MooFileView *fileview,
static void file_added (MooFileView *fileview); 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_delete_selected (MooFileView *fileview);
static void file_view_create_folder (MooFileView *fileview); static void file_view_create_folder (MooFileView *fileview);
static void file_view_properties_dialog (MooFileView *fileview); static void file_view_properties_dialog (MooFileView *fileview);
@ -1165,14 +1167,13 @@ init_actions (MooFileView *fileview)
action = moo_action_group_add_action (group, "Delete", action = moo_action_group_add_action (group, "Delete",
"label", _("Delete..."), "label", _("Delete..."),
"tooltip", _("Delete..."), "tooltip", _("Delete selected files"),
"stock-id", GTK_STOCK_DELETE, "stock-id", GTK_STOCK_DELETE,
"default-accel", MOO_FILE_VIEW_ACCEL_DELETE, "default-accel", MOO_FILE_VIEW_ACCEL_DELETE,
"force-accel-label", TRUE, "force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", file_view_delete_selected,
NULL); NULL);
moo_bind_bool_property (action, "sensitive", fileview, "has-selection", FALSE); 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 = moo_action_group_add_action (group, "ShowHiddenFiles",
"action-type::", MOO_TYPE_TOGGLE_ACTION, "action-type::", MOO_TYPE_TOGGLE_ACTION,
@ -2028,7 +2029,7 @@ file_list_row_activated (MooFileView *fileview,
} }
struct _History { struct History {
GSList *back; GSList *back;
GSList *fwd; GSList *fwd;
char *current; char *current;
@ -3100,16 +3101,82 @@ file_view_get_selected_files (MooFileView *fileview)
} }
static void static gboolean
file_view_delete_selected (MooFileView *fileview) ask_delete_files (MooFileView *fileview,
GList *files,
gboolean trash)
{ {
GError *error = NULL;
GList *files, *l;
gboolean one; gboolean one;
char *message; char *primary = NULL;
char *secondary = NULL;
GtkWidget *dialog; GtkWidget *dialog;
int response; 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)
{
GList *files, *l;
if (!fileview->priv->current_dir) if (!fileview->priv->current_dir)
return; return;
@ -3118,78 +3185,104 @@ file_view_delete_selected (MooFileView *fileview)
if (!files) if (!files)
return; return;
one = (files->next == NULL); if (ask_delete_files (fileview, files, trash))
if (one)
{
if (MOO_FILE_IS_DIR (files->data) && !MOO_FILE_IS_LINK (files->data))
message = g_strdup_printf ("Delete folder %s and all its content?",
_moo_file_display_name (files->data));
else
message = g_strdup_printf ("Delete file %s?",
_moo_file_display_name (files->data));
}
else
{
message = g_strdup ("Delete selected files?");
}
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE,
"%s", message);
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);
if (response == GTK_RESPONSE_OK)
{ {
for (l = files; l != NULL; l = l->next) for (l = files; l != NULL; l = l->next)
{ {
char *path = g_build_filename (_moo_folder_get_path (fileview->priv->current_dir), char *path = g_build_filename (_moo_folder_get_path (fileview->priv->current_dir),
_moo_file_name (l->data), NULL); _moo_file_name (l->data), NULL);
MooDeleteFileFlags flags = MOO_DELETE_RECURSIVE;
GError *error = NULL;
if (!_moo_file_system_delete_file (fileview->priv->file_system, path, TRUE, &error)) if (trash)
flags |= MOO_DELETE_TO_TRASH;
if (!_moo_file_system_delete_file (fileview->priv->file_system, path, flags, &error))
{ {
dialog = gtk_message_dialog_new (NULL, char *text;
GTK_DIALOG_MODAL, char *path_utf8;
GTK_MESSAGE_ERROR,
GTK_BUTTONS_NONE,
"Could not delete %s '%s'",
MOO_FILE_IS_DIR (l->data) ? "folder" : "file",
path);
moo_window_set_parent (dialog, GTK_WIDGET (fileview)); path_utf8 = g_filename_display_name (path);
if (error) if (MOO_FILE_IS_DIR (l->data))
{ text = g_strdup_printf (_("Could not delete folder %s"),
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), path_utf8);
"%s", error->message); else
g_error_free (error); text = g_strdup_printf (_("Could not delete file %s"),
error = NULL; path_utf8);
}
gtk_dialog_add_buttons (GTK_DIALOG (dialog), moo_error_dialog (GTK_WIDGET (fileview), text,
GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL); error ? error->message : NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
gtk_dialog_run (GTK_DIALOG (dialog)); g_free (path_utf8);
gtk_widget_destroy (dialog); g_free (text);
} }
g_free (path); g_free (path);
if (error)
g_error_free (error);
} }
} }
g_list_foreach (files, (GFunc) _moo_file_unref, NULL); g_list_foreach (files, (GFunc) _moo_file_unref, NULL);
g_list_free (files); g_list_free (files);
g_free (message); }
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));
} }
@ -3355,6 +3448,12 @@ do_popup (MooFileView *fileview,
fileview->priv->actions, fileview->priv->actions,
NULL); NULL);
MOO_OBJECT_REF_SINK (menu); MOO_OBJECT_REF_SINK (menu);
#ifdef MOO_USE_GIO
g_signal_connect_swapped (menu, "alternate-toggled",
G_CALLBACK (update_delete_action),
fileview);
update_delete_action (fileview, NULL);
#endif
_moo_file_view_tools_check (fileview); _moo_file_view_tools_check (fileview);
g_signal_emit (fileview, signals[POPULATE_POPUP], 0, files, menu); g_signal_emit (fileview, signals[POPULATE_POPUP], 0, files, menu);
@ -4506,7 +4605,7 @@ looks_like_path (const char *text)
/* Typeahead /* Typeahead
*/ */
struct _Typeahead { struct Typeahead {
MooFileView *fileview; MooFileView *fileview;
GtkEntry *entry; GtkEntry *entry;
GString *matched_prefix; GString *matched_prefix;

4
moo/moofileview/moofileview.h
View File

@ -28,8 +28,8 @@ G_BEGIN_DECLS
#define MOO_IS_FILE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_FILE_VIEW)) #define MOO_IS_FILE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_FILE_VIEW))
#define MOO_FILE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_FILE_VIEW, MooFileViewClass)) #define MOO_FILE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_FILE_VIEW, MooFileViewClass))
typedef struct _MooFileView MooFileView; typedef struct MooFileView MooFileView;
typedef struct _MooFileViewClass MooFileViewClass; typedef struct MooFileViewClass MooFileViewClass;
GType moo_file_view_get_type (void) G_GNUC_CONST; GType moo_file_view_get_type (void) G_GNUC_CONST;

2
moo/mooutils/Makefile.ug
View File

@ -94,6 +94,8 @@ mooutils_sources = \
mooi18n.h \ mooi18n.h \
moomarkup.c \ moomarkup.c \
moomarkup.h \ moomarkup.h \
moomenu.c \
moomenu.h \
moomenuaction.c \ moomenuaction.c \
moomenuaction.h \ moomenuaction.h \
moomenumgr.c \ moomenumgr.c \

100
moo/mooutils/moomenu.c Normal file
View File

@ -0,0 +1,100 @@
/*
* moomenu.c
*
* Copyright (C) 2004-2008 by Yevgen Muntyan <muntyan@tamu.edu>
*
* 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 "mooutils/moomenu.h"
#include "marshals.h"
#include "mooutils/mooutils-misc.h"
#include <gdk/gdkkeysyms.h>
static gboolean moo_menu_key_press_event (GtkWidget *widget,
GdkEventKey *event);
static gboolean moo_menu_key_release_event (GtkWidget *widget,
GdkEventKey *event);
enum {
ALTERNATE_TOGGLED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
G_DEFINE_TYPE (MooMenu, moo_menu, GTK_TYPE_MENU)
static void
moo_menu_class_init (MooMenuClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
widget_class->key_press_event = moo_menu_key_press_event;
widget_class->key_release_event = moo_menu_key_release_event;
signals[ALTERNATE_TOGGLED] =
g_signal_new ("alternate-toggled",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MooMenuClass, alternate_toggled),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
moo_menu_init (G_GNUC_UNUSED MooMenu *menu)
{
}
static void
moo_menu_key_event (GtkWidget *widget,
GdkEventKey *event)
{
switch (event->keyval)
{
case GDK_Shift_L:
case GDK_Shift_R:
case GDK_Shift_Lock:
g_signal_emit (widget, signals[ALTERNATE_TOGGLED], 0);
break;
}
}
static gboolean
moo_menu_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
moo_menu_key_event (widget, event);
if (GTK_WIDGET_CLASS (moo_menu_parent_class)->key_press_event)
return GTK_WIDGET_CLASS (moo_menu_parent_class)->key_press_event (widget, event);
else
return FALSE;
}
static gboolean
moo_menu_key_release_event (GtkWidget *widget,
GdkEventKey *event)
{
moo_menu_key_event (widget, event);
if (GTK_WIDGET_CLASS (moo_menu_parent_class)->key_release_event)
return GTK_WIDGET_CLASS (moo_menu_parent_class)->key_release_event (widget, event);
else
return FALSE;
}
GtkWidget *
moo_menu_new (void)
{
return g_object_new (MOO_TYPE_MENU, NULL);
}

50
moo/mooutils/moomenu.h Normal file
View File

@ -0,0 +1,50 @@
/*
* moomenu.h
*
* Copyright (C) 2004-2008 by Yevgen Muntyan <muntyan@tamu.edu>
*
* 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/>.
*/
#ifndef MOO_MENU_H
#define MOO_MENU_H
#include <gtk/gtkmenu.h>
G_BEGIN_DECLS
#define MOO_TYPE_MENU (moo_menu_get_type ())
#define MOO_MENU(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_MENU, MooMenu))
#define MOO_MENU_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_MENU, MooMenuClass))
#define MOO_IS_MENU(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_MENU))
#define MOO_IS_MENU_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_MENU))
#define MOO_MENU_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_MENU, MooMenuClass))
typedef struct MooMenu MooMenu;
typedef struct MooMenuClass MooMenuClass;
struct MooMenu
{
GtkMenu base;
};
struct MooMenuClass
{
GtkMenuClass base_class;
void (*alternate_toggled) (MooMenu *menu);
};
GType moo_menu_get_type (void) G_GNUC_CONST;
GtkWidget *moo_menu_new (void);
G_END_DECLS
#endif /* MOO_MENU_H */

3
moo/mooutils/moouixml.c
View File

@ -19,6 +19,7 @@
#include "mooutils/moomenutoolbutton.h" #include "mooutils/moomenutoolbutton.h"
#include "mooutils/mooutils-misc.h" #include "mooutils/mooutils-misc.h"
#include "mooutils/mooi18n.h" #include "mooutils/mooi18n.h"
#include "mooutils/moomenu.h"
#include "mooutils/mootype-macros.h" #include "mooutils/mootype-macros.h"
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <string.h> #include <string.h>
@ -2004,7 +2005,7 @@ create_menu_shell (MooUIXML *xml,
} }
else else
{ {
toplevel->widget = gtk_menu_new (); toplevel->widget = moo_menu_new ();
gtk_menu_set_accel_group (GTK_MENU (toplevel->widget), gtk_menu_set_accel_group (GTK_MENU (toplevel->widget),
toplevel->accel_group); toplevel->accel_group);
} }

32
moo/mooutils/mooutils-fs.c
View File

@ -23,8 +23,10 @@
#include "mooutils/mooutils-mem.h" #include "mooutils/mooutils-mem.h"
#include "mooutils/mootype-macros.h" #include "mooutils/mootype-macros.h"
#include "mooutils/moocompat.h" #include "mooutils/moocompat.h"
#include "mooutils/mooi18n.h"
#include <stdio.h> #include <stdio.h>
#include <string.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <errno.h> #include <errno.h>
@ -113,7 +115,7 @@ rm_fr (const char *path,
NULL, NULL, NULL, &child_err, &status, &error_here)) NULL, NULL, NULL, &child_err, &status, &error_here))
{ {
g_set_error (error, MOO_FILE_ERROR, MOO_FILE_ERROR_FAILED, g_set_error (error, MOO_FILE_ERROR, MOO_FILE_ERROR_FAILED,
"Could not run 'rm' command: %s", _("Could not run 'rm' command: %s"),
error_here->message); error_here->message);
g_error_free (error_here); g_error_free (error_here);
g_strfreev (argv); g_strfreev (argv);
@ -124,10 +126,14 @@ rm_fr (const char *path,
if (!WIFEXITED (status) || WEXITSTATUS (status)) if (!WIFEXITED (status) || WEXITSTATUS (status))
{ {
if (child_err && strlen (child_err) > 5000)
strcpy (child_err + 4997, "...");
g_set_error (error, MOO_FILE_ERROR, g_set_error (error, MOO_FILE_ERROR,
MOO_FILE_ERROR_FAILED, MOO_FILE_ERROR_FAILED,
"'rm' command failed: %s", _("'rm' command failed: %s"),
child_err ? child_err : ""); child_err ? child_err : "");
g_free (child_err); g_free (child_err);
return FALSE; return FALSE;
} }
@ -175,7 +181,7 @@ rm_r (const char *path,
success = FALSE; success = FALSE;
g_set_error (error, MOO_FILE_ERROR, g_set_error (error, MOO_FILE_ERROR,
_moo_file_error_from_errno (err), _moo_file_error_from_errno (err),
"Could not remove '%s': %s", file_path, _("Could not remove %s: %s"), file_path,
g_strerror (err)); g_strerror (err));
} }
} }
@ -195,7 +201,7 @@ rm_r (const char *path,
success = FALSE; success = FALSE;
g_set_error (error, MOO_FILE_ERROR, g_set_error (error, MOO_FILE_ERROR,
_moo_file_error_from_errno (err), _moo_file_error_from_errno (err),
"Could not remove '%s': %s", path, _("Could not remove %s: %s"), path,
g_strerror (err)); g_strerror (err));
} }
} }
@ -222,7 +228,7 @@ _moo_remove_dir (const char *path,
char *path_utf8 = g_filename_display_name (path); char *path_utf8 = g_filename_display_name (path);
g_set_error (error, MOO_FILE_ERROR, g_set_error (error, MOO_FILE_ERROR,
_moo_file_error_from_errno (err), _moo_file_error_from_errno (err),
"Could not remove '%s': %s", _("Could not remove %s: %s"),
path_utf8, g_strerror (err)); path_utf8, g_strerror (err));
g_free (path_utf8); g_free (path_utf8);
return FALSE; return FALSE;
@ -267,7 +273,7 @@ _moo_create_dir (const char *path,
g_set_error (error, g_set_error (error,
MOO_FILE_ERROR, MOO_FILE_ERROR,
_moo_file_error_from_errno (err_code), _moo_file_error_from_errno (err_code),
"Could not create directory '%s': %s", _("Could not create folder %s: %s"),
utf8_path, g_strerror (err_code)); utf8_path, g_strerror (err_code));
g_free (utf8_path); g_free (utf8_path);
@ -286,7 +292,7 @@ _moo_create_dir (const char *path,
g_set_error (error, g_set_error (error,
MOO_FILE_ERROR, MOO_FILE_ERROR,
_moo_file_error_from_errno (err_code), _moo_file_error_from_errno (err_code),
"Could not create directory '%s': %s", _("Could not create folder %s: %s"),
utf8_path, g_strerror (err_code)); utf8_path, g_strerror (err_code));
g_free (utf8_path); g_free (utf8_path);
@ -302,7 +308,7 @@ _moo_create_dir (const char *path,
utf8_path = g_filename_display_name (path); utf8_path = g_filename_display_name (path);
g_set_error (error, MOO_FILE_ERROR, g_set_error (error, MOO_FILE_ERROR,
MOO_FILE_ERROR_ALREADY_EXISTS, MOO_FILE_ERROR_ALREADY_EXISTS,
"Could not create directory '%s': %s", _("Could not create folder %s: %s"),
utf8_path, g_strerror (EEXIST)); utf8_path, g_strerror (EEXIST));
g_free (utf8_path); g_free (utf8_path);
@ -331,7 +337,7 @@ _moo_rename_file (const char *path,
g_set_error (error, g_set_error (error,
MOO_FILE_ERROR, MOO_FILE_ERROR,
_moo_file_error_from_errno (err_code), _moo_file_error_from_errno (err_code),
"Could not rename file '%s' to '%s': %s", _("Could not rename file %s to %s: %s"),
utf8_path, utf8_new_path, g_strerror (err_code)); utf8_path, utf8_new_path, g_strerror (err_code));
g_free (utf8_path); g_free (utf8_path);
@ -1486,7 +1492,7 @@ moo_file_reader_new_real (const char *filename,
int err = errno; int err = errno;
g_set_error (error, MOO_FILE_ERROR, g_set_error (error, MOO_FILE_ERROR,
_moo_file_error_from_errno (err), _moo_file_error_from_errno (err),
"Could not open '%s': %s", filename, _("Could not open %s: %s"), filename,
g_strerror (err)); g_strerror (err));
return NULL; return NULL;
} }
@ -1717,7 +1723,7 @@ moo_local_file_writer_new (const char *filename,
char *display_name = g_filename_display_name (dirname); char *display_name = g_filename_display_name (dirname);
g_set_error (error, G_FILE_ERROR, g_set_error (error, G_FILE_ERROR,
g_file_error_from_errno (err), g_file_error_from_errno (err),
"could not create directory '%s': %s", _("Could not create folder %s: %s"),
display_name, g_strerror (err)); display_name, g_strerror (err));
g_free (display_name); g_free (display_name);
goto out; goto out;
@ -1733,7 +1739,7 @@ moo_local_file_writer_new (const char *filename,
char *display_name = g_filename_display_name (temp_filename); char *display_name = g_filename_display_name (temp_filename);
g_set_error (error, G_FILE_ERROR, g_set_error (error, G_FILE_ERROR,
g_file_error_from_errno (err), g_file_error_from_errno (err),
"could not create temporary file '%s': %s", _("Could not create temporary file %s: %s"),
display_name, g_strerror (err)); display_name, g_strerror (err));
g_free (display_name); g_free (display_name);
goto out; goto out;
@ -1747,7 +1753,7 @@ moo_local_file_writer_new (const char *filename,
char *display_name = g_filename_display_name (temp_filename); char *display_name = g_filename_display_name (temp_filename);
g_set_error (error, G_FILE_ERROR, g_set_error (error, G_FILE_ERROR,
g_file_error_from_errno (err), g_file_error_from_errno (err),
"could not create temporary file '%s': %s", _("Could not create temporary file %s: %s"),
display_name, g_strerror (err)); display_name, g_strerror (err));
g_free (display_name); g_free (display_name);
g_unlink (temp_filename); g_unlink (temp_filename);