static void * gio_fopen (const char * filename, const char * mode)
{
GError * error = 0;
FileData * data = g_new0 (FileData, 1);
data->file = g_file_new_for_uri (filename);
switch (mode[0])
{
case 'r':
if (strchr (mode, '+'))
{
data->iostream = (GIOStream *) g_file_open_readwrite (data->file, 0, & error);
CHECK_ERROR ("open", filename);
data->istream = g_io_stream_get_input_stream (data->iostream);
data->ostream = g_io_stream_get_output_stream (data->iostream);
data->seekable = (GSeekable *) data->iostream;
}
else
{
data->istream = (GInputStream *) g_file_read (data->file, 0, & error);
CHECK_ERROR ("open", filename);
data->seekable = (GSeekable *) data->istream;
}
break;
case 'w':
if (strchr (mode, '+'))
{
data->iostream = (GIOStream *) g_file_replace_readwrite (data->file, 0, 0, 0, 0, & error);
CHECK_ERROR ("open", filename);
data->istream = g_io_stream_get_input_stream (data->iostream);
data->ostream = g_io_stream_get_output_stream (data->iostream);
data->seekable = (GSeekable *) data->iostream;
}
else
{
data->ostream = (GOutputStream *) g_file_replace (data->file, 0, 0, 0, 0, & error);
CHECK_ERROR ("open", filename);
data->seekable = (GSeekable *) data->ostream;
}
break;
case 'a':
if (strchr (mode, '+'))
{
gio_error ("Cannot open %s: GIO does not support read-and-append mode.", filename);
goto FAILED;
}
else
{
data->ostream = (GOutputStream *) g_file_append_to (data->file, 0, 0, & error);
CHECK_ERROR ("open", filename);
data->seekable = (GSeekable *) data->ostream;
}
break;
default:
gio_error ("Cannot open %s: invalid mode.", filename);
goto FAILED;
}
return data;
FAILED:
g_free (data);
return 0;
}
/**
* Start file open operation, mount volume when needed and according to file type
* create file output stream or read directory content.
* @return NS_OK when file or directory opened successfully, error code otherwise
*/
nsresult
nsGIOInputStream::DoOpen()
{
nsresult rv;
GError *error = nullptr;
NS_ASSERTION(mHandle == nullptr, "already open");
mHandle = g_file_new_for_uri( mSpec.get() );
GFileInfo *info = g_file_query_info(mHandle,
"standard::*",
G_FILE_QUERY_INFO_NONE,
nullptr,
&error);
if (error) {
if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_MOUNTED) {
// location is not yet mounted, try to mount
g_error_free(error);
if (NS_IsMainThread())
return NS_ERROR_NOT_CONNECTED;
error = nullptr;
rv = MountVolume();
if (rv != NS_OK) {
return rv;
}
// get info again
info = g_file_query_info(mHandle,
"standard::*",
G_FILE_QUERY_INFO_NONE,
nullptr,
&error);
// second try to get file info from remote files after media mount
if (!info) {
g_warning("Unable to get file info: %s", error->message);
rv = MapGIOResult(error);
g_error_free(error);
return rv;
}
} else {
g_warning("Unable to get file info: %s", error->message);
rv = MapGIOResult(error);
g_error_free(error);
return rv;
}
}
// Get file type to handle directories and file differently
GFileType f_type = g_file_info_get_file_type(info);
if (f_type == G_FILE_TYPE_DIRECTORY) {
// directory
rv = DoOpenDirectory();
} else if (f_type != G_FILE_TYPE_UNKNOWN) {
// file
rv = DoOpenFile(info);
} else {
g_warning("Unable to get file type.");
rv = NS_ERROR_FILE_NOT_FOUND;
}
if (info)
g_object_unref(info);
return rv;
}
/* This is based on nautilus_compute_title_for_uri() and
* nautilus_file_get_display_name_nocopy() */
char *
panel_util_get_label_for_uri (const char *text_uri)
{
GFile *file;
char *label;
GFile *root;
char *root_display;
/* Here's what we do:
* + x-nautilus-search: URI
* + check if the URI is a mount
* + if file: URI:
* - check for known file: URI
* - check for description of the GFile
* - use display name of the GFile
* + else:
* - check for description of the GFile
* - if the URI is a root: "root displayname"
* - else: "root displayname: displayname"
*/
label = NULL;
//FIXME: see nautilus_query_to_readable_string() to have a nice name
if (g_str_has_prefix (text_uri, "x-nautilus-search:"))
return g_strdup (_("Search"));
file = g_file_new_for_uri (text_uri);
label = panel_util_get_file_display_name_if_mount (file);
if (label) {
g_object_unref (file);
return label;
}
if (g_str_has_prefix (text_uri, "file:")) {
label = panel_util_get_file_display_for_common_files (file);
if (!label)
label = panel_util_get_file_description (file);
if (!label)
label = panel_util_get_file_display_name (file, TRUE);
g_object_unref (file);
return label;
}
label = panel_util_get_file_description (file);
if (label) {
g_object_unref (file);
return label;
}
root = panel_util_get_gfile_root (file);
root_display = panel_util_get_file_description (root);
if (!root_display)
root_display = panel_util_get_file_display_name (root, FALSE);
if (!root_display)
/* can happen with URI schemes non supported by gvfs */
root_display = g_file_get_uri_scheme (root);
if (g_file_equal (file, root))
label = root_display;
else {
char *displayname;
displayname = panel_util_get_file_display_name (file, TRUE);
/* Translators: the first string is the name of a gvfs
* method, and the second string is a path. For
* example, "Trash: some-directory". It means that the
* directory called "some-directory" is in the trash.
*/
label = g_strdup_printf (_("%1$s: %2$s"),
root_display, displayname);
g_free (root_display);
g_free (displayname);
}
g_object_unref (root);
g_object_unref (file);
return label;
}
static void
panel_place_menu_item_append_gtk_bookmarks (GtkWidget *menu)
{
typedef struct {
char *full_uri;
char *label;
} PanelBookmark;
GtkWidget *add_menu;
char *filename;
GIOChannel *io_channel;
GHashTable *table;
int i;
GSList *lines = NULL;
GSList *add_bookmarks, *l;
PanelBookmark *bookmark;
filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
io_channel = g_io_channel_new_file (filename, "r", NULL);
g_free (filename);
if (!io_channel)
return;
/* We use a hard limit to avoid having users shooting their
* own feet, and to avoid crashing the system if a misbehaving
* application creates a big bookmars file.
*/
for (i = 0; i < MAX_BOOKMARK_ITEMS; i++) {
char *contents;
gsize length;
gsize terminator_pos;
GIOStatus status;
status = g_io_channel_read_line (io_channel, &contents, &length, &terminator_pos, NULL);
if (status != G_IO_STATUS_NORMAL)
break;
if (length == 0)
break;
/* Clear the line terminator (\n), if any */
if (terminator_pos > 0)
contents[terminator_pos] = '\0';
lines = g_slist_prepend (lines, contents);
}
g_io_channel_shutdown (io_channel, FALSE, NULL);
g_io_channel_unref (io_channel);
if (!lines)
return;
lines = g_slist_reverse (lines);
table = g_hash_table_new (g_str_hash, g_str_equal);
add_bookmarks = NULL;
for (l = lines; l; l = l->next) {
char *line = (char*) l->data;
if (line[0] && !g_hash_table_lookup (table, line)) {
GFile *file;
char *space;
char *label;
gboolean keep;
g_hash_table_insert (table, line, line);
space = strchr (line, ' ');
if (space) {
*space = '\0';
label = g_strdup (space + 1);
} else {
label = NULL;
}
keep = FALSE;
if (g_str_has_prefix (line, "x-caja-search:"))
keep = TRUE;
if (!keep) {
file = g_file_new_for_uri (line);
keep = !g_file_is_native (file) ||
g_file_query_exists (file, NULL);
g_object_unref (file);
}
if (!keep) {
if (label)
g_free (label);
continue;
}
bookmark = g_malloc (sizeof (PanelBookmark));
bookmark->full_uri = g_strdup (line);
bookmark->label = label;
add_bookmarks = g_slist_prepend (add_bookmarks, bookmark);
}
}
g_hash_table_destroy (table);
g_slist_foreach (lines, (GFunc) g_free, NULL);
g_slist_free (lines);
add_bookmarks = g_slist_reverse (add_bookmarks);
if (g_slist_length (add_bookmarks) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_BOOKMARKS, NULL, NULL,
_("Bookmarks"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (l = add_bookmarks; l; l = l->next) {
char *display_name;
char *tooltip;
char *label;
char *icon;
GFile *file;
GIcon *gicon;
bookmark = l->data;
file = g_file_new_for_uri (bookmark->full_uri);
display_name = g_file_get_parse_name (file);
g_object_unref (file);
/* Translators: %s is a URI */
tooltip = g_strdup_printf (_("Open '%s'"), display_name);
g_free (display_name);
label = NULL;
if (bookmark->label) {
label = g_strdup (g_strstrip (bookmark->label));
if (!label [0]) {
g_free (label);
label = NULL;
}
}
if (!label) {
label = panel_util_get_label_for_uri (bookmark->full_uri);
if (!label) {
g_free (tooltip);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
continue;
}
}
icon = panel_util_get_icon_for_uri (bookmark->full_uri);
/*FIXME: we should probably get a GIcon if possible, so that we
* have customized icons for cd-rom, eg */
if (!icon)
icon = g_strdup (PANEL_ICON_FOLDER);
gicon = g_themed_icon_new_with_default_fallbacks (icon);
//FIXME: drag and drop will be broken for x-caja-search uris
panel_menu_items_append_place_item (icon, gicon,
label,
tooltip,
add_menu,
G_CALLBACK (activate_uri),
bookmark->full_uri);
g_free (icon);
g_object_unref (gicon);
g_free (tooltip);
g_free (label);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
}
g_slist_free (add_bookmarks);
}
static gboolean
xmms_gvfs_init (xmms_xform_t *xform)
{
xmms_gvfs_data_t *data;
GFile *file;
GFileInfo *info;
GFileInputStream *handle;
GError *error = NULL;
const gchar *url;
url = xmms_xform_indata_get_str (xform, XMMS_STREAM_TYPE_URL);
g_return_val_if_fail (url, FALSE);
/* This is an ugly hack to handle files with
chars needing url encoding */
if (!g_ascii_strncasecmp (url, "file://", 7)) {
file = g_file_new_for_path (url+7);
} else {
file = g_file_new_for_uri (url);
}
handle = g_file_read (file, NULL, &error);
g_object_unref (file);
if (!handle) {
xmms_log_error ("Failed to upen url %s for reading: %s",
url, error->message);
return FALSE;
}
data = g_new (xmms_gvfs_data_t, 1);
data->handle = G_INPUT_STREAM (handle);
xmms_xform_private_data_set (xform, data);
info = g_file_input_stream_query_info (handle, (char *)query_attributes,
NULL, &error);
if (!info) {
xmms_log_info ("failed to query information for %s", url);
} else {
int i;
for (i = 0; i < G_N_ELEMENTS (attr_map); i++) {
if (!g_file_info_has_attribute (info, attr_map[i].gvfs)) {
continue;
}
switch (attr_map[i].type) {
case XMMSV_TYPE_STRING: {
gchar *attr = g_file_info_get_attribute_as_string (info,
attr_map[i].gvfs);
xmms_xform_metadata_set_str (xform, attr_map[i].mlib, attr);
g_free (attr);
break;
}
case XMMSV_TYPE_INT32: {
/* right now the xform metadata api only handles strings
* and 32 bit ints. however the gvfs api returns uint64 for
* the numeric attributes we're interested in and we just
* pass that to the xform and pray that it doesn't overflow
* as we know it's unsafe.
*/
gint64 attr = g_file_info_get_attribute_uint64 (info,
attr_map[i].gvfs);
xmms_xform_metadata_set_int (xform, attr_map[i].mlib, attr);
break;
}
default:
g_assert_not_reached ();
}
}
g_object_unref (info);
}
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"application/octet-stream",
XMMS_STREAM_TYPE_END);
return TRUE;
}
extern void desktop_run_in_terminal(char* executable);
extern char* dentry_get_uri(Entry* e);
Test({
GFile* f = g_file_new_for_uri("file:///tmp/test_files/skype.desktop");
char* s = dentry_get_uri(f);
// desktop_run_in_terminal(s);//Warning:!!!!! : don't test it , it will open terminal alltimes
g_free(s);
g_object_unref(f);
},"desktop_run_in_terminal");
#if 0
extern gboolean activate_file (GFile* file, const char* content_type, gboolean is_executable, GFile* _file_arg);
Test({
g_message("activate_file start");
GFile* f = g_file_new_for_uri("file:///tmp/test_files/skype.desktop");
ArrayContainer fs;
fs.data=&f;
fs.num = 1;
// g_message("file is GFile");
#if 1
gboolean launch_res = TRUE;
GFileInfo* info = g_file_query_info(f, "standard::content-type,access::can-execute", G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (info != NULL) {
const char* content_type = g_file_info_get_attribute_string(info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
gboolean is_executable = g_file_info_get_attribute_boolean(info, "access::can-execute");
//ugly hack here. we just read the first GFile*.
GFile* _file_arg = NULL;
ArrayContainer _fs;
GFile** files = NULL;
/**
* tracker_media_art_get_path:
* @artist: the artist
* @title: the title
* @prefix: For example "album"
* @uri: NULL or the uri of the file
* @path: the location to store the local path
* @local_uri: the location to store the local uri or NULL
*
* Get the path to media art for a given resource. Newly allocated data in
* @path and @local_uri must be freed with g_free.
*
* Since: 0.10.14
*/
void
tracker_media_art_get_path (const gchar *artist,
const gchar *title,
const gchar *prefix,
const gchar *uri,
gchar **path,
gchar **local_uri)
{
const gchar *space_checksum = "7215ee9c7d9dc229d2921a40e899ec5f";
const gchar *a, *b;
gchar *art_filename;
gchar *dir;
gchar *artist_down, *title_down;
gchar *artist_stripped, *title_stripped;
gchar *artist_norm, *title_norm;
gchar *artist_checksum = NULL, *title_checksum = NULL;
/* http://live.gnome.org/MediaArtStorageSpec */
if (path) {
*path = NULL;
}
if (local_uri) {
*local_uri = NULL;
}
if (!artist && !title) {
return;
}
if (artist) {
artist_stripped = tracker_media_art_strip_invalid_entities (artist);
artist_norm = g_utf8_normalize (artist_stripped, -1, G_NORMALIZE_NFKD);
artist_down = g_utf8_strdown (artist_norm, -1);
artist_checksum = media_art_checksum_for_data (G_CHECKSUM_MD5,
(const guchar *) artist_down,
strlen (artist_down));
}
if (title) {
title_stripped = tracker_media_art_strip_invalid_entities (title);
title_norm = g_utf8_normalize (title_stripped, -1, G_NORMALIZE_NFKD);
title_down = g_utf8_strdown (title_norm, -1);
title_checksum = media_art_checksum_for_data (G_CHECKSUM_MD5,
(const guchar *) title_down,
strlen (title_down));
}
dir = g_build_filename (g_get_user_cache_dir (),
"media-art",
NULL);
if (!g_file_test (dir, G_FILE_TEST_EXISTS)) {
g_mkdir_with_parents (dir, 0770);
}
if (artist) {
a = artist_checksum;
b = title ? title_checksum : space_checksum;
} else {
a = title_checksum;
b = space_checksum;
}
art_filename = g_strdup_printf ("%s-%s-%s.jpeg", prefix ? prefix : "album", a, b);
if (artist) {
g_free (artist_checksum);
g_free (artist_stripped);
g_free (artist_down);
g_free (artist_norm);
}
if (title) {
g_free (title_checksum);
g_free (title_stripped);
g_free (title_down);
g_free (title_norm);
}
if (path) {
*path = g_build_filename (dir, art_filename, NULL);
}
if (local_uri) {
gchar *local_dir;
GFile *file, *parent;
if (strstr (uri, "://")) {
file = g_file_new_for_uri (uri);
} else {
file = g_file_new_for_path (uri);
}
parent = g_file_get_parent (file);
if (parent) {
local_dir = g_file_get_uri (parent);
/* This is a URI, don't use g_build_filename here */
*local_uri = g_strdup_printf ("%s/.mediaartlocal/%s", local_dir, art_filename);
g_free (local_dir);
g_object_unref (parent);
}
g_object_unref (file);
}
g_free (dir);
g_free (art_filename);
}
/* serverside */
static void
on_message_received (const char *message,
gpointer data)
{
const PlumaEncoding *encoding = NULL;
gchar **commands;
gchar **params;
gint workspace;
gint viewport_x;
gint viewport_y;
gchar *display_name;
gint screen_number;
gint i;
PlumaApp *app;
PlumaWindow *window;
GdkDisplay *display;
GdkScreen *screen;
g_return_if_fail (message != NULL);
pluma_debug_message (DEBUG_APP, "Received message:\n%s\n", message);
commands = g_strsplit (message, "\v", -1);
/* header */
params = g_strsplit (commands[0], "\t", 6);
startup_timestamp = atoi (params[0]);
display_name = params[1];
screen_number = atoi (params[2]);
workspace = atoi (params[3]);
viewport_x = atoi (params[4]);
viewport_y = atoi (params[5]);
display = display_open_if_needed (display_name);
if (display == NULL)
{
g_warning ("Could not open display %s\n", display_name);
g_strfreev (params);
goto out;
}
screen = gdk_display_get_screen (display, screen_number);
g_strfreev (params);
/* body */
for (i = 1; commands[i] != NULL; i++)
{
params = g_strsplit (commands[i], "\t", -1);
if (strcmp (params[0], "NEW-WINDOW") == 0)
{
new_window_option = TRUE;
}
else if (strcmp (params[0], "NEW-DOCUMENT") == 0)
{
new_document_option = TRUE;
}
else if (strcmp (params[0], "OPEN-URIS") == 0)
{
gint n_uris, j;
gchar **uris;
line_position = atoi (params[1]);
if (params[2] != '\0')
encoding = pluma_encoding_get_from_charset (params[2]);
n_uris = atoi (params[3]);
uris = g_strsplit (params[4], " ", n_uris);
for (j = 0; j < n_uris; j++)
{
GFile *file;
file = g_file_new_for_uri (uris[j]);
file_list = g_slist_prepend (file_list, file);
}
file_list = g_slist_reverse (file_list);
/* the list takes ownerhip of the strings,
* only free the array */
g_free (uris);
}
else
{
g_warning ("Unexpected bacon command");
}
g_strfreev (params);
}
/* execute the commands */
app = pluma_app_get_default ();
if (new_window_option)
{
window = pluma_app_create_window (app, screen);
}
else
{
/* get a window in the current workspace (if exists) and raise it */
window = _pluma_app_get_window_in_viewport (app,
screen,
workspace,
viewport_x,
viewport_y);
}
if (file_list != NULL)
{
_pluma_cmd_load_files_from_prompt (window,
file_list,
encoding,
line_position);
if (new_document_option)
pluma_window_create_tab (window, TRUE);
}
else
{
PlumaDocument *doc;
doc = pluma_window_get_active_document (window);
if (doc == NULL ||
!pluma_document_is_untouched (doc) ||
new_document_option)
pluma_window_create_tab (window, TRUE);
}
/* set the proper interaction time on the window.
* Fall back to roundtripping to the X server when we
* don't have the timestamp, e.g. when launched from
* terminal. We also need to make sure that the window
* has been realized otherwise it will not work. lame.
*/
if (!gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_widget_realize (GTK_WIDGET (window));
if (startup_timestamp <= 0)
startup_timestamp = gdk_x11_get_server_time (gtk_widget_get_window (GTK_WIDGET (window)));
gdk_x11_window_set_user_time (gtk_widget_get_window (GTK_WIDGET (window)),
startup_timestamp);
gtk_window_present (GTK_WINDOW (window));
out:
g_strfreev (commands);
free_command_line_data ();
}
static int
gth_application_command_line (GApplication *application,
GApplicationCommandLine *command_line)
{
char **argv;
int argc;
GOptionContext *context;
GError *error = NULL;
const char *arg;
int i;
GList *files;
GList *dirs;
GFile *location;
gboolean singleton;
GList *scan;
argv = g_application_command_line_get_arguments (command_line, &argc);
/* parse command line options */
context = gth_application_create_option_context ();
if (! g_option_context_parse (context, &argc, &argv, &error)) {
g_critical ("Failed to parse arguments: %s", error->message);
g_error_free (error);
g_option_context_free (context);
return EXIT_FAILURE;
}
g_option_context_free (context);
g_strfreev (argv);
gdk_notify_startup_complete ();
/* exec the command line */
if (ImportPhotos) {
GFile *location = NULL;
if (remaining_args != NULL)
location = g_file_new_for_commandline_arg (remaining_args[0]);
import_photos_from_location (location);
return 0;
}
if (remaining_args == NULL) { /* No location specified. */
GFile *location;
GSettings *settings;
char *file_to_select_uri;
GFile *file_to_select;
location = g_file_new_for_uri (gth_pref_get_startup_location ());
settings = g_settings_new (GTHUMB_BROWSER_SCHEMA);
file_to_select_uri = _g_settings_get_uri (settings, PREF_BROWSER_STARTUP_CURRENT_FILE);
if (file_to_select_uri != NULL)
file_to_select = g_file_new_for_uri (file_to_select_uri);
else
file_to_select = NULL;
open_browser_window (location, file_to_select, TRUE);
_g_object_unref (file_to_select);
g_free (file_to_select_uri);
g_object_unref (settings);
g_object_unref (location);
return 0;
}
/* At least a location was specified */
files = NULL;
dirs = NULL;
for (i = 0; (arg = remaining_args[i]) != NULL; i++) {
GFile *location;
GFileType file_type;
location = g_file_new_for_commandline_arg (arg);
file_type = _g_file_get_standard_type (location);
if (file_type == G_FILE_TYPE_REGULAR)
files = g_list_prepend (files, location);
else
dirs = g_list_prepend (dirs, location);
}
files = g_list_reverse (files);
dirs = g_list_reverse (dirs);
location = gth_hook_invoke_get ("command-line-files", files);
if (location != NULL) {
open_browser_window (location, NULL, FALSE);
g_object_unref (location);
}
else {
/* Open each file in a new window */
singleton = (files != NULL) && (files->next == NULL);
for (scan = files; scan; scan = scan->next)
open_browser_window ((GFile *) scan->data, NULL, ! singleton);
}
/* Open each dir in a new window */
for (scan = dirs; scan; scan = scan->next)
open_browser_window ((GFile *) scan->data, NULL, TRUE);
_g_object_list_unref (dirs);
_g_object_list_unref (files);
return 0;
}
static void
panel_place_menu_item_append_gtk_bookmarks (GtkWidget *menu)
{
typedef struct {
char *full_uri;
char *label;
} PanelBookmark;
GtkWidget *add_menu;
char *filename;
char *contents;
gchar **lines;
GHashTable *table;
int i;
GSList *add_bookmarks, *l;
PanelBookmark *bookmark;
filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
if (!g_file_get_contents (filename, &contents, NULL, NULL)) {
g_free (filename);
return;
}
g_free (filename);
lines = g_strsplit (contents, "\n", -1);
g_free (contents);
table = g_hash_table_new (g_str_hash, g_str_equal);
add_bookmarks = NULL;
for (i = 0; lines[i]; i++) {
if (lines[i][0] && !g_hash_table_lookup (table, lines[i])) {
GFile *file;
char *space;
char *label;
gboolean keep;
g_hash_table_insert (table, lines[i], lines[i]);
space = strchr (lines[i], ' ');
if (space) {
*space = '\0';
label = g_strdup (space + 1);
} else {
label = NULL;
}
keep = FALSE;
if (g_str_has_prefix (lines[i], "x-nautilus-search:"))
keep = TRUE;
if (!keep) {
file = g_file_new_for_uri (lines[i]);
keep = !g_file_is_native (file) ||
g_file_query_exists (file, NULL);
g_object_unref (file);
}
if (!keep) {
if (label)
g_free (label);
continue;
}
bookmark = g_malloc (sizeof (PanelBookmark));
bookmark->full_uri = g_strdup (lines[i]);
bookmark->label = label;
add_bookmarks = g_slist_prepend (add_bookmarks, bookmark);
}
}
g_hash_table_destroy (table);
g_strfreev (lines);
add_bookmarks = g_slist_reverse (add_bookmarks);
if (g_slist_length (add_bookmarks) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_BOOKMARKS, NULL, NULL,
_("Bookmarks"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (l = add_bookmarks; l; l = l->next) {
char *display_name;
char *tooltip;
char *label;
char *icon;
GFile *file;
bookmark = l->data;
file = g_file_new_for_uri (bookmark->full_uri);
display_name = g_file_get_parse_name (file);
g_object_unref (file);
/* Translators: %s is a URI */
tooltip = g_strdup_printf (_("Open '%s'"), display_name);
g_free (display_name);
label = NULL;
if (bookmark->label) {
label = g_strdup (g_strstrip (bookmark->label));
if (!label [0]) {
g_free (label);
label = NULL;
}
}
if (!label) {
label = panel_util_get_label_for_uri (bookmark->full_uri);
if (!label) {
g_free (tooltip);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
continue;
}
}
icon = panel_util_get_icon_for_uri (bookmark->full_uri);
/*FIXME: we should probably get a GIcon if possible, so that we
* have customized icons for cd-rom, eg */
if (!icon)
icon = g_strdup (PANEL_ICON_FOLDER);
//FIXME: drag and drop will be broken for x-nautilus-search uris
panel_menu_items_append_place_item (icon, NULL,
label,
tooltip,
add_menu,
G_CALLBACK (activate_uri),
bookmark->full_uri);
g_free (icon);
g_free (tooltip);
g_free (label);
g_free (bookmark->full_uri);
if (bookmark->label)
g_free (bookmark->label);
g_free (bookmark);
}
g_slist_free (add_bookmarks);
}
void
Tetris::dragDrop(GtkWidget *widget, GdkDragContext *context,
gint x, gint y, GtkSelectionData *data, guint info,
guint time, Tetris * t)
{
const char *fileuri;
GError *error = NULL;
GFile *file;
GFile *outfile;
GFileInfo *fileinfo;
GFileInputStream *istream;
GFileOutputStream *outstream;
goffset filesize;
gssize bytesread, byteswrote;
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf;
guchar *buffer;
/* Accept a dropped filename and try and load it as the
background image. In the event of any kind of failure we
silently ignore it. */
/* FIXME: We don't handle colour gradients (e.g. from the gimp) */
/* FIXME: Dropped URLs from mozilla don't work (see below). */
if (data->length < 0) {
gtk_drag_finish (context, FALSE, FALSE, time);
return;
}
gtk_drag_finish (context, TRUE, FALSE, time);
if (info == COLOUR) {
if (data->length == 8)
decodeColour ((guint16 *)data->data, t);
return;
}
if (info == RESET) {
resetColour (t);
return;
}
fileuri = decodeDropData ((char *)data->data, info);
/* Silently ignore bad data. */
if (fileuri == NULL)
goto error_exit;
/* Now that we have a URI we load it and test it to see if it is
* an image file. */
file = g_file_new_for_uri (fileuri);
istream = g_file_read (file, NULL, &error);
if (error)
goto error_exit;
fileinfo = g_file_input_stream_query_info (istream, (char *)G_FILE_ATTRIBUTE_STANDARD_SIZE, NULL, &error);
if (error)
goto error_exit_handle;
filesize = g_file_info_get_size (fileinfo);
buffer = (guchar *)g_malloc (filesize);
if (buffer == NULL)
goto error_exit_handle;
bytesread = g_input_stream_read (G_INPUT_STREAM (istream), buffer, filesize, NULL, &error);
/* FIXME: We should reread if not enough was read. */
if (error || (bytesread != filesize))
goto error_exit_buffer;
loader = gdk_pixbuf_loader_new ();
if (!gdk_pixbuf_loader_write (loader, buffer, filesize, NULL))
goto error_exit_loader;
gdk_pixbuf_loader_close (loader, NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf == NULL)
goto error_exit_loader;
g_object_ref (pixbuf);
/* We now have an image file, in memory, that we know gdk-pixbuf
* can handle. Now we save it to disk. This is necessary so that
* "slow" URIs (e.g. http) behave well in the long run. */
outfile = g_file_new_for_path (t->bgPixmap);
outstream = g_file_replace (outfile, NULL, FALSE, G_FILE_CREATE_PRIVATE,
NULL, &error);
if (error)
goto error_exit_loader;
byteswrote = g_output_stream_write (G_OUTPUT_STREAM (outstream), buffer,
bytesread, NULL, &error);
if (byteswrote != filesize)
goto error_exit_saver;
t->usebg = TRUE;
t->saveBgOptions ();
error_exit_saver:
g_object_unref(outstream);
error_exit_loader:
g_object_unref (loader);
error_exit_buffer:
g_free (buffer);
error_exit_handle:
g_object_unref(istream);
error_exit:
if(error)
g_error_free(error);
return;
}
static void
drag_data_received_callback (GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
guint info,
guint32 time,
gpointer callback_data)
{
char **names;
NemoApplication *application;
int name_count;
NemoWindow *new_window, *window;
GdkScreen *screen;
gboolean new_windows_for_extras;
char *prompt;
char *detail;
GFile *location;
NemoLocationBar *self = NEMO_LOCATION_BAR (widget);
g_assert (data != NULL);
g_assert (callback_data == NULL);
names = g_uri_list_extract_uris ((const gchar *) gtk_selection_data_get_data (data));
if (names == NULL || *names == NULL) {
g_warning ("No D&D URI's");
g_strfreev (names);
gtk_drag_finish (context, FALSE, FALSE, time);
return;
}
window = nemo_location_bar_get_window (widget);
new_windows_for_extras = FALSE;
/* Ask user if they really want to open multiple windows
* for multiple dropped URIs. This is likely to have been
* a mistake.
*/
name_count = g_strv_length (names);
if (name_count > 1) {
prompt = g_strdup_printf (ngettext("Do you want to view %d location?",
"Do you want to view %d locations?",
name_count),
name_count);
detail = g_strdup_printf (ngettext("This will open %d separate window.",
"This will open %d separate windows.",
name_count),
name_count);
/* eel_run_simple_dialog should really take in pairs
* like gtk_dialog_new_with_buttons() does. */
new_windows_for_extras = eel_run_simple_dialog
(GTK_WIDGET (window),
TRUE,
GTK_MESSAGE_QUESTION,
prompt,
detail,
GTK_STOCK_CANCEL, GTK_STOCK_OK,
NULL) != 0 /* GNOME_OK */;
g_free (prompt);
g_free (detail);
if (!new_windows_for_extras) {
g_strfreev (names);
gtk_drag_finish (context, FALSE, FALSE, time);
return;
}
}
nemo_location_bar_set_location (self, names[0]);
emit_location_changed (self);
if (new_windows_for_extras) {
int i;
application = nemo_application_get_singleton ();
screen = gtk_window_get_screen (GTK_WINDOW (window));
for (i = 1; names[i] != NULL; ++i) {
new_window = nemo_application_create_window (application, screen);
location = g_file_new_for_uri (names[i]);
nemo_window_go_to (new_window, location);
g_object_unref (location);
}
}
g_strfreev (names);
gtk_drag_finish (context, TRUE, FALSE, time);
}
static void
catalog_new_dialog_response_cb (GtkWidget *dialog,
int response_id,
gpointer user_data)
{
GthBrowser *browser = user_data;
char *name;
GthFileData *selected_parent;
GFile *parent;
GthFileSource *file_source;
GFile *gio_parent;
char *display_name;
GError *error = NULL;
GFile *gio_file;
if (response_id != GTK_RESPONSE_OK) {
gtk_widget_destroy (dialog);
return;
}
name = gth_request_dialog_get_normalized_text (GTH_REQUEST_DIALOG (dialog));
if (_g_utf8_all_spaces (name)) {
g_free (name);
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, _("No name specified"));
return;
}
if (g_regex_match_simple ("/", name, 0, 0)) {
char *message;
message = g_strdup_printf (_("Invalid name. The following characters are not allowed: %s"), "/");
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, message);
g_free (message);
g_free (name);
return;
}
selected_parent = gth_browser_get_folder_popup_file_data (browser);
if (selected_parent != NULL) {
GthFileSource *file_source;
GFileInfo *info;
file_source = gth_main_get_file_source (selected_parent->file);
info = gth_file_source_get_file_info (file_source, selected_parent->file, GFILE_BASIC_ATTRIBUTES);
if (g_file_info_get_attribute_boolean (info, "gthumb::no-child"))
parent = g_file_get_parent (selected_parent->file);
else
parent = g_file_dup (selected_parent->file);
g_object_unref (info);
g_object_unref (file_source);
}
else
parent = g_file_new_for_uri ("catalog:///");
file_source = gth_main_get_file_source (parent);
gio_parent = gth_file_source_to_gio_file (file_source, parent);
display_name = g_strconcat (name, ".catalog", NULL);
gio_file = g_file_get_child_for_display_name (gio_parent, display_name, &error);
if (gio_file != NULL) {
GFileOutputStream *stream;
stream = g_file_create (gio_file, G_FILE_CREATE_NONE, NULL, &error);
if (stream != NULL) {
GFile *file;
GList *list;
file = gth_catalog_file_from_gio_file (gio_file, NULL);
list = g_list_prepend (NULL, file);
gth_monitor_folder_changed (gth_main_get_default_monitor (),
parent,
list,
GTH_MONITOR_EVENT_CREATED);
g_list_free (list);
g_object_unref (file);
g_object_unref (stream);
}
g_object_unref (gio_file);
}
if (error != NULL) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS))
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, _("Name already used"));
else
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, error->message);
g_clear_error (&error);
}
else
gtk_widget_destroy (dialog);
g_free (display_name);
g_object_unref (gio_parent);
g_object_unref (file_source);
g_free (name);
}
static void
jpeg_thumbnailer_create (TumblerAbstractThumbnailer *thumbnailer,
GCancellable *cancellable,
TumblerFileInfo *info)
{
TumblerThumbnailFlavor *flavor;
TumblerImageData data;
TumblerThumbnail *thumbnail;
struct stat statb;
const gchar *uri;
GdkPixbuf *pixbuf = NULL;
gboolean streaming_needed = TRUE;
JOCTET *content;
GError *error = NULL;
GFile *file;
gchar *path;
gsize length;
gint fd;
gint height;
gint width;
gint size;
g_return_if_fail (IS_JPEG_THUMBNAILER (thumbnailer));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
g_return_if_fail (TUMBLER_IS_FILE_INFO (info));
/* do nothing if cancelled */
if (g_cancellable_is_cancelled (cancellable))
return;
uri = tumbler_file_info_get_uri (info);
/* try to open the source file for reading */
file = g_file_new_for_uri (uri);
thumbnail = tumbler_file_info_get_thumbnail (info);
g_assert (thumbnail != NULL);
flavor = tumbler_thumbnail_get_flavor (thumbnail);
g_assert (flavor != NULL);
tumbler_thumbnail_flavor_get_size (flavor, &width, &height);
size = MIN (width, height);
#ifdef HAVE_MMAP
if (g_file_is_native (file))
{
path = g_file_get_path (file);
/* try to open the file at the given path */
fd = open (path, O_RDONLY);
if (G_LIKELY (fd >= 0))
{
/* determine the status of the file */
if (G_LIKELY (fstat (fd, &statb) == 0 && statb.st_size > 0))
{
/* try to mmap the file */
content = (JOCTET *) mmap (NULL, statb.st_size, PROT_READ,
MAP_SHARED, fd, 0);
/* verify whether the mmap was successful */
if (G_LIKELY (content != (JOCTET *) MAP_FAILED))
{
/* try to load the embedded thumbnail first */
pixbuf = tvtj_jpeg_load_thumbnail (content, statb.st_size, size);
if (pixbuf == NULL)
{
/* fall back to loading and scaling the image itself */
pixbuf = tvtj_jpeg_load (content, statb.st_size, size);
if (pixbuf == NULL)
{
g_set_error (&error, TUMBLER_ERROR,
TUMBLER_ERROR_INVALID_FORMAT,
_("Thumbnail could not be inferred from file contents"));
}
}
/* we have successfully mmapped the file. we may not have
* a thumbnail but trying to read the image from a stream
* won't help us here, so we don't need to attempt streaming
* as a fallback */
streaming_needed = FALSE;
}
/* unmap the file content */
munmap ((void *) content, statb.st_size);
}
/* close the file */
close (fd);
}
g_free (path);
}
#endif
if (streaming_needed)
{
g_file_load_contents (file, cancellable, (gchar **)&content, &length,
NULL, &error);
if (error == NULL)
{
pixbuf = tvtj_jpeg_load_thumbnail (content, length, size);
if (pixbuf == NULL)
{
pixbuf = tvtj_jpeg_load (content, length, size);
if (pixbuf == NULL)
{
g_set_error (&error, TUMBLER_ERROR, TUMBLER_ERROR_INVALID_FORMAT,
_("Thumbnail could not be inferred from file contents"));
}
}
}
}
/* either we have an error now or we have a valid thumbnail pixbuf */
g_assert (error != NULL || pixbuf != NULL);
if (pixbuf != NULL)
{
data.data = gdk_pixbuf_get_pixels (pixbuf);
data.has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
data.bits_per_sample = gdk_pixbuf_get_bits_per_sample (pixbuf);
data.width = gdk_pixbuf_get_width (pixbuf);
data.height = gdk_pixbuf_get_height (pixbuf);
data.rowstride = gdk_pixbuf_get_rowstride (pixbuf);
data.colorspace = (TumblerColorspace) gdk_pixbuf_get_colorspace (pixbuf);
tumbler_thumbnail_save_image_data (thumbnail, &data,
tumbler_file_info_get_mtime (info),
NULL, &error);
g_object_unref (pixbuf);
}
if (error != NULL)
{
g_signal_emit_by_name (thumbnailer, "error", uri, error->code, error->message);
g_error_free (error);
}
else
{
g_signal_emit_by_name (thumbnailer, "ready", uri);
}
g_object_unref (flavor);
g_object_unref (thumbnail);
g_object_unref (file);
}
GList *
_filter_out_unshowable_recent_items (PengeEverythingPane *pane,
ZeitgeistResultSet *set)
{
PengeEverythingPanePrivate *priv = GET_PRIVATE (pane);
GList *ret = NULL;
guint i; /* loop index */
/* probably an error (or an actual empty set, obv), we need to return empty
* list anyway */
if (set == NULL)
return NULL;
while (zeitgeist_result_set_has_next (set))
{
ZeitgeistEvent *event = NULL;
gchar *thumbnail_path = NULL;
/* We have to do this because we edit the list */
event = zeitgeist_result_set_next (set);
/* FIXME, so far this is the assumption, then we can use a better data
* structure for managing events with multiple subjects */
g_assert (zeitgeist_event_num_subjects (event) == 1);
for (i = 0; i < zeitgeist_event_num_subjects (event); ++i)
{
ZeitgeistSubject *s;
GFile *file;
const gchar *uri = NULL;
s = zeitgeist_event_get_subject (event, i);
g_assert (s != NULL);
uri = zeitgeist_subject_get_uri (s);
g_assert (uri != NULL);
/* Just a small debug help :)
g_warning ("%s: subj(%d): i=%s m=%s",
zeitgeist_subject_get_uri (s),
i,
zeitgeist_subject_get_interpretation (s),
zeitgeist_subject_get_manifestation (s));
*/
/* Current detault template look for local files only, if it's not local,
* it's probably a template error, log it and move on */
if (!g_str_has_prefix (uri, "file:"))
{
g_warning ("uri %s for recent event is not local", uri);
continue;
}
file = g_file_new_for_uri (uri);
/* if the file does not exist anymore we ignore it and move on */
if (!g_file_query_exists (file, NULL))
break; /* consider the next event */
thumbnail_path = mpl_utils_get_thumbnail_path (uri);
/* add to the return list only if it has a valid thumbnail */
if (thumbnail_path && g_file_test (thumbnail_path, G_FILE_TEST_EXISTS))
ret = g_list_prepend (ret, g_object_ref (event));
g_free (thumbnail_path);
g_object_unref (file);
}
}
return ret;
}
gboolean
nemo_link_local_create (const char *directory_uri,
const char *base_name,
const char *display_name,
const char *image,
const char *target_uri,
const GdkPoint *point,
int screen,
gboolean unique_filename)
{
char *real_directory_uri;
char *uri, *contents;
GFile *file;
GList dummy_list;
NemoFileChangesQueuePosition item;
g_return_val_if_fail (directory_uri != NULL, FALSE);
g_return_val_if_fail (base_name != NULL, FALSE);
g_return_val_if_fail (display_name != NULL, FALSE);
g_return_val_if_fail (target_uri != NULL, FALSE);
if (eel_uri_is_trash (directory_uri) ||
eel_uri_is_search (directory_uri)) {
return FALSE;
}
if (eel_uri_is_desktop (directory_uri)) {
real_directory_uri = nemo_get_desktop_directory_uri ();
} else {
real_directory_uri = g_strdup (directory_uri);
}
if (unique_filename) {
uri = nemo_ensure_unique_file_name (real_directory_uri,
base_name, ".desktop");
if (uri == NULL) {
g_free (real_directory_uri);
return FALSE;
}
file = g_file_new_for_uri (uri);
g_free (uri);
} else {
char *link_name;
GFile *dir;
link_name = g_strdup_printf ("%s.desktop", base_name);
/* replace '/' with '-', just in case */
g_strdelimit (link_name, "/", '-');
dir = g_file_new_for_uri (directory_uri);
file = g_file_get_child (dir, link_name);
g_free (link_name);
g_object_unref (dir);
}
g_free (real_directory_uri);
contents = g_strdup_printf ("[Desktop Entry]\n"
"Encoding=UTF-8\n"
"Name=%s\n"
"Type=Link\n"
"URL=%s\n"
"%s%s\n",
display_name,
target_uri,
image != NULL ? "Icon=" : "",
image != NULL ? image : "");
if (!g_file_replace_contents (file,
contents, strlen (contents),
NULL, FALSE,
G_FILE_CREATE_NONE,
NULL, NULL, NULL)) {
g_free (contents);
g_object_unref (file);
return FALSE;
}
g_free (contents);
dummy_list.data = file;
dummy_list.next = NULL;
dummy_list.prev = NULL;
nemo_directory_notify_files_added (&dummy_list);
if (point != NULL) {
item.location = file;
item.set = TRUE;
item.point.x = point->x;
item.point.y = point->y;
item.screen = screen;
dummy_list.data = &item;
dummy_list.next = NULL;
dummy_list.prev = NULL;
nemo_directory_schedule_position_set (&dummy_list);
}
g_object_unref (file);
return TRUE;
}
static void
terminal_nautilus_menu_item_activate (NautilusMenuItem *item)
{
TerminalNautilusMenuItem *menu_item = TERMINAL_NAUTILUS_MENU_ITEM (item);
TerminalNautilus *nautilus = menu_item->nautilus;
char *uri, *path;
TerminalFileInfo info;
ExecData *data;
uri = nautilus_file_info_get_activation_uri (menu_item->file_info);
if (uri == NULL)
return;
path = NULL;
info = get_terminal_file_info_from_uri (uri);
switch (info) {
case FILE_INFO_LOCAL:
path = g_filename_from_uri (uri, NULL, NULL);
break;
case FILE_INFO_DESKTOP:
if (desktop_is_home_dir (nautilus) || desktop_opens_home_dir (nautilus)) {
path = g_strdup (g_get_home_dir ());
} else {
path = g_strdup (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP));
}
break;
case FILE_INFO_SFTP:
if (menu_item->remote_terminal)
break;
/* fall through */
case FILE_INFO_OTHER: {
GFile *file;
/* map back remote URI to local path */
file = g_file_new_for_uri (uri);
path = g_file_get_path (file);
g_object_unref (file);
break;
}
default:
g_assert_not_reached ();
}
if (path == NULL && (info != FILE_INFO_SFTP || !menu_item->remote_terminal)) {
g_free (uri);
return;
}
data = g_new (ExecData, 1);
data->nautilus = g_object_ref (nautilus);
data->timestamp = gtk_get_current_event_time ();
data->path = path;
data->uri = uri;
data->display = gdk_screen_make_display_name (menu_item->screen);
data->info = info;
data->remote = menu_item->remote_terminal;
data->run_in_mc = menu_item->run_in_mc;
create_terminal (data);
}
static void
on_monitors_changed (MetaScreen *screen,
MetaPlugin *plugin)
{
MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
__attribute__ ((unused)) ClutterAnimation *animation;
int i, n;
gchar *wallpaper = NULL;
GFile *wallpaper_file = NULL;
gchar *filename = NULL;
GDesktopBackgroundStyle style;
GDesktopBackgroundShading shading_direction;
ClutterColor primary_color;
ClutterColor secondary_color;
gboolean random_colour = FALSE;
clutter_actor_destroy_all_children (self->priv->background_group);
wallpaper = g_settings_get_string (self->priv->settings, PICTURE_URI_KEY);
/* We don't currently support slideshows */
if (!wallpaper || g_str_has_suffix(wallpaper, ".xml"))
random_colour = TRUE;
else {
gchar *color_str;
/* Shading direction*/
shading_direction = g_settings_get_enum (self->priv->settings, COLOR_SHADING_TYPE_KEY);
/* Primary color */
color_str = g_settings_get_string (self->priv->settings, PRIMARY_COLOR_KEY);
if (color_str)
{
clutter_color_from_string (&primary_color, color_str);
g_free (color_str);
color_str = NULL;
}
/* Secondary color */
color_str = g_settings_get_string (self->priv->settings, SECONDARY_COLOR_KEY);
if (color_str)
{
clutter_color_from_string (&secondary_color, color_str);
g_free (color_str);
color_str = NULL;
}
/* Picture options: "none", "wallpaper", "centered", "scaled", "stretched", "zoom", "spanned" */
style = g_settings_get_enum (self->priv->settings, BACKGROUND_STYLE_KEY);
wallpaper_file = g_file_new_for_uri(wallpaper);
filename = g_file_get_path(wallpaper_file);
}
n = meta_screen_get_n_monitors (screen);
for (i = 0; i < n; i++)
{
MetaBackground *content;
MetaRectangle rect;
ClutterActor *background;
background = meta_background_actor_new ();
content = meta_background_new (screen,
i,
META_BACKGROUND_EFFECTS_NONE);
// Don't use rand() here, mesa calls srand() internally when
// parsing the driconf XML, but it's nice if the colors are
// reproducible.
if (random_colour)
{
clutter_color_init (&primary_color,
g_random_int () % 255,
g_random_int () % 255,
g_random_int () % 255,
255);
meta_background_load_color (content, &primary_color);
} else {
if (style == G_DESKTOP_BACKGROUND_STYLE_NONE ||
g_str_has_suffix (filename, GNOME_COLOR_HACK))
{
if (shading_direction == G_DESKTOP_BACKGROUND_SHADING_SOLID)
meta_background_load_color (content, &primary_color);
else
meta_background_load_gradient (content,
shading_direction,
&primary_color,
&secondary_color);
} else {
/* Set the background */
meta_background_load_file_async (content,
filename,
style,
NULL, /*TODO use cancellable*/
background_load_file_cb,
self);
}
}
clutter_actor_set_content (background, CLUTTER_CONTENT (content));
g_object_unref (content);
meta_screen_get_monitor_geometry (screen, i, &rect);
clutter_actor_set_position (background, rect.x, rect.y);
clutter_actor_set_size (background, rect.width, rect.height);
clutter_actor_add_child (self->priv->background_group, background);
clutter_actor_set_scale (background, 0.0, 0.0);
clutter_actor_show (background);
clutter_actor_set_pivot_point (background, 0.5, 0.5);
/* Ease in the background using a scale effect */
animation = clutter_actor_animate (background, CLUTTER_EASE_IN_SINE,
BACKGROUND_TIMEOUT,
"scale-x", 1.0,
"scale-y", 1.0,
NULL);
}
if (wallpaper_file)
g_object_unref(wallpaper_file);
g_free(wallpaper);
g_free(filename);
}
int
main (int argc, char *argv[])
{
GtkApplication *app;
GError *error = NULL;
GOptionContext *context;
GOptionGroup *debug;
gulong debug_flags = 0;
LifereaDBus *dbus = NULL;
gchar *feedUri = NULL;
gint status;
GOptionEntry entries[] = {
{ "mainwindow-state", 'w', 0, G_OPTION_ARG_STRING, &initialStateOption, N_("Start Liferea with its main window in STATE. STATE may be `shown', `iconified', or `hidden'"), N_("STATE") },
{ "version", 'v', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version, N_("Show version information and exit"), NULL },
{ "add-feed", 'a', 0, G_OPTION_ARG_STRING, &feedUri, N_("Add a new subscription"), N_("uri") },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
GOptionEntry debug_entries[] = {
{ "debug-all", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all types"), NULL },
{ "debug-cache", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the cache handling"), NULL },
{ "debug-conf", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the configuration handling"), NULL },
{ "debug-db", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the database handling"), NULL },
{ "debug-gui", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all GUI functions"), NULL },
{ "debug-html", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Enables HTML rendering debugging. Each time Liferea renders HTML output it will also dump the generated HTML into ~/.cache/liferea/output.xhtml"), NULL },
{ "debug-net", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all network activity"), NULL },
{ "debug-parsing", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all parsing functions"), NULL },
{ "debug-performance", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when a function takes too long to process"), NULL },
{ "debug-trace", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when entering/leaving functions"), NULL },
{ "debug-update", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the feed update processing"), NULL },
{ "debug-vfolder", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the search folder matching"), NULL },
{ "debug-verbose", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print verbose debugging messages"), NULL },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
debug = g_option_group_new ("debug",
_("Print debugging messages for the given topic"),
_("Print debugging messages for the given topic"),
&debug_flags,
NULL);
g_option_group_set_translation_domain(debug, GETTEXT_PACKAGE);
g_option_group_add_entries (debug, debug_entries);
context = g_option_context_new (NULL);
g_option_context_set_summary (context, N_("Liferea, the Linux Feed Reader"));
g_option_context_set_description (context, N_("For more information, please visit http://lzone.de/liferea/"));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_set_translation_domain(context, GETTEXT_PACKAGE);
g_option_context_add_group (context, debug);
g_option_context_add_group (context, gtk_get_option_group (FALSE));
g_option_context_add_group (context, g_irepository_get_option_group ());
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error) {
g_print ("Error parsing options: %s\n", error->message);
}
set_debug_level (debug_flags);
/* Configuration necessary for network options, so it
has to be initialized before update_init() */
conf_init ();
/* We need to do the network initialization here to allow
network-manager to be setup before gtk_init() */
update_init ();
gtk_init (&argc, &argv);
/* Single instance checks, also note that we pass or only RPC (add-feed)
as activate signal payload as it is simply an URI string. */
app = gtk_application_new ("net.sourceforge.liferea", G_APPLICATION_HANDLES_OPEN);
g_signal_connect (app, "activate", G_CALLBACK (on_app_activate), feedUri);
g_signal_connect (app, "open", G_CALLBACK (on_feed_add), NULL);
g_set_prgname ("liferea");
g_set_application_name (_("Liferea"));
gtk_window_set_default_icon_name ("liferea"); /* GTK theme support */
debug_start_measurement (DEBUG_DB);
/* order is important! */
db_init (); /* initialize sqlite */
xml_init (); /* initialize libxml2 */
#ifdef HAVE_LIBNOTIFY
notification_plugin_register (&libnotify_plugin);
#endif
social_init (); /* initialize social bookmarking */
dbus = liferea_dbus_new ();
signal (SIGTERM, signal_handler);
signal (SIGINT, signal_handler);
signal (SIGHUP, signal_handler);
/* Note: we explicitely do not use the gdk_thread_*
locking in Liferea because it freezes the program
when running Flash applets */
runState = STATE_STARTING;
debug_end_measurement (DEBUG_DB, "startup");
status = g_application_run (G_APPLICATION (app), 0, NULL);
/* Trigger RPCs if we are not primary instance (currently only feed-add) */
if (feedUri && g_application_get_is_remote (G_APPLICATION (app))) {
GFile *uris[2];
uris[0] = g_file_new_for_uri (feedUri);
uris[1] = NULL;
g_application_open (G_APPLICATION (app), uris, 1, "feed-add");
g_object_unref (uris[0]);
}
g_object_unref (G_OBJECT (dbus));
g_object_unref (app);
return status;
}
/**
* shell_util_get_icon_for_uri:
* @text_uri: A URI
*
* Look up the icon that should be associated with a given URI. Handles
* various special GNOME-internal cases like x-nautilus-search, etc.
*
* Return Value: (transfer full): A new #GIcon
*/
GIcon *
shell_util_get_icon_for_uri (const char *text_uri)
{
const char *name;
GFile *file;
GFileInfo *info;
GIcon *retval;
/* Here's what we do:
* + check for known file: URI
* + x-nautilus-search: URI
* + override burn: URI icon
* + check if the URI is a mount
* + override trash: URI icon for subfolders
* + check for application/x-gnome-saved-search mime type and override
* icon of the GFile
* + use icon of the GFile
*/
/* this only checks file: URI */
name = shell_util_get_icon_for_uri_known_folders (text_uri);
if (name)
return g_themed_icon_new (name);
if (g_str_has_prefix (text_uri, "x-nautilus-search:"))
return g_themed_icon_new ("folder-saved-search");
/* gvfs doesn't give us a nice icon, so overriding */
if (g_str_has_prefix (text_uri, "burn:"))
return g_themed_icon_new ("nautilus-cd-burner");
file = g_file_new_for_uri (text_uri);
retval = shell_util_get_file_icon_if_mount (file);
if (retval)
return retval;
/* gvfs doesn't give us a nice icon for subfolders of the trash, so
* overriding */
if (g_str_has_prefix (text_uri, "trash:"))
{
GFile *root;
root = shell_util_get_gfile_root (file);
g_object_unref (file);
file = root;
}
info = g_file_query_info (file, "standard::icon", G_FILE_QUERY_INFO_NONE,
NULL, NULL);
g_object_unref (file);
if (!info)
return g_themed_icon_new ("gtk-file");
retval = g_file_info_get_icon (info);
if (retval)
g_object_ref (retval);
g_object_unref (info);
if (retval)
return retval;
return g_themed_icon_new ("gtk-file");
}
static gboolean
try_check_file (GIOSchedulerJob *io_job,
GCancellable *cancellable,
gpointer data)
{
AsyncExistenceJob *job = data;
GFile *file;
GFileInfo *info;
GError *error;
char *uri;
retry:
error = NULL;
uri = build_uri (job);
file = g_file_new_for_uri (uri);
info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, cancellable, &error);
if (info != NULL)
{
/* file already exists, iterate again */
g_object_unref (info);
g_object_unref (file);
g_free (uri);
(job->iteration)++;
goto retry;
}
else
{
/* see the error to check whether the location is not accessible
* or the file does not exist.
*/
if (error->code == G_IO_ERROR_NOT_FOUND)
{
GFile *parent;
/* if the parent directory doesn't exist as well, forget the saved
* directory and treat this as a generic error.
*/
parent = g_file_get_parent (file);
if (!g_file_query_exists (parent, NULL))
{
(job->type)++;
job->iteration = 0;
g_object_unref (file);
g_object_unref (parent);
goto retry;
}
else
{
job->retval = uri;
g_object_unref (parent);
goto out;
}
}
else
{
/* another kind of error, assume this location is not
* accessible.
*/
g_free (uri);
if (job->type == TEST_TMP)
{
job->retval = NULL;
goto out;
}
else
{
(job->type)++;
job->iteration = 0;
g_error_free (error);
g_object_unref (file);
goto retry;
}
}
}
out:
g_error_free (error);
g_object_unref (file);
g_io_scheduler_job_send_to_mainloop_async (io_job,
check_file_done,
job,
NULL);
return FALSE;
}
static void
drag_data_received_callback (GtkWidget *widget,
GdkDragContext *context,
int x,
int y,
GtkSelectionData *data,
guint info,
guint32 time,
gpointer user_data)
{
NemoDragInfo *drag_info;
char *tmp;
const char *tmp_raw;
int length;
gboolean success;
drag_info = &(NEMO_ICON_CONTAINER (widget)->details->dnd_info->drag_info);
drag_info->got_drop_data_type = TRUE;
drag_info->data_type = info;
switch (info) {
case NEMO_ICON_DND_GNOME_ICON_LIST:
nemo_icon_container_dropped_icon_feedback (widget, data, x, y);
break;
case NEMO_ICON_DND_URI_LIST:
case NEMO_ICON_DND_TEXT:
case NEMO_ICON_DND_XDNDDIRECTSAVE:
case NEMO_ICON_DND_RAW:
/* Save the data so we can do the actual work on drop. */
if (drag_info->selection_data != NULL) {
gtk_selection_data_free (drag_info->selection_data);
}
drag_info->selection_data = gtk_selection_data_copy (data);
break;
/* Netscape keeps sending us the data, even though we accept the first drag */
case NEMO_ICON_DND_NETSCAPE_URL:
if (drag_info->selection_data != NULL) {
gtk_selection_data_free (drag_info->selection_data);
drag_info->selection_data = gtk_selection_data_copy (data);
}
break;
case NEMO_ICON_DND_ROOTWINDOW_DROP:
/* Do nothing, this won't even happen, since we don't want to call get_data twice */
break;
}
/* this is the second use case of this callback.
* we have to do the actual work for the drop.
*/
if (drag_info->drop_occured) {
success = FALSE;
switch (info) {
case NEMO_ICON_DND_GNOME_ICON_LIST:
nemo_icon_container_receive_dropped_icons
(NEMO_ICON_CONTAINER (widget),
context, x, y);
break;
case NEMO_ICON_DND_NETSCAPE_URL:
receive_dropped_netscape_url
(NEMO_ICON_CONTAINER (widget),
(char *) gtk_selection_data_get_data (data), context, x, y);
success = TRUE;
break;
case NEMO_ICON_DND_URI_LIST:
receive_dropped_uri_list
(NEMO_ICON_CONTAINER (widget),
(char *) gtk_selection_data_get_data (data), context, x, y);
success = TRUE;
break;
case NEMO_ICON_DND_TEXT:
tmp = gtk_selection_data_get_text (data);
receive_dropped_text
(NEMO_ICON_CONTAINER (widget),
(char *) tmp, context, x, y);
success = TRUE;
g_free (tmp);
break;
case NEMO_ICON_DND_RAW:
length = gtk_selection_data_get_length (data);
tmp_raw = gtk_selection_data_get_data (data);
receive_dropped_raw
(NEMO_ICON_CONTAINER (widget),
tmp_raw, length, drag_info->direct_save_uri,
context, x, y);
success = TRUE;
break;
case NEMO_ICON_DND_ROOTWINDOW_DROP:
/* Do nothing, everything is done by the sender */
break;
case NEMO_ICON_DND_XDNDDIRECTSAVE:
{
const guchar *selection_data;
gint selection_length;
gint selection_format;
selection_data = gtk_selection_data_get_data (drag_info->selection_data);
selection_length = gtk_selection_data_get_length (drag_info->selection_data);
selection_format = gtk_selection_data_get_format (drag_info->selection_data);
if (selection_format == 8 &&
selection_length == 1 &&
selection_data[0] == 'F') {
gtk_drag_get_data (widget, context,
gdk_atom_intern (NEMO_ICON_DND_RAW_TYPE,
FALSE),
time);
return;
} else if (selection_format == 8 &&
selection_length == 1 &&
selection_data[0] == 'F' &&
drag_info->direct_save_uri != NULL) {
GdkPoint p;
GFile *location;
location = g_file_new_for_uri (drag_info->direct_save_uri);
nemo_file_changes_queue_file_added (location);
p.x = x; p.y = y;
nemo_file_changes_queue_schedule_position_set (
location,
p,
gdk_screen_get_number (
gtk_widget_get_screen (widget)));
g_object_unref (location);
nemo_file_changes_consume_changes (TRUE);
success = TRUE;
}
break;
} /* NEMO_ICON_DND_XDNDDIRECTSAVE */
}
gtk_drag_finish (context, success, FALSE, time);
nemo_icon_container_free_drag_data (NEMO_ICON_CONTAINER (widget));
set_drop_target (NEMO_ICON_CONTAINER (widget), NULL);
/* reinitialise it for the next dnd */
drag_info->drop_occured = FALSE;
}
}
nsresult
nsIconChannel::InitWithGIO(nsIMozIconURI *aIconURI)
{
GIcon *icon = NULL;
nsCOMPtr<nsIURL> fileURI;
// Read icon content
aIconURI->GetIconURL(getter_AddRefs(fileURI));
// Get icon for file specified by URI
if (fileURI) {
bool isFile;
nsAutoCString spec;
fileURI->GetAsciiSpec(spec);
if (NS_SUCCEEDED(fileURI->SchemeIs("file", &isFile)) && isFile) {
GFile *file = g_file_new_for_uri(spec.get());
GFileInfo *fileInfo = g_file_query_info(file,
G_FILE_ATTRIBUTE_STANDARD_ICON,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
g_object_unref(file);
if (fileInfo) {
// icon from g_content_type_get_icon doesn't need unref
icon = g_file_info_get_icon(fileInfo);
if (icon)
g_object_ref(icon);
g_object_unref(fileInfo);
}
}
}
// Try to get icon by using MIME type
if (!icon) {
nsAutoCString type;
aIconURI->GetContentType(type);
// Try to get MIME type from file extension by using nsIMIMEService
if (type.IsEmpty()) {
nsCOMPtr<nsIMIMEService> ms(do_GetService("@mozilla.org/mime;1"));
if (ms) {
nsAutoCString fileExt;
aIconURI->GetFileExtension(fileExt);
ms->GetTypeFromExtension(fileExt, type);
}
}
char *ctype = NULL; // character representation of content type
if (!type.IsEmpty()) {
ctype = g_content_type_from_mime_type(type.get());
}
if (ctype) {
icon = g_content_type_get_icon(ctype);
g_free(ctype);
}
}
// Get default icon theme
GtkIconTheme *iconTheme = gtk_icon_theme_get_default();
GtkIconInfo *iconInfo = NULL;
// Get icon size
int32_t iconSize = GetIconSize(aIconURI);
if (icon) {
// Use icon and theme to get GtkIconInfo
iconInfo = gtk_icon_theme_lookup_by_gicon(iconTheme,
icon, iconSize,
(GtkIconLookupFlags)0);
g_object_unref(icon);
}
if (!iconInfo) {
// Mozilla's mimetype lookup failed. Try the "unknown" icon.
iconInfo = gtk_icon_theme_lookup_icon(iconTheme,
"unknown", iconSize,
(GtkIconLookupFlags)0);
if (!iconInfo) {
return NS_ERROR_NOT_AVAILABLE;
}
}
// Create a GdkPixbuf buffer containing icon and scale it
GdkPixbuf* buf = gtk_icon_info_load_icon(iconInfo, NULL);
gtk_icon_info_free(iconInfo);
if (!buf) {
return NS_ERROR_UNEXPECTED;
}
nsresult rv = ScaleIconBuf(&buf, iconSize);
NS_ENSURE_SUCCESS(rv, rv);
rv = moz_gdk_pixbuf_to_channel(buf, aIconURI,
getter_AddRefs(mRealChannel));
g_object_unref(buf);
return rv;
}
void
ori_open (gchar * fn, gboolean replace)
{
GString *gstr;
GFile *fp;
GFileInputStream *file_in;
char *nullstr = "NULLSTRING";
gssize bytes = 1;
if (!fn)
fn = nullstr;
fp = g_file_new_for_uri (fn);
if (fp == NULL)
{
gchar errmsg[MAX_ERR_MSG_SIZE + 1];
g_snprintf (errmsg, MAX_ERR_MSG_SIZE, _("Failed to open <%s>"),
fn);
gui_app_show_msg (GTK_MESSAGE_ERROR, errmsg);
return;
}
gstr = g_string_new ("");
file_in = g_file_read (fp, NULL, NULL);
while (bytes != 0)
{
gchar buf[100] = { 0 };
bytes = g_input_stream_read (G_INPUT_STREAM (file_in), buf, 100, NULL, NULL);
g_string_append_len (gstr, buf, bytes);
}
g_input_stream_close (G_INPUT_STREAM (file_in), NULL, NULL);
gui_editor_set_text (app->editor, gstr->str);
gtk_text_buffer_set_modified ((GtkTextBuffer *)app->editor->buffer, FALSE);
/* Set breakpoints as instructed in the source */
{
gchar *str = gstr->str;
gint ln = 0;
gchar **lines = NULL;
g_assert (str);
lines = g_strsplit (str, "\n", -1);
g_assert (lines);
/* for each line */
while (lines[ln])
{
/* check for ;@ */
if (strlen (lines[ln]) > 1)
{
if (lines[ln][0] == ';'
&& lines[ln][1] == '@')
{
/* add breakpoint */
gui_editor_set_mark (app->editor,
ln + 1, TRUE);
//exit(99);
}
}
ln++;
}
g_strfreev (lines);
}
g_string_free (gstr, TRUE);
if (replace)
_set_file_name (fn);
}
static GdkPixbuf *
_gdk_pixbuf_new_from_uri_at_scale (const char *uri,
gint size,
GError **error)
{
gboolean result;
guchar buffer[LOAD_BUFFER_SIZE];
gssize bytes_read;
GdkPixbufLoader *loader = NULL;
GdkPixbuf *pixbuf;
GdkPixbufAnimation *animation;
GdkPixbufAnimationIter *iter;
gboolean has_frame;
SizePrepareContext info;
GFile *file;
GInputStream *input_stream;
g_return_val_if_fail (uri != NULL, NULL);
file = g_file_new_for_uri (uri);
input_stream = G_INPUT_STREAM (g_file_read (file, NULL, error));
if (input_stream == NULL) {
g_object_unref (file);
return NULL;
}
has_frame = FALSE;
result = FALSE;
while (!has_frame) {
bytes_read = g_input_stream_read (input_stream,
buffer,
sizeof (buffer),
NULL,
error);
if (bytes_read == -1) {
break;
}
result = TRUE;
if (bytes_read == 0) {
break;
}
if (loader == NULL) {
loader = create_loader (file, buffer, bytes_read);
if (1 <= size) {
info.size = size;
info.input_width = info.input_height = 0;
g_signal_connect (loader, "size-prepared", G_CALLBACK (size_prepared_cb), &info);
}
g_assert (loader != NULL);
}
if (!gdk_pixbuf_loader_write (loader,
(unsigned char *)buffer,
bytes_read,
error)) {
result = FALSE;
break;
}
animation = gdk_pixbuf_loader_get_animation (loader);
if (animation) {
iter = gdk_pixbuf_animation_get_iter (animation, NULL);
if (!gdk_pixbuf_animation_iter_on_currently_loading_frame (iter)) {
has_frame = TRUE;
}
g_object_unref (iter);
}
}
if (loader == NULL) {
/* This can happen if the above loop was exited due to the
* g_input_stream_read() call failing. */
result = FALSE;
} else if (*error != NULL) {
gdk_pixbuf_loader_close (loader, NULL);
result = FALSE;
} else if (gdk_pixbuf_loader_close (loader, error) == FALSE) {
if (!g_error_matches (*error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INCOMPLETE_ANIMATION))
result = FALSE;
else
g_clear_error (error);
}
if (!result) {
g_clear_object (&loader);
g_input_stream_close (input_stream, NULL, NULL);
g_object_unref (input_stream);
g_object_unref (file);
return NULL;
}
g_input_stream_close (input_stream, NULL, NULL);
g_object_unref (input_stream);
g_object_unref (file);
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf != NULL) {
g_object_ref (G_OBJECT (pixbuf));
g_object_set_data (G_OBJECT (pixbuf), "gnome-original-width",
GINT_TO_POINTER (info.input_width));
g_object_set_data (G_OBJECT (pixbuf), "gnome-original-height",
GINT_TO_POINTER (info.input_height));
}
g_object_unref (G_OBJECT (loader));
return pixbuf;
}
static GimpValueArray *
xcf_load_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
XcfInfo info = { 0, };
GimpValueArray *return_vals;
GimpImage *image = NULL;
const gchar *uri;
gchar *filename;
GFile *file;
gboolean success = FALSE;
gchar id[14];
GError *my_error = NULL;
gimp_set_busy (gimp);
uri = g_value_get_string (gimp_value_array_index (args, 1));
#ifdef GIO_IS_FIXED
file = g_file_new_for_uri (uri);
#else
file = g_file_new_for_path (uri);
#endif
filename = g_file_get_parse_name (file);
info.input = G_INPUT_STREAM (g_file_read (file, NULL, &my_error));
if (info.input)
{
info.gimp = gimp;
info.seekable = G_SEEKABLE (info.input);
info.progress = progress;
info.filename = filename;
info.compression = COMPRESS_NONE;
if (progress)
{
gchar *name = g_filename_display_name (filename);
gchar *msg = g_strdup_printf (_("Opening '%s'"), name);
gimp_progress_start (progress, msg, FALSE);
g_free (msg);
g_free (name);
}
success = TRUE;
info.cp += xcf_read_int8 (info.input, (guint8 *) id, 14);
if (! g_str_has_prefix (id, "gimp xcf "))
{
success = FALSE;
}
else if (strcmp (id + 9, "file") == 0)
{
info.file_version = 0;
}
else if (id[9] == 'v')
{
info.file_version = atoi (id + 10);
}
else
{
success = FALSE;
}
if (success)
{
if (info.file_version >= 0 &&
info.file_version < G_N_ELEMENTS (xcf_loaders))
{
image = (*(xcf_loaders[info.file_version])) (gimp, &info, error);
if (! image)
success = FALSE;
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("XCF error: unsupported XCF file version %d "
"encountered"), info.file_version);
success = FALSE;
}
}
g_object_unref (info.input);
if (progress)
gimp_progress_end (progress);
}
else
{
g_propagate_prefixed_error (error, my_error,
_("Could not open '%s' for reading: "),
filename);
}
g_free (filename);
g_object_unref (file);
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
gimp_value_set_image (gimp_value_array_index (return_vals, 1), image);
gimp_unset_busy (gimp);
return return_vals;
}
static gboolean
drop_urilist (PanelWidget *panel,
int pos,
char *urilist)
{
char **uris;
gboolean success;
int i;
uris = g_uri_list_extract_uris (urilist);
success = TRUE;
for (i = 0; uris[i]; i++) {
GFile *file;
GFileInfo *info;
const char *uri;
uri = uris[i];
if (g_ascii_strncasecmp (uri, "http:", strlen ("http:")) == 0 ||
g_ascii_strncasecmp (uri, "https:", strlen ("https:")) == 0 ||
g_ascii_strncasecmp (uri, "ftp:", strlen ("ftp:")) == 0 ||
g_ascii_strncasecmp (uri, "gopher:", strlen ("gopher:")) == 0 ||
g_ascii_strncasecmp (uri, "ghelp:", strlen ("ghelp:")) == 0 ||
g_ascii_strncasecmp (uri, "man:", strlen ("man:")) == 0 ||
g_ascii_strncasecmp (uri, "info:", strlen ("info:")) == 0) {
/* FIXME: probably do this only on link,
* in fact, on link always set up a link,
* on copy do all the other stuff. Or something. */
if ( ! drop_url (panel, pos, uri))
success = FALSE;
continue;
}
if (g_ascii_strncasecmp (uri, "x-caja-desktop:",
strlen ("x-caja-desktop:")) == 0) {
success = drop_caja_desktop_uri (panel, pos, uri);
continue;
}
file = g_file_new_for_uri (uri);
info = g_file_query_info (file,
"standard::type,"
"standard::content-type,"
"access::can-execute",
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if (info) {
const char *mime;
GFileType type;
gboolean can_exec;
mime = g_file_info_get_content_type (info);
type = g_file_info_get_file_type (info);
can_exec = g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE);
if (mime &&
g_str_has_prefix (mime, "image")) {
if (!set_background_image_from_uri (panel->toplevel, uri))
success = FALSE;
} else if (mime &&
(!strcmp (mime, "application/x-mate-app-info") ||
!strcmp (mime, "application/x-desktop") ||
!strcmp (mime, "application/x-kde-app-info"))) {
if (panel_profile_id_lists_are_writable ())
panel_launcher_create (panel->toplevel, pos, uri);
else
success = FALSE;
} else if (type != G_FILE_TYPE_DIRECTORY && can_exec) {
char *filename;
filename = g_file_get_path (file);
if (panel_profile_id_lists_are_writable ())
/* executable and local, so add a
* launcher with it */
ask_about_launcher (filename, panel,
pos, TRUE);
else
success = FALSE;
g_free (filename);
} else {
if (!drop_uri (panel, pos, uri,
PANEL_ICON_UNKNOWN))
success = FALSE;
}
} else {
if (!drop_uri (panel, pos, uri, PANEL_ICON_UNKNOWN))
success = FALSE;
}
g_object_unref (info);
g_object_unref (file);
}
g_strfreev (uris);
return success;
}
static GimpValueArray *
xcf_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
XcfInfo info = { 0, };
GimpValueArray *return_vals;
GimpImage *image;
const gchar *uri;
gchar *filename;
GFile *file;
gboolean success = FALSE;
GError *my_error = NULL;
gimp_set_busy (gimp);
image = gimp_value_get_image (gimp_value_array_index (args, 1), gimp);
uri = g_value_get_string (gimp_value_array_index (args, 3));
#ifdef GIO_IS_FIXED
file = g_file_new_for_uri (uri);
#else
file = g_file_new_for_path (uri);
#endif
filename = g_file_get_parse_name (file);
info.output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, 0, NULL,
&my_error));
if (info.output)
{
info.gimp = gimp;
info.seekable = G_SEEKABLE (info.output);
info.progress = progress;
info.filename = filename;
info.compression = COMPRESS_RLE;
if (progress)
{
gchar *name = g_filename_display_name (filename);
gchar *msg = g_strdup_printf (_("Saving '%s'"), name);
gimp_progress_start (progress, msg, FALSE);
g_free (msg);
g_free (name);
}
xcf_save_choose_format (&info, image);
success = xcf_save_image (&info, image, error);
g_object_unref (info.output);
if (progress)
gimp_progress_end (progress);
}
else
{
g_propagate_prefixed_error (error, my_error,
_("Could not open '%s' for writing: "),
filename);
}
g_free (filename);
g_object_unref (file);
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
gimp_unset_busy (gimp);
return return_vals;
}
int
ddb_gvfs_scandir (const char *dir, struct dirent ***namelist, int (*selector) (const struct dirent *), int (*cmp) (const struct dirent **, const struct dirent **))
{
GQueue *file_list = g_queue_new ();
GQueue *dir_list = g_queue_new ();
g_queue_push_head (dir_list, g_file_new_for_uri (dir));
GFile *gdir;
while ((gdir = g_queue_pop_head (dir_list)) != NULL)
{
GFileEnumerator *file_enumerator = g_file_enumerate_children (gdir, G_FILE_ATTRIBUTE_STANDARD_NAME, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL);
if (file_enumerator == NULL)
{
g_object_unref (gdir);
continue;
}
GFileInfo *file_info;
GFile *child_file;
while ((file_info = g_file_enumerator_next_file (file_enumerator, NULL, NULL)) != NULL)
{
child_file = g_file_get_child (gdir, g_file_info_get_name (file_info));
g_object_unref (file_info);
if (g_file_query_file_type (child_file, G_FILE_QUERY_INFO_NONE, NULL) == G_FILE_TYPE_DIRECTORY)
g_queue_push_head (dir_list, child_file);
else
{
g_queue_push_tail (file_list, g_file_get_uri (child_file));
g_object_unref (child_file);
}
}
g_file_enumerator_close (file_enumerator, NULL, NULL);
g_object_unref (file_enumerator);
g_object_unref (gdir);
}
g_queue_free (dir_list);
int num_files = 0;
*namelist = malloc (sizeof(void *) * g_queue_get_length (file_list));
char *fname;
while ((fname = g_queue_pop_head (file_list)) != NULL)
{
struct dirent entry;
strncpy (entry.d_name, fname, sizeof(entry.d_name) - 1);
entry.d_name[sizeof(entry.d_name) - 1] = '\0';
if (selector == NULL || (selector && selector(&entry)))
{
(*namelist)[num_files] = calloc (1, sizeof (struct dirent));
strcpy ((*namelist)[num_files]->d_name, entry.d_name);
num_files++;
}
g_free (fname);
}
g_queue_free (file_list);
return num_files;
}
bool TextFileSaver::step()
{
GOutputStream *stream = NULL;
// Open the file.
GFile *file = g_file_new_for_uri(uri());
GFileOutputStream *fileStream = g_file_replace(file,
NULL,
TRUE,
G_FILE_CREATE_NONE,
NULL,
&m_error);
if (!fileStream)
{
g_object_unref(file);
return true;
}
// Open the encoding converter and setup the input stream.
if (m_encoding == "UTF-8")
stream = G_OUTPUT_STREAM(fileStream);
else
{
GCharsetConverter *encodingConverter =
g_charset_converter_new(m_encoding.c_str(), "UTF-8", &m_error);
if (!encodingConverter)
{
g_object_unref(file);
g_object_unref(fileStream);
return true;
}
stream =
g_converter_output_stream_new(G_OUTPUT_STREAM(fileStream),
G_CONVERTER(encodingConverter));
g_object_unref(fileStream);
g_object_unref(encodingConverter);
}
// Convert and write.
int size =
g_output_stream_write(stream,
m_text.get(),
m_length == -1 ? strlen(m_text.get()) : m_length,
NULL,
&m_error);
if (size == -1)
{
g_object_unref(file);
g_object_unref(stream);
return true;
}
if (!g_output_stream_close(stream, NULL, &m_error))
{
g_object_unref(file);
g_object_unref(stream);
return true;
}
g_object_unref(stream);
// Get the time when the file was last modified.
GFileInfo *fileInfo;
fileInfo =
g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
NULL,
&m_error);
if (!fileInfo)
{
g_object_unref(file);
return true;
}
m_modifiedTime.seconds = g_file_info_get_attribute_uint64(
fileInfo,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
g_object_unref(fileInfo);
fileInfo =
g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC,
G_FILE_QUERY_INFO_NONE,
NULL,
&m_error);
if (!fileInfo)
{
g_object_unref(file);
return true;
}
m_modifiedTime.microSeconds = g_file_info_get_attribute_uint32(
fileInfo,
G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC);
g_object_unref(fileInfo);
g_object_unref(file);
return true;
}
