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
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"
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_WIN32, $GDK_WIN32)
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, "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 ();
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/mooi18n.h"
#include "mooutils/moo-mime.h"
#include "mooutils/moomenu.h"
#include "plugins/moofileselector-gxml.h"
#include "mooutils/moohelp.h"
#include "help-sections.h"
@ -1059,28 +1060,15 @@ create_menu_item (MooFileSelector *filesel,
return item;
}
static gboolean
menu_key_event (GtkWidget *menu,
GdkEventKey *event)
static void
alternate_toggled (GtkWidget *menu)
{
GdkModifierType mask;
gboolean alternate;
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);
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");
@ -1098,8 +1086,6 @@ menu_key_event (GtkWidget *menu,
GINT_TO_POINTER (alternate));
_moo_menu_item_set_label (item, label, FALSE);
}
return FALSE;
}
static GtkWidget *
@ -1110,10 +1096,8 @@ create_drop_doc_menu (MooFileSelector *filesel,
GtkWidget *menu, *item;
GSList *items = NULL;
menu = gtk_menu_new ();
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);
menu = moo_menu_new ();
g_signal_connect (menu, "alternate-toggled", G_CALLBACK (alternate_toggled), NULL);
item = create_menu_item (filesel, doc, destdir,
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))
typedef struct _MooFileSelector MooFileSelector;
typedef struct _MooFileSelectorClass MooFileSelectorClass;
typedef struct MooFileSelector MooFileSelector;
typedef struct MooFileSelectorClass MooFileSelectorClass;
struct _MooFileSelector
struct MooFileSelector
{
MooFileView parent;
MooFileView base;
MooEditWindow *window;
@ -45,9 +45,9 @@ struct _MooFileSelector
gboolean waiting_for_tab;
};
struct _MooFileSelectorClass
struct MooFileSelectorClass
{
MooFileViewClass parent_class;
MooFileViewClass base_class;
};

34
moo/moofileview/moofilesystem.c
View File

