static GList* relax_plugin_get_background_items(NautilusMenuProvider* provider,
GtkWidget *window,
NautilusFileInfo* current_folder)
{
NautilusMenu *sub_menu;
NautilusMenuItem *item;
NautilusMenuItem *add_item;
NautilusMenuItem *refresh_item;
NautilusMenuItem *refresh_folder_item;
GList* ret_val = NULL;
GFile* a_file;
add_item = nautilus_menu_item_new("RelaxPlugin::add",
"add folder to relax",
"adds the current folder as a folder to be monitored on relax",
NULL);
g_signal_connect (add_item, "activate", add_to_relax_callback, provider);
a_file = nautilus_file_info_get_location(current_folder);
g_object_set_data(G_OBJECT(add_item), "folder", (gpointer)g_file_get_path(a_file));
refresh_item = nautilus_menu_item_new("RelaxPlugin::refresh",
"refresh relax",
"refreshes Relax! app",
NULL);
g_signal_connect (refresh_item, "activate", refresh_relax_callback, provider);
refresh_folder_item = nautilus_menu_item_new("RelaxPlugin::refresh-folder",
"refresh current folder",
"refreshes the current folder without adding it to relax",
NULL);
g_signal_connect (refresh_folder_item, "activate", refresh_current_folder_callback, provider);
GFile* s_file = nautilus_file_info_get_location(current_folder);
g_object_set_data(G_OBJECT(refresh_folder_item), "folder", (gpointer)g_file_get_path(s_file));
sub_menu = nautilus_menu_new();
nautilus_menu_append_item(sub_menu, add_item);
nautilus_menu_append_item(sub_menu, refresh_item);
nautilus_menu_append_item(sub_menu, refresh_folder_item);
item = nautilus_menu_item_new("Relax::Plugin",
"relax-file-manager",
"show operations to be done on relax",
NULL);
nautilus_menu_item_set_submenu(item, sub_menu);
ret_val = g_list_append(ret_val, item);
return ret_val;
}
static GList *
deja_dup_nautilus_extension_get_background_items(NautilusMenuProvider *provider,
GtkWidget *window,
NautilusFileInfo *file)
{
NautilusMenuItem *item;
guint length;
GList *file_copies;
gchar *path;
if (file == NULL)
return NULL;
path = g_find_program_in_path("deja-dup");
if (!path)
return NULL;
g_free(path);
if (!is_dir_included(nautilus_file_info_get_location(file)))
return NULL;
item = nautilus_menu_item_new("DejaDupNautilusExtension::restore_missing_item",
dgettext(GETTEXT_PACKAGE, "Restore Missing Files…"),
dgettext(GETTEXT_PACKAGE, "Restore deleted files from backup"),
"deja-dup");
g_signal_connect(item, "activate", G_CALLBACK(restore_missing_files_callback), NULL);
g_object_set_data_full (G_OBJECT(item), "deja_dup_extension_file",
g_object_ref(file),
(GDestroyNotify)g_object_unref);
return g_list_append(NULL, item);
}
static gboolean
unsupported_scheme (NautilusFileInfo *file)
{
gboolean result = FALSE;
GFile *location;
gchar *scheme;
location = nautilus_file_info_get_location (file);
scheme = g_file_get_uri_scheme (location);
if (scheme != NULL)
{
const gchar *unsupported[] = { "trash", "computer", NULL };
gsize i;
for (i = 0; unsupported[i] != NULL; i++)
{
if (strcmp (scheme, unsupported[i]) == 0)
{
result = TRUE;
}
}
}
g_free (scheme);
g_object_unref (location);
return result;
}
static GList *
deja_dup_nautilus_extension_get_file_items(NautilusMenuProvider *provider,
GtkWidget *window,
GList *files)
{
NautilusMenuItem *item;
guint length;
GList *file_copies;
gchar *path;
if (files == NULL)
return NULL;
path = g_find_program_in_path("deja-dup");
if (!path)
return NULL;
g_free(path);
gboolean is_one_included = FALSE;
GList *p;
for (p = files; p; p = p->next) {
GFile *gfile = nautilus_file_info_get_location((NautilusFileInfo *)p->data);
if (is_dir_included(gfile))
is_one_included = TRUE;
}
if (!is_one_included)
return NULL;
length = g_list_length(files);
item = nautilus_menu_item_new("DejaDupNautilusExtension::restore_item",
dngettext(GETTEXT_PACKAGE,
"Revert to Previous Version…",
"Revert to Previous Versions…",
length),
dngettext(GETTEXT_PACKAGE,
"Restore file from backup",
"Restore files from backup",
length),
"deja-dup");
g_signal_connect(item, "activate", G_CALLBACK(restore_files_callback), NULL);
g_object_set_data_full (G_OBJECT(item), "deja_dup_extension_files",
nautilus_file_info_list_copy(files),
(GDestroyNotify)nautilus_file_info_list_free);
return g_list_append(NULL, item);
}
/* Info interfaces */
static NautilusOperationResult mtime_extension_update_file_info(
NautilusInfoProvider *provider,
NautilusFileInfo *file,
GClosure *update_complete,
NautilusOperationHandle **handle)
{
char datetime[32];
struct stat sb;
struct tm *tm;
GFile *loc;
loc = nautilus_file_info_get_location(file);
stat(g_file_get_path(loc), &sb);
tm = localtime(&sb.st_mtime);
g_snprintf(datetime, sizeof(datetime), ISO_8601_FMT,
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
nautilus_file_info_add_string_attribute(file,
"MTimeExt::mtime_data", datetime);
return NAUTILUS_OPERATION_COMPLETE;
}
static GList *
nautilus_disc_burn_get_file_items (NautilusMenuProvider *provider,
GtkWidget *window,
GList *selection)
{
GList *items = NULL;
NautilusMenuItem *item;
NautilusFileInfo *file_info;
GFile *file;
GMount *mount;
GVolume *volume;
GDrive *drive;
char *mime_type;
gboolean is_iso;
DEBUG_PRINT ("Getting file items\n");
if (!selection || selection->next != NULL) {
return NULL;
}
file_info = NAUTILUS_FILE_INFO (selection->data);
if (nautilus_file_info_is_gone (file_info)) {
return NULL;
}
file = nautilus_file_info_get_location (file_info);
if (file == NULL) {
DEBUG_PRINT ("No file found\n");
return NULL;
}
mime_type = nautilus_file_info_get_mime_type (file_info);
DEBUG_PRINT ("Mime type: %s\n", mime_type);
if (! mime_type) {
g_object_unref (file);
return NULL;
}
is_iso = (strcmp (mime_type, "application/x-iso-image") == 0)
|| (strcmp (mime_type, "application/x-cd-image") == 0)
|| (strcmp (mime_type, "application/x-cue") == 0)
|| (strcmp (mime_type, "application/x-toc") == 0)
|| (strcmp (mime_type, "application/x-cdrdao-toc") == 0);
if (is_iso) {
/* Whether or not this file is local is not a problem */
item = nautilus_menu_item_new ("NautilusDiscBurn::write_iso",
_("_Write to Disc…"),
_("Write disc image to a CD or DVD"),
"media-optical-data-new");
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_signal_connect (item, "activate",
G_CALLBACK (write_iso_activate_cb), window);
items = g_list_append (items, item);
}
/*
* We handle two cases here. The selection is:
* A) a volume
* B) a drive
*
* This is because there is very little distinction between
* the two for CD/DVD media
*/
drive = NULL;
volume = NULL;
mount = nautilus_file_info_get_mount (file_info);
if (mount != NULL) {
drive = g_mount_get_drive (mount);
volume = g_mount_get_volume (mount);
} else {
char *uri = g_file_get_uri (file);
DEBUG_PRINT ("Mount not found: %s\n", uri);
g_free (uri);
}
if (drive == NULL && volume != NULL) {
/* case A */
drive = g_volume_get_drive (volume);
} else if (volume == NULL && drive != NULL) {
/* case B */
volume = drive_get_first_volume (drive);
if (volume == NULL) {
DEBUG_PRINT ("Volume not found\n");
}
}
if (drive != NULL
&& volume != NULL
&& drive_is_cd_device (drive)
&& ! volume_is_blank (volume)) {
char *device_path;
BraseroMediumMonitor *monitor;
BraseroDrive *bdrive;
BraseroMedium *medium;
BraseroMedia media;
BraseroTrackType *type;
/* Reminder: the following is not needed since it is already
* called in drive_is_cd_device ().
* ensure_initialized();
*/
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
monitor = brasero_medium_monitor_get_default ();
bdrive = brasero_medium_monitor_get_drive (monitor, device_path);
g_object_unref (monitor);
medium = brasero_drive_get_medium (bdrive);
media = brasero_medium_get_status (medium);
g_object_unref (bdrive);
type = brasero_track_type_new ();
brasero_track_type_set_has_medium (type);
brasero_track_type_set_medium_type (type, media);
if (brasero_burn_library_input_supported (type) == BRASERO_BURN_OK) {
/* user may want to copy it ... */
item = nautilus_menu_item_new ("NautilusDiscBurn::copy_disc",
_("_Copy Disc…"),
_("Create a copy of this CD or DVD"),
"media-optical-copy");
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_object_set_data_full (G_OBJECT (item), "drive_device_path", g_strdup (device_path), g_free);
g_signal_connect (item, "activate", G_CALLBACK (copy_disc_activate_cb), window);
items = g_list_append (items, item);
}
brasero_track_type_free (type);
if (brasero_burn_library_get_media_capabilities (media) & BRASERO_MEDIUM_REWRITABLE) {
/* ... or if it's a rewritable medium to blank it ... */
item = nautilus_menu_item_new ("NautilusDiscBurn::blank_disc",
_("_Blank Disc…"),
_("Blank this CD or DVD"),
"media-optical-blank");
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_object_set_data_full (G_OBJECT (item), "drive_device_path", g_strdup (device_path), g_free);
g_signal_connect (item, "activate",
G_CALLBACK (blank_disc_activate_cb), window);
items = g_list_append (items, item);
}
/* - library should be able to checksum
* - disc must have a data session */
if (brasero_burn_library_can_checksum ()
&& (media & BRASERO_MEDIUM_HAS_DATA)) {
/* ... or verify medium. */
item = nautilus_menu_item_new ("NautilusDiscBurn::check_disc",
_("_Check Disc…"),
_("Check the data integrity on this CD or DVD"),
NULL);
g_object_set_data (G_OBJECT (item), "file_info", file_info);
g_object_set_data (G_OBJECT (item), "window", window);
g_object_set_data_full (G_OBJECT (item), "drive_device_path", g_strdup (device_path), g_free);
g_signal_connect (item, "activate",
G_CALLBACK (check_disc_activate_cb),
window);
items = g_list_append (items, item);
}
g_free (device_path);
}
g_object_unref (file);
if (drive != NULL) {
g_object_unref (drive);
}
if (volume != NULL) {
g_object_unref (volume);
}
g_free (mime_type);
DEBUG_PRINT ("Items returned\n");
return items;
}