@ -31,6 +31,10 @@
#include <shellapi.h>
#endif
#ifdef MOO_USE_GIO
#include <gio/gio.h>
#endif
#if 0 && MOO_DEBUG_ENABLED
#define DEBUG_MESSAGE g_message
#else
@ -75,7 +79,7 @@ static MooFolder *get_parent_folder (MooFileSystem *fs,
MooFileFlags flags);
static gboolean delete_file (MooFileSystem *fs,
const char *path,
gboolean recursive,
MooDeleteFileFlags flags,
GError **error);
static gboolean move_file_unix (MooFileSystem *fs,
@ -338,12 +342,12 @@ _moo_file_system_create_folder (MooFileSystem *fs,
gboolean
_moo_file_system_delete_file (MooFileSystem *fs,
const char *path,
gboolean recursive,
MooDeleteFileFlags flags,
GError **error)
{
g_return_val_if_fail (MOO_IS_FILE_SYSTEM (fs), 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);
}
@ -726,16 +730,34 @@ delete_file_win32 (const char *path,
static gboolean
delete_file (G_GNUC_UNUSED MooFileSystem *fs,
const char *path,
gboolean recursive,
MooDeleteFileFlags flags,
GError **error)
{
gboolean isdir;
g_return_val_if_fail (path != NULL, 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
return delete_file_win32 (path, recursive, error);
return delete_file_win32 (path, (flags & MOO_DELETE_RECURSIVE) != 0, error);
#endif
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);
if (isdir)
return _moo_remove_dir (path, recursive, error);
return _moo_remove_dir (path, (flags & MOO_DELETE_RECURSIVE) != 0, error);
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 _MooFileSystemClass MooFileSystemClass;
typedef enum {
MOO_DELETE_RECURSIVE = 1 << 0,
MOO_DELETE_TO_TRASH = 1 << 1
} MooDeleteFileFlags;
struct _MooFileSystem
{
GObject parent;
@ -78,7 +83,7 @@ struct _MooFileSystemClass
GError **error);
gboolean (*delete_file) (MooFileSystem *fs,
const char *path,
gboolean recursive,
MooDeleteFileFlags flags,
GError **error);
gboolean (*move_file) (MooFileSystem *fs,
const char *old_path,
@ -115,7 +120,7 @@ gboolean _moo_file_system_create_folder (MooFileSystem *fs,
GError **error);
gboolean _moo_file_system_delete_file (MooFileSystem *fs,
const char *path,
gboolean recursive,
MooDeleteFileFlags flags,
GError **error);
gboolean _moo_file_system_move_file (MooFileSystem *fs,
const char *old_path,

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

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

237
moo/moofileview/moofileview.c
View File

@ -86,17 +86,17 @@ static GtkTargetEntry dest_targets[] = {
};
typedef struct _History History;
typedef struct _Typeahead Typeahead;
typedef struct _Clipboard Clipboard;
typedef struct History History;
typedef struct Typeahead Typeahead;
typedef struct Clipboard Clipboard;
struct _Clipboard {
struct Clipboard {
MooFolder *folder;
GList *files;
gboolean cut;
};
struct _MooFileViewPrivate {
struct MooFileViewPrivate {
GtkTreeModel *model;
GtkTreeModel *filter_model;
MooFolder *current_dir;
@ -299,6 +299,8 @@ static void file_view_activate_filename (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_create_folder (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",
"label", _("Delete..."),
"tooltip", _("Delete..."),
"tooltip", _("Delete selected files"),
"stock-id", GTK_STOCK_DELETE,
"default-accel", MOO_FILE_VIEW_ACCEL_DELETE,
"force-accel-label", TRUE,
"closure-object", fileview,
"closure-callback", file_view_delete_selected,
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,
@ -2028,7 +2029,7 @@ file_list_row_activated (MooFileView *fileview,
}
struct _History {
struct History {
GSList *back;
GSList *fwd;
char *current;
@ -3100,16 +3101,82 @@ file_view_get_selected_files (MooFileView *fileview)
}
static void
file_view_delete_selected (MooFileView *fileview)
static gboolean
ask_delete_files (MooFileView *fileview,
GList *files,
gboolean trash)
{
GError *error = NULL;
GList *files, *l;
gboolean one;
char *message;
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)
{
GList *files, *l;
if (!fileview->priv->current_dir)
return;
@ -3118,78 +3185,104 @@ file_view_delete_selected (MooFileView *fileview)
if (!files)
return;
one = (files->next == NULL);
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)
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 (!_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,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_NONE,
"Could not delete %s '%s'",
MOO_FILE_IS_DIR (l->data) ? "folder" : "file",
path);
char *text;
char *path_utf8;
moo_window_set_parent (dialog, GTK_WIDGET (fileview));
path_utf8 = g_filename_display_name (path);
if (error)
{
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
"%s", error->message);
g_error_free (error);
error = NULL;
}
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);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
moo_error_dialog (GTK_WIDGET (fileview), text,
error ? error->message : NULL);
g_free (path_utf8);
g_free (text);
}
g_free (path);
if (error)
g_error_free (error);
}
}
g_list_foreach (files, (GFunc) _moo_file_unref, NULL);
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,
NULL);
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);
g_signal_emit (fileview, signals[POPULATE_POPUP], 0, files, menu);
@ -4506,7 +4605,7 @@ looks_like_path (const char *text)
/* Typeahead
*/
struct _Typeahead {
struct Typeahead {
MooFileView *fileview;
GtkEntry *entry;
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_FILE_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_FILE_VIEW, MooFileViewClass))
typedef struct _MooFileView MooFileView;
typedef struct _MooFileViewClass MooFileViewClass;
typedef struct MooFileView MooFileView;
typedef struct MooFileViewClass MooFileViewClass;
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 \
moomarkup.c \
moomarkup.h \
moomenu.c \
moomenu.h \
moomenuaction.c \
moomenuaction.h \
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/mooutils-misc.h"
#include "mooutils/mooi18n.h"
#include "mooutils/moomenu.h"
#include "mooutils/mootype-macros.h"
#include <gtk/gtk.h>
#include <string.h>
@ -2004,7 +2005,7 @@ create_menu_shell (MooUIXML *xml,
}
else
{
toplevel->widget = gtk_menu_new ();
toplevel->widget = moo_menu_new ();
gtk_menu_set_accel_group (GTK_MENU (toplevel->widget),
toplevel->accel_group);
}

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

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