File: | libbaul-private/baul-file.c |
Warning: | line 3055, column 11 Out of bound memory access (access exceeds upper limit of memory block) |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- | |||
2 | ||||
3 | baul-file.c: Baul file model. | |||
4 | ||||
5 | Copyright (C) 1999, 2000, 2001 Eazel, Inc. | |||
6 | ||||
7 | This program is free software; you can redistribute it and/or | |||
8 | modify it under the terms of the GNU General Public License as | |||
9 | published by the Free Software Foundation; either version 2 of the | |||
10 | License, or (at your option) any later version. | |||
11 | ||||
12 | This program is distributed in the hope that it will be useful, | |||
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
15 | General Public License for more details. | |||
16 | ||||
17 | You should have received a copy of the GNU General Public | |||
18 | License along with this program; if not, write to the | |||
19 | Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |||
20 | Boston, MA 02110-1301, USA. | |||
21 | ||||
22 | Author: Darin Adler <darin@bentspoon.com> | |||
23 | */ | |||
24 | ||||
25 | #include <config.h> | |||
26 | #include <grp.h> | |||
27 | #include <ctk/ctk.h> | |||
28 | #include <glib/gi18n.h> | |||
29 | #include <glib/gstdio.h> | |||
30 | #include <gio/gio.h> | |||
31 | #include <glib.h> | |||
32 | #include <libxml/parser.h> | |||
33 | #include <pwd.h> | |||
34 | #include <stdlib.h> | |||
35 | #include <ctype.h> | |||
36 | #include <sys/time.h> | |||
37 | #include <time.h> | |||
38 | #include <unistd.h> | |||
39 | #include <sys/stat.h> | |||
40 | ||||
41 | #include <eel/eel-debug.h> | |||
42 | #include <eel/eel-glib-extensions.h> | |||
43 | #include <eel/eel-ctk-extensions.h> | |||
44 | #include <eel/eel-vfs-extensions.h> | |||
45 | #include <eel/eel-ctk-macros.h> | |||
46 | #include <eel/eel-string.h> | |||
47 | ||||
48 | #include <libbaul-extension/baul-file-info.h> | |||
49 | #include <libbaul-extension/baul-extension-private.h> | |||
50 | #include <libbaul-private/baul-extensions.h> | |||
51 | ||||
52 | #include "baul-file.h" | |||
53 | #include "baul-directory-notify.h" | |||
54 | #include "baul-directory-private.h" | |||
55 | #include "baul-signaller.h" | |||
56 | #include "baul-desktop-directory.h" | |||
57 | #include "baul-desktop-directory-file.h" | |||
58 | #include "baul-desktop-icon-file.h" | |||
59 | #include "baul-file-attributes.h" | |||
60 | #include "baul-file-private.h" | |||
61 | #include "baul-file-operations.h" | |||
62 | #include "baul-file-utilities.h" | |||
63 | #include "baul-global-preferences.h" | |||
64 | #include "baul-lib-self-check-functions.h" | |||
65 | #include "baul-link.h" | |||
66 | #include "baul-metadata.h" | |||
67 | #include "baul-module.h" | |||
68 | #include "baul-search-directory.h" | |||
69 | #include "baul-search-directory-file.h" | |||
70 | #include "baul-thumbnails.h" | |||
71 | #include "baul-ui-utilities.h" | |||
72 | #include "baul-vfs-file.h" | |||
73 | #include "baul-saved-search-file.h" | |||
74 | ||||
75 | #ifdef HAVE_SELINUX1 | |||
76 | #include <selinux/selinux.h> | |||
77 | #endif | |||
78 | ||||
79 | /* Time in seconds to cache getpwuid results */ | |||
80 | #define GETPWUID_CACHE_TIME(5*60) (5*60) | |||
81 | ||||
82 | #define ICON_NAME_THUMBNAIL_LOADING"image-loading" "image-loading" | |||
83 | ||||
84 | #undef BAUL_FILE_DEBUG_REF | |||
85 | #undef BAUL_FILE_DEBUG_REF_VALGRIND | |||
86 | ||||
87 | #ifdef BAUL_FILE_DEBUG_REF_VALGRIND | |||
88 | #include <valgrind/valgrind.h> | |||
89 | #define DEBUG_REF_PRINTFprintf VALGRIND_PRINTF_BACKTRACE | |||
90 | #else | |||
91 | #define DEBUG_REF_PRINTFprintf printf | |||
92 | #endif | |||
93 | ||||
94 | /* Files that start with these characters sort after files that don't. */ | |||
95 | #define SORT_LAST_CHAR1'.' '.' | |||
96 | #define SORT_LAST_CHAR2'#' '#' | |||
97 | ||||
98 | /* Name of Baul trash directories */ | |||
99 | #define TRASH_DIRECTORY_NAME".Trash" ".Trash" | |||
100 | ||||
101 | #define METADATA_ID_IS_LIST_MASK(1U<<31) (1U<<31) | |||
102 | ||||
103 | #define SORT_BY_EXTENSION_FOLLOWING_MAX_LENGTH3 3 | |||
104 | #define SORT_BY_EXTENSION_MAX_SEGMENTS3 3 | |||
105 | ||||
106 | typedef enum { | |||
107 | SHOW_HIDDEN = 1 << 0, | |||
108 | SHOW_BACKUP = 1 << 1, | |||
109 | } FilterOptions; | |||
110 | ||||
111 | typedef void (* ModifyListFunction) (GList **list, BaulFile *file); | |||
112 | ||||
113 | enum { | |||
114 | CHANGED, | |||
115 | UPDATED_DEEP_COUNT_IN_PROGRESS, | |||
116 | LAST_SIGNAL | |||
117 | }; | |||
118 | ||||
119 | static int date_format_pref; | |||
120 | ||||
121 | static guint signals[LAST_SIGNAL] = { 0 }; | |||
122 | ||||
123 | static GHashTable *symbolic_links; | |||
124 | ||||
125 | static GQuark attribute_name_q, | |||
126 | attribute_size_q, | |||
127 | attribute_size_on_disk_q, | |||
128 | attribute_type_q, | |||
129 | attribute_modification_date_q, | |||
130 | attribute_date_modified_q, | |||
131 | attribute_accessed_date_q, | |||
132 | attribute_date_accessed_q, | |||
133 | attribute_emblems_q, | |||
134 | attribute_extension_q, | |||
135 | attribute_mime_type_q, | |||
136 | attribute_size_detail_q, | |||
137 | attribute_size_on_disk_detail_q, | |||
138 | attribute_deep_size_q, | |||
139 | attribute_deep_size_on_disk_q, | |||
140 | attribute_deep_file_count_q, | |||
141 | attribute_deep_directory_count_q, | |||
142 | attribute_deep_total_count_q, | |||
143 | attribute_date_changed_q, | |||
144 | attribute_trashed_on_q, | |||
145 | attribute_trash_orig_path_q, | |||
146 | attribute_date_permissions_q, | |||
147 | attribute_permissions_q, | |||
148 | attribute_selinux_context_q, | |||
149 | attribute_octal_permissions_q, | |||
150 | attribute_owner_q, | |||
151 | attribute_group_q, | |||
152 | attribute_uri_q, | |||
153 | attribute_where_q, | |||
154 | attribute_link_target_q, | |||
155 | attribute_volume_q, | |||
156 | attribute_free_space_q; | |||
157 | ||||
158 | static void baul_file_info_iface_init (BaulFileInfoIface *iface); | |||
159 | static char * baul_file_get_owner_as_string (BaulFile *file, | |||
160 | gboolean include_real_name); | |||
161 | static char * baul_file_get_type_as_string (BaulFile *file); | |||
162 | static gboolean update_info_and_name (BaulFile *file, | |||
163 | GFileInfo *info); | |||
164 | static const char * baul_file_peek_display_name (BaulFile *file); | |||
165 | static const char * baul_file_peek_display_name_collation_key (BaulFile *file); | |||
166 | static void file_mount_unmounted (GMount *mount, gpointer data); | |||
167 | static void metadata_hash_free (GHashTable *hash); | |||
168 | ||||
169 | G_DEFINE_TYPE_WITH_CODE (BaulFile, baul_file, G_TYPE_OBJECT,static void baul_file_init (BaulFile *self); static void baul_file_class_init (BaulFileClass *klass); static GType baul_file_get_type_once (void); static gpointer baul_file_parent_class = ((void*)0); static gint BaulFile_private_offset; static void baul_file_class_intern_init (gpointer klass) { baul_file_parent_class = g_type_class_peek_parent (klass); if (BaulFile_private_offset != 0) g_type_class_adjust_private_offset (klass, &BaulFile_private_offset); baul_file_class_init ( (BaulFileClass*) klass); } __attribute__ ((__unused__)) static inline gpointer baul_file_get_instance_private (BaulFile *self ) { return (((gpointer) ((guint8*) (self) + (glong) (BaulFile_private_offset )))); } GType baul_file_get_type (void) { static gsize static_g_define_type_id = 0; if ((__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); (void ) (0 ? (gpointer) *(&static_g_define_type_id) : ((void*)0 )); (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__ ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id ); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5) ; gapg_temp_newval; })) && g_once_init_enter (&static_g_define_type_id )); }))) { GType g_define_type_id = baul_file_get_type_once ( ); (__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id) = (g_define_type_id) ) : (void) 0; g_once_init_leave ((&static_g_define_type_id ), (gsize) (g_define_type_id)); })); } return static_g_define_type_id ; } __attribute__ ((__noinline__)) static GType baul_file_get_type_once (void) { GType g_define_type_id = g_type_register_static_simple (((GType) ((20) << (2))), g_intern_static_string ("BaulFile" ), sizeof (BaulFileClass), (GClassInitFunc)(void (*)(void)) baul_file_class_intern_init , sizeof (BaulFile), (GInstanceInitFunc)(void (*)(void)) baul_file_init , (GTypeFlags) 0); { {{ BaulFile_private_offset = g_type_add_instance_private (g_define_type_id, sizeof (BaulFilePrivate)); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc)(void (*) (void)) baul_file_info_iface_init, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id, (baul_file_info_get_type ()), &g_implement_interface_info ); };} } return g_define_type_id; } | |||
170 | G_ADD_PRIVATE (BaulFile)static void baul_file_init (BaulFile *self); static void baul_file_class_init (BaulFileClass *klass); static GType baul_file_get_type_once (void); static gpointer baul_file_parent_class = ((void*)0); static gint BaulFile_private_offset; static void baul_file_class_intern_init (gpointer klass) { baul_file_parent_class = g_type_class_peek_parent (klass); if (BaulFile_private_offset != 0) g_type_class_adjust_private_offset (klass, &BaulFile_private_offset); baul_file_class_init ( (BaulFileClass*) klass); } __attribute__ ((__unused__)) static inline gpointer baul_file_get_instance_private (BaulFile *self ) { return (((gpointer) ((guint8*) (self) + (glong) (BaulFile_private_offset )))); } GType baul_file_get_type (void) { static gsize static_g_define_type_id = 0; if ((__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); (void ) (0 ? (gpointer) *(&static_g_define_type_id) : ((void*)0 )); (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__ ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id ); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5) ; gapg_temp_newval; })) && g_once_init_enter (&static_g_define_type_id )); }))) { GType g_define_type_id = baul_file_get_type_once ( ); (__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id) = (g_define_type_id) ) : (void) 0; g_once_init_leave ((&static_g_define_type_id ), (gsize) (g_define_type_id)); })); } return static_g_define_type_id ; } __attribute__ ((__noinline__)) static GType baul_file_get_type_once (void) { GType g_define_type_id = g_type_register_static_simple (((GType) ((20) << (2))), g_intern_static_string ("BaulFile" ), sizeof (BaulFileClass), (GClassInitFunc)(void (*)(void)) baul_file_class_intern_init , sizeof (BaulFile), (GInstanceInitFunc)(void (*)(void)) baul_file_init , (GTypeFlags) 0); { {{ BaulFile_private_offset = g_type_add_instance_private (g_define_type_id, sizeof (BaulFilePrivate)); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc)(void (*) (void)) baul_file_info_iface_init, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id, (baul_file_info_get_type ()), &g_implement_interface_info ); };} } return g_define_type_id; } | |||
171 | G_IMPLEMENT_INTERFACE (BAUL_TYPE_FILE_INFO,static void baul_file_init (BaulFile *self); static void baul_file_class_init (BaulFileClass *klass); static GType baul_file_get_type_once (void); static gpointer baul_file_parent_class = ((void*)0); static gint BaulFile_private_offset; static void baul_file_class_intern_init (gpointer klass) { baul_file_parent_class = g_type_class_peek_parent (klass); if (BaulFile_private_offset != 0) g_type_class_adjust_private_offset (klass, &BaulFile_private_offset); baul_file_class_init ( (BaulFileClass*) klass); } __attribute__ ((__unused__)) static inline gpointer baul_file_get_instance_private (BaulFile *self ) { return (((gpointer) ((guint8*) (self) + (glong) (BaulFile_private_offset )))); } GType baul_file_get_type (void) { static gsize static_g_define_type_id = 0; if ((__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); (void ) (0 ? (gpointer) *(&static_g_define_type_id) : ((void*)0 )); (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__ ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id ); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5) ; gapg_temp_newval; })) && g_once_init_enter (&static_g_define_type_id )); }))) { GType g_define_type_id = baul_file_get_type_once ( ); (__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id) = (g_define_type_id) ) : (void) 0; g_once_init_leave ((&static_g_define_type_id ), (gsize) (g_define_type_id)); })); } return static_g_define_type_id ; } __attribute__ ((__noinline__)) static GType baul_file_get_type_once (void) { GType g_define_type_id = g_type_register_static_simple (((GType) ((20) << (2))), g_intern_static_string ("BaulFile" ), sizeof (BaulFileClass), (GClassInitFunc)(void (*)(void)) baul_file_class_intern_init , sizeof (BaulFile), (GInstanceInitFunc)(void (*)(void)) baul_file_init , (GTypeFlags) 0); { {{ BaulFile_private_offset = g_type_add_instance_private (g_define_type_id, sizeof (BaulFilePrivate)); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc)(void (*) (void)) baul_file_info_iface_init, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id, (baul_file_info_get_type ()), &g_implement_interface_info ); };} } return g_define_type_id; } | |||
172 | baul_file_info_iface_init))static void baul_file_init (BaulFile *self); static void baul_file_class_init (BaulFileClass *klass); static GType baul_file_get_type_once (void); static gpointer baul_file_parent_class = ((void*)0); static gint BaulFile_private_offset; static void baul_file_class_intern_init (gpointer klass) { baul_file_parent_class = g_type_class_peek_parent (klass); if (BaulFile_private_offset != 0) g_type_class_adjust_private_offset (klass, &BaulFile_private_offset); baul_file_class_init ( (BaulFileClass*) klass); } __attribute__ ((__unused__)) static inline gpointer baul_file_get_instance_private (BaulFile *self ) { return (((gpointer) ((guint8*) (self) + (glong) (BaulFile_private_offset )))); } GType baul_file_get_type (void) { static gsize static_g_define_type_id = 0; if ((__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); (void ) (0 ? (gpointer) *(&static_g_define_type_id) : ((void*)0 )); (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__ ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id ); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5) ; gapg_temp_newval; })) && g_once_init_enter (&static_g_define_type_id )); }))) { GType g_define_type_id = baul_file_get_type_once ( ); (__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id ) == sizeof (gpointer), "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id) = (g_define_type_id) ) : (void) 0; g_once_init_leave ((&static_g_define_type_id ), (gsize) (g_define_type_id)); })); } return static_g_define_type_id ; } __attribute__ ((__noinline__)) static GType baul_file_get_type_once (void) { GType g_define_type_id = g_type_register_static_simple (((GType) ((20) << (2))), g_intern_static_string ("BaulFile" ), sizeof (BaulFileClass), (GClassInitFunc)(void (*)(void)) baul_file_class_intern_init , sizeof (BaulFile), (GInstanceInitFunc)(void (*)(void)) baul_file_init , (GTypeFlags) 0); { {{ BaulFile_private_offset = g_type_add_instance_private (g_define_type_id, sizeof (BaulFilePrivate)); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc)(void (*) (void)) baul_file_info_iface_init, ((void*)0), ((void*)0) }; g_type_add_interface_static (g_define_type_id, (baul_file_info_get_type ()), &g_implement_interface_info ); };} } return g_define_type_id; }; | |||
173 | ||||
174 | static void | |||
175 | baul_file_init (BaulFile *file) | |||
176 | { | |||
177 | file->details = baul_file_get_instance_private (file); | |||
178 | ||||
179 | baul_file_clear_info (file); | |||
180 | baul_file_invalidate_extension_info_internal (file); | |||
181 | } | |||
182 | ||||
183 | static GObject* | |||
184 | baul_file_constructor (GType type, | |||
185 | guint n_construct_properties, | |||
186 | GObjectConstructParam *construct_params) | |||
187 | { | |||
188 | GObject *object; | |||
189 | BaulFile *file; | |||
190 | ||||
191 | object = (* G_OBJECT_CLASS (baul_file_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((baul_file_parent_class)), (((GType) ((20) << (2))) )))))->constructor) (type, | |||
192 | n_construct_properties, | |||
193 | construct_params); | |||
194 | ||||
195 | file = BAUL_FILE (object)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((object)), (baul_file_get_type()))))); | |||
196 | ||||
197 | /* Set to default type after full construction */ | |||
198 | if (BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->default_file_type != G_FILE_TYPE_UNKNOWN) { | |||
199 | file->details->type = BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->default_file_type; | |||
200 | } | |||
201 | ||||
202 | return object; | |||
203 | } | |||
204 | ||||
205 | gboolean | |||
206 | baul_file_set_display_name (BaulFile *file, | |||
207 | const char *display_name, | |||
208 | const char *edit_name, | |||
209 | gboolean custom) | |||
210 | { | |||
211 | gboolean changed; | |||
212 | ||||
213 | if (custom && display_name == NULL((void*)0)) { | |||
214 | /* We're re-setting a custom display name, invalidate it if | |||
215 | we already set it so that the old one is re-read */ | |||
216 | if (file->details->got_custom_display_name) { | |||
217 | file->details->got_custom_display_name = FALSE(0); | |||
218 | baul_file_invalidate_attributes (file, | |||
219 | BAUL_FILE_ATTRIBUTE_INFO); | |||
220 | } | |||
221 | return FALSE(0); | |||
222 | } | |||
223 | ||||
224 | if (display_name == NULL((void*)0) || *display_name == 0) { | |||
225 | return FALSE(0); | |||
226 | } | |||
227 | ||||
228 | if (!custom && file->details->got_custom_display_name) { | |||
229 | return FALSE(0); | |||
230 | } | |||
231 | ||||
232 | if (edit_name == NULL((void*)0)) { | |||
233 | edit_name = display_name; | |||
234 | } | |||
235 | ||||
236 | changed = FALSE(0); | |||
237 | ||||
238 | if (eel_strcmp (file->details->display_name, display_name) != 0) { | |||
239 | changed = TRUE(!(0)); | |||
240 | ||||
241 | g_clear_pointer (&file->details->display_name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->display_name ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->display_name)) _pp = (&file-> details->display_name); __typeof__ (*(&file->details ->display_name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) (_ptr); } while (0); | |||
242 | ||||
243 | if (eel_strcmp (file->details->name, display_name) == 0) { | |||
244 | file->details->display_name = g_ref_string_acquire (file->details->name); | |||
245 | } else { | |||
246 | file->details->display_name = g_ref_string_new (display_name); | |||
247 | } | |||
248 | ||||
249 | g_free (file->details->display_name_collation_key); | |||
250 | file->details->display_name_collation_key = g_utf8_collate_key_for_filename (display_name, -1); | |||
251 | } | |||
252 | ||||
253 | if (eel_strcmp (file->details->edit_name, edit_name) != 0) { | |||
254 | changed = TRUE(!(0)); | |||
255 | ||||
256 | g_clear_pointer (&file->details->edit_name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->edit_name ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->edit_name)) _pp = (&file-> details->edit_name); __typeof__ (*(&file->details-> edit_name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
257 | if (eel_strcmp (file->details->display_name, edit_name) == 0) { | |||
258 | file->details->edit_name = g_ref_string_acquire (file->details->display_name); | |||
259 | } else { | |||
260 | file->details->edit_name = g_ref_string_new (edit_name); | |||
261 | } | |||
262 | } | |||
263 | ||||
264 | file->details->got_custom_display_name = custom; | |||
265 | return changed; | |||
266 | } | |||
267 | ||||
268 | static void | |||
269 | baul_file_clear_display_name (BaulFile *file) | |||
270 | { | |||
271 | g_clear_pointer (&file->details->display_name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->display_name ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->display_name)) _pp = (&file-> details->display_name); __typeof__ (*(&file->details ->display_name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) (_ptr); } while (0); | |||
272 | file->details->display_name = NULL((void*)0); | |||
273 | g_free (file->details->display_name_collation_key); | |||
274 | file->details->display_name_collation_key = NULL((void*)0); | |||
275 | g_clear_pointer (&file->details->edit_name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->edit_name ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->edit_name)) _pp = (&file-> details->edit_name); __typeof__ (*(&file->details-> edit_name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
276 | file->details->edit_name = NULL((void*)0); | |||
277 | } | |||
278 | ||||
279 | static gboolean | |||
280 | foreach_metadata_free (gpointer key, | |||
281 | gpointer value, | |||
282 | gpointer user_data) | |||
283 | { | |||
284 | guint id; | |||
285 | ||||
286 | id = GPOINTER_TO_UINT (key)((guint) (gulong) (key)); | |||
287 | ||||
288 | if (id & METADATA_ID_IS_LIST_MASK(1U<<31)) { | |||
289 | g_strfreev ((char **)value); | |||
290 | } else { | |||
291 | g_free ((char *)value); | |||
292 | } | |||
293 | return TRUE(!(0)); | |||
294 | } | |||
295 | ||||
296 | ||||
297 | static void | |||
298 | metadata_hash_free (GHashTable *hash) | |||
299 | { | |||
300 | g_hash_table_foreach_remove (hash, | |||
301 | foreach_metadata_free, | |||
302 | NULL((void*)0)); | |||
303 | g_hash_table_destroy (hash); | |||
304 | } | |||
305 | ||||
306 | static gboolean | |||
307 | metadata_hash_equal (GHashTable *hash1, | |||
308 | GHashTable *hash2) | |||
309 | { | |||
310 | GHashTableIter iter; | |||
311 | gpointer key1, value1, value2; | |||
312 | guint id; | |||
313 | ||||
314 | if (hash1 == NULL((void*)0) && hash2 == NULL((void*)0)) { | |||
315 | return TRUE(!(0)); | |||
316 | } | |||
317 | ||||
318 | if (hash1 == NULL((void*)0) || hash2 == NULL((void*)0)) { | |||
319 | return FALSE(0); | |||
320 | } | |||
321 | ||||
322 | if (g_hash_table_size (hash1) != | |||
323 | g_hash_table_size (hash2)) { | |||
324 | return FALSE(0); | |||
325 | } | |||
326 | ||||
327 | g_hash_table_iter_init (&iter, hash1); | |||
328 | while (g_hash_table_iter_next (&iter, &key1, &value1)) { | |||
329 | value2 = g_hash_table_lookup (hash2, key1); | |||
330 | if (value2 == NULL((void*)0)) { | |||
331 | return FALSE(0); | |||
332 | } | |||
333 | id = GPOINTER_TO_UINT (key1)((guint) (gulong) (key1)); | |||
334 | if (id & METADATA_ID_IS_LIST_MASK(1U<<31)) { | |||
335 | if (!eel_g_strv_equal ((char **)value1, (char **)value2)) { | |||
336 | return FALSE(0); | |||
337 | } | |||
338 | } else { | |||
339 | if (strcmp ((char *)value1, (char *)value2) != 0) { | |||
340 | return FALSE(0); | |||
341 | } | |||
342 | } | |||
343 | } | |||
344 | ||||
345 | return TRUE(!(0)); | |||
346 | } | |||
347 | ||||
348 | static void | |||
349 | clear_metadata (BaulFile *file) | |||
350 | { | |||
351 | if (file->details->metadata) { | |||
352 | metadata_hash_free (file->details->metadata); | |||
353 | file->details->metadata = NULL((void*)0); | |||
354 | } | |||
355 | } | |||
356 | ||||
357 | static GHashTable * | |||
358 | get_metadata_from_info (GFileInfo *info) | |||
359 | { | |||
360 | GHashTable *metadata; | |||
361 | char **attrs; | |||
362 | guint id; | |||
363 | int i; | |||
364 | GFileAttributeType type; | |||
365 | gpointer value; | |||
366 | ||||
367 | attrs = g_file_info_list_attributes (info, "metadata"); | |||
368 | ||||
369 | metadata = g_hash_table_new (NULL((void*)0), NULL((void*)0)); | |||
370 | ||||
371 | for (i = 0; attrs[i] != NULL((void*)0); i++) { | |||
372 | id = baul_metadata_get_id (attrs[i] + strlen ("metadata::")); | |||
373 | if (id == 0) { | |||
374 | continue; | |||
375 | } | |||
376 | ||||
377 | if (!g_file_info_get_attribute_data (info, attrs[i], | |||
378 | &type, &value, NULL((void*)0))) { | |||
379 | continue; | |||
380 | } | |||
381 | ||||
382 | if (type == G_FILE_ATTRIBUTE_TYPE_STRING) { | |||
383 | g_hash_table_insert (metadata, GUINT_TO_POINTER (id)((gpointer) (gulong) (id)), | |||
384 | g_strdup ((char *)value)); | |||
385 | } else if (type == G_FILE_ATTRIBUTE_TYPE_STRINGV) { | |||
386 | id |= METADATA_ID_IS_LIST_MASK(1U<<31); | |||
387 | g_hash_table_insert (metadata, GUINT_TO_POINTER (id)((gpointer) (gulong) (id)), | |||
388 | g_strdupv ((char **)value)); | |||
389 | } | |||
390 | } | |||
391 | ||||
392 | g_strfreev (attrs); | |||
393 | ||||
394 | return metadata; | |||
395 | } | |||
396 | ||||
397 | gboolean | |||
398 | baul_file_update_metadata_from_info (BaulFile *file, | |||
399 | GFileInfo *info) | |||
400 | { | |||
401 | gboolean changed = FALSE(0); | |||
402 | ||||
403 | if (g_file_info_has_namespace (info, "metadata")) { | |||
404 | GHashTable *metadata; | |||
405 | ||||
406 | metadata = get_metadata_from_info (info); | |||
407 | if (!metadata_hash_equal (metadata, | |||
408 | file->details->metadata)) { | |||
409 | changed = TRUE(!(0)); | |||
410 | clear_metadata (file); | |||
411 | file->details->metadata = metadata; | |||
412 | } else { | |||
413 | metadata_hash_free (metadata); | |||
414 | } | |||
415 | } else if (file->details->metadata) { | |||
416 | changed = TRUE(!(0)); | |||
417 | clear_metadata (file); | |||
418 | } | |||
419 | return changed; | |||
420 | } | |||
421 | ||||
422 | void | |||
423 | baul_file_clear_info (BaulFile *file) | |||
424 | { | |||
425 | file->details->got_file_info = FALSE(0); | |||
426 | if (file->details->get_info_error) { | |||
427 | g_error_free (file->details->get_info_error); | |||
428 | file->details->get_info_error = NULL((void*)0); | |||
429 | } | |||
430 | /* Reset to default type, which might be other than unknown for | |||
431 | special kinds of files like the desktop or a search directory */ | |||
432 | file->details->type = BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->default_file_type; | |||
433 | ||||
434 | if (!file->details->got_custom_display_name) { | |||
435 | baul_file_clear_display_name (file); | |||
436 | } | |||
437 | ||||
438 | if (!file->details->got_custom_activation_uri && | |||
439 | file->details->activation_uri != NULL((void*)0)) { | |||
440 | g_free (file->details->activation_uri); | |||
441 | file->details->activation_uri = NULL((void*)0); | |||
442 | } | |||
443 | ||||
444 | if (file->details->icon != NULL((void*)0)) { | |||
445 | g_object_unref (file->details->icon); | |||
446 | file->details->icon = NULL((void*)0); | |||
447 | } | |||
448 | ||||
449 | g_free (file->details->thumbnail_path); | |||
450 | file->details->thumbnail_path = NULL((void*)0); | |||
451 | file->details->thumbnailing_failed = FALSE(0); | |||
452 | ||||
453 | file->details->is_launcher = FALSE(0); | |||
454 | file->details->is_foreign_link = FALSE(0); | |||
455 | file->details->is_trusted_link = FALSE(0); | |||
456 | file->details->is_symlink = FALSE(0); | |||
457 | file->details->is_hidden = FALSE(0); | |||
458 | file->details->is_backup = FALSE(0); | |||
459 | file->details->is_mountpoint = FALSE(0); | |||
460 | file->details->uid = -1; | |||
461 | file->details->gid = -1; | |||
462 | file->details->can_read = TRUE(!(0)); | |||
463 | file->details->can_write = TRUE(!(0)); | |||
464 | file->details->can_execute = TRUE(!(0)); | |||
465 | file->details->can_delete = TRUE(!(0)); | |||
466 | file->details->can_trash = TRUE(!(0)); | |||
467 | file->details->can_rename = TRUE(!(0)); | |||
468 | file->details->can_mount = FALSE(0); | |||
469 | file->details->can_unmount = FALSE(0); | |||
470 | file->details->can_eject = FALSE(0); | |||
471 | file->details->can_start = FALSE(0); | |||
472 | file->details->can_start_degraded = FALSE(0); | |||
473 | file->details->can_stop = FALSE(0); | |||
474 | file->details->start_stop_type = G_DRIVE_START_STOP_TYPE_UNKNOWN; | |||
475 | file->details->can_poll_for_media = FALSE(0); | |||
476 | file->details->is_media_check_automatic = FALSE(0); | |||
477 | file->details->has_permissions = FALSE(0); | |||
478 | file->details->permissions = 0; | |||
479 | file->details->size = -1; | |||
480 | file->details->size_on_disk = -1; | |||
481 | file->details->sort_order = 0; | |||
482 | file->details->mtime = 0; | |||
483 | file->details->atime = 0; | |||
484 | file->details->ctime = 0; | |||
485 | file->details->trash_time = 0; | |||
486 | g_free (file->details->symlink_name); | |||
487 | file->details->symlink_name = NULL((void*)0); | |||
488 | g_clear_pointer (&file->details->mime_type, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->mime_type ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->mime_type)) _pp = (&file-> details->mime_type); __typeof__ (*(&file->details-> mime_type)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
489 | file->details->mime_type = NULL((void*)0); | |||
490 | g_free (file->details->selinux_context); | |||
491 | file->details->selinux_context = NULL((void*)0); | |||
492 | g_free (file->details->description); | |||
493 | file->details->description = NULL((void*)0); | |||
494 | g_clear_pointer (&file->details->owner, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->owner ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->owner)) _pp = (&file->details ->owner); __typeof__ (*(&file->details->owner)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
495 | file->details->owner = NULL((void*)0); | |||
496 | g_clear_pointer (&file->details->owner_real, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->owner_real ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->owner_real)) _pp = (&file-> details->owner_real); __typeof__ (*(&file->details-> owner_real)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
497 | file->details->owner_real = NULL((void*)0); | |||
498 | g_clear_pointer (&file->details->group, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->group ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->group)) _pp = (&file->details ->group); __typeof__ (*(&file->details->group)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
499 | file->details->group = NULL((void*)0); | |||
500 | ||||
501 | g_clear_pointer (&file->details->filesystem_id, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->filesystem_id ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->filesystem_id)) _pp = (&file ->details->filesystem_id); __typeof__ (*(&file-> details->filesystem_id)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) (_ptr); } while (0); | |||
502 | file->details->filesystem_id = NULL((void*)0); | |||
503 | ||||
504 | clear_metadata (file); | |||
505 | } | |||
506 | ||||
507 | static BaulFile * | |||
508 | baul_file_new_from_filename (BaulDirectory *directory, | |||
509 | const char *filename, | |||
510 | gboolean self_owned) | |||
511 | { | |||
512 | BaulFile *file; | |||
513 | ||||
514 | g_assert (BAUL_IS_DIRECTORY (directory))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((directory)); GType __t = (baul_directory_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 514, ( (const char*) (__func__)), "BAUL_IS_DIRECTORY (directory)"); } while (0); | |||
515 | g_assert (filename != NULL)do { if (filename != ((void*)0)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 515, ((const char*) (__func__) ), "filename != NULL"); } while (0); | |||
516 | g_assert (filename[0] != '\0')do { if (filename[0] != '\0') ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 516, ((const char*) (__func__) ), "filename[0] != '\\0'"); } while (0); | |||
517 | ||||
518 | if (BAUL_IS_DESKTOP_DIRECTORY (directory)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (directory)); GType __t = (baul_desktop_directory_get_type()) ; gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0) ); else __r = g_type_check_instance_is_a (__inst, __t); __r; } ))))) { | |||
519 | if (self_owned) { | |||
520 | file = BAUL_FILE (g_object_new (BAUL_TYPE_DESKTOP_DIRECTORY_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_desktop_directory_file_get_type(), (( void*)0)))), (baul_file_get_type()))))); | |||
521 | } else { | |||
522 | /* This doesn't normally happen, unless the user somehow types in a uri | |||
523 | * that references a file like this. (See #349840) */ | |||
524 | file = BAUL_FILE (g_object_new (BAUL_TYPE_VFS_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_vfs_file_get_type(), ((void*)0)))), ( baul_file_get_type()))))); | |||
525 | } | |||
526 | } else if (BAUL_IS_SEARCH_DIRECTORY (directory)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (directory)); GType __t = (baul_search_directory_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0) ); else __r = g_type_check_instance_is_a (__inst, __t); __r; } ))))) { | |||
527 | if (self_owned) { | |||
528 | file = BAUL_FILE (g_object_new (BAUL_TYPE_SEARCH_DIRECTORY_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_search_directory_file_get_type(), ((void *)0)))), (baul_file_get_type()))))); | |||
529 | } else { | |||
530 | /* This doesn't normally happen, unless the user somehow types in a uri | |||
531 | * that references a file like this. (See #349840) */ | |||
532 | file = BAUL_FILE (g_object_new (BAUL_TYPE_VFS_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_vfs_file_get_type(), ((void*)0)))), ( baul_file_get_type()))))); | |||
533 | } | |||
534 | } else if (g_str_has_suffix (filename, BAUL_SAVED_SEARCH_EXTENSION".savedSearch")) { | |||
535 | file = BAUL_FILE (g_object_new (BAUL_TYPE_SAVED_SEARCH_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_saved_search_file_get_type(), ((void* )0)))), (baul_file_get_type()))))); | |||
536 | } else { | |||
537 | file = BAUL_FILE (g_object_new (BAUL_TYPE_VFS_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_vfs_file_get_type(), ((void*)0)))), ( baul_file_get_type()))))); | |||
538 | } | |||
539 | ||||
540 | file->details->directory = baul_directory_ref (directory); | |||
541 | ||||
542 | file->details->name = g_ref_string_new (filename); | |||
543 | ||||
544 | #ifdef BAUL_FILE_DEBUG_REF | |||
545 | DEBUG_REF_PRINTFprintf("%10p ref'd", file); | |||
546 | #endif | |||
547 | ||||
548 | return file; | |||
549 | } | |||
550 | ||||
551 | static void | |||
552 | modify_link_hash_table (BaulFile *file, | |||
553 | ModifyListFunction modify_function) | |||
554 | { | |||
555 | char *target_uri; | |||
556 | gboolean found; | |||
557 | gpointer original_key; | |||
558 | GList **list_ptr; | |||
559 | ||||
560 | /* Check if there is a symlink name. If none, we are OK. */ | |||
561 | if (file->details->symlink_name == NULL((void*)0) || !baul_file_is_symbolic_link (file)) { | |||
562 | return; | |||
563 | } | |||
564 | ||||
565 | /* Create the hash table first time through. */ | |||
566 | if (symbolic_links == NULL((void*)0)) { | |||
567 | symbolic_links = g_hash_table_new (g_str_hash, g_str_equal); | |||
568 | } | |||
569 | ||||
570 | target_uri = baul_file_get_symbolic_link_target_uri (file); | |||
571 | ||||
572 | /* Find the old contents of the hash table. */ | |||
573 | found = g_hash_table_lookup_extended | |||
574 | (symbolic_links, target_uri, | |||
575 | &original_key, (gpointer *)&list_ptr); | |||
576 | if (!found) { | |||
577 | list_ptr = g_new0 (GList *, 1)((GList * *) g_malloc0_n ((1), sizeof (GList *))); | |||
578 | original_key = g_strdup (target_uri); | |||
579 | g_hash_table_insert (symbolic_links, original_key, list_ptr); | |||
580 | } | |||
581 | (* modify_function) (list_ptr, file); | |||
582 | if (*list_ptr == NULL((void*)0)) { | |||
583 | g_hash_table_remove (symbolic_links, target_uri); | |||
584 | g_free (list_ptr); | |||
585 | g_free (original_key); | |||
586 | } | |||
587 | g_free (target_uri); | |||
588 | } | |||
589 | ||||
590 | static void | |||
591 | symbolic_link_weak_notify (gpointer data, | |||
592 | GObject *where_the_object_was) | |||
593 | { | |||
594 | GList **list = data; | |||
595 | /* This really shouldn't happen, but we're seeing some strange things in | |||
596 | bug #358172 where the symlink hashtable isn't correctly updated. */ | |||
597 | *list = g_list_remove (*list, where_the_object_was); | |||
598 | } | |||
599 | ||||
600 | static void | |||
601 | add_to_link_hash_table_list (GList **list, BaulFile *file) | |||
602 | { | |||
603 | if (g_list_find (*list, file) != NULL((void*)0)) { | |||
604 | g_warning ("Adding file to symlink_table multiple times. " | |||
605 | "Please add feedback of what you were doing at https://bugzilla.gnome.org/show_bug.cgi?id=358172\n"); | |||
606 | return; | |||
607 | } | |||
608 | g_object_weak_ref (G_OBJECT (file)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((file)), (((GType) ((20) << (2)))))))), symbolic_link_weak_notify, list); | |||
609 | *list = g_list_prepend (*list, file); | |||
610 | } | |||
611 | ||||
612 | static void | |||
613 | add_to_link_hash_table (BaulFile *file) | |||
614 | { | |||
615 | modify_link_hash_table (file, add_to_link_hash_table_list); | |||
616 | } | |||
617 | ||||
618 | static void | |||
619 | remove_from_link_hash_table_list (GList **list, BaulFile *file) | |||
620 | { | |||
621 | if (g_list_find (*list, file) != NULL((void*)0)) { | |||
622 | g_object_weak_unref (G_OBJECT (file)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((file)), (((GType) ((20) << (2)))))))), symbolic_link_weak_notify, list); | |||
623 | *list = g_list_remove (*list, file); | |||
624 | } | |||
625 | } | |||
626 | ||||
627 | static void | |||
628 | remove_from_link_hash_table (BaulFile *file) | |||
629 | { | |||
630 | modify_link_hash_table (file, remove_from_link_hash_table_list); | |||
631 | } | |||
632 | ||||
633 | BaulFile * | |||
634 | baul_file_new_from_info (BaulDirectory *directory, | |||
635 | GFileInfo *info) | |||
636 | { | |||
637 | BaulFile *file; | |||
638 | const char *mime_type; | |||
639 | ||||
640 | g_return_val_if_fail (BAUL_IS_DIRECTORY (directory), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((directory)); GType __t = (baul_directory_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_DIRECTORY (directory)"); return (((void *)0)); } } while (0); | |||
641 | g_return_val_if_fail (info != NULL, NULL)do { if ((info != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "info != NULL"); return (((void*)0)); } } while (0); | |||
642 | ||||
643 | mime_type = g_file_info_get_content_type (info); | |||
644 | if (mime_type && | |||
645 | strcmp (mime_type, BAUL_SAVED_SEARCH_MIMETYPE"application/x-cafe-saved-search") == 0) { | |||
646 | g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY); | |||
647 | file = BAUL_FILE (g_object_new (BAUL_TYPE_SAVED_SEARCH_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_saved_search_file_get_type(), ((void* )0)))), (baul_file_get_type()))))); | |||
648 | } else { | |||
649 | file = BAUL_FILE (g_object_new (BAUL_TYPE_VFS_FILE, NULL))((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((g_object_new (baul_vfs_file_get_type(), ((void*)0)))), ( baul_file_get_type()))))); | |||
650 | } | |||
651 | ||||
652 | file->details->directory = baul_directory_ref (directory); | |||
653 | ||||
654 | update_info_and_name (file, info); | |||
655 | ||||
656 | #ifdef BAUL_FILE_DEBUG_REF | |||
657 | DEBUG_REF_PRINTFprintf("%10p ref'd", file); | |||
658 | #endif | |||
659 | ||||
660 | return file; | |||
661 | } | |||
662 | ||||
663 | static BaulFile * | |||
664 | baul_file_get_internal (GFile *location, gboolean create) | |||
665 | { | |||
666 | gboolean self_owned; | |||
667 | BaulDirectory *directory; | |||
668 | BaulFile *file; | |||
669 | GFile *parent; | |||
670 | char *basename; | |||
671 | ||||
672 | g_assert (location != NULL)do { if (location != ((void*)0)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 672, ((const char*) (__func__) ), "location != NULL"); } while (0); | |||
673 | ||||
674 | parent = g_file_get_parent (location); | |||
675 | ||||
676 | self_owned = FALSE(0); | |||
677 | if (parent == NULL((void*)0)) { | |||
678 | self_owned = TRUE(!(0)); | |||
679 | parent = g_object_ref (location)((__typeof__ (location)) (g_object_ref) (location)); | |||
680 | } | |||
681 | ||||
682 | /* Get object that represents the directory. */ | |||
683 | directory = baul_directory_get_internal (parent, create); | |||
684 | ||||
685 | g_object_unref (parent); | |||
686 | ||||
687 | /* Get the name for the file. */ | |||
688 | if (self_owned && directory != NULL((void*)0)) { | |||
689 | basename = baul_directory_get_name_for_self_as_new_file (directory); | |||
690 | } else { | |||
691 | basename = g_file_get_basename (location); | |||
692 | } | |||
693 | /* Check to see if it's a file that's already known. */ | |||
694 | if (directory == NULL((void*)0)) { | |||
695 | file = NULL((void*)0); | |||
696 | } else if (self_owned) { | |||
697 | file = directory->details->as_file; | |||
698 | } else { | |||
699 | file = baul_directory_find_file_by_name (directory, basename); | |||
700 | } | |||
701 | ||||
702 | /* Ref or create the file. */ | |||
703 | if (file != NULL((void*)0)) { | |||
704 | baul_file_ref (file); | |||
705 | } else if (create && directory != NULL((void*)0)) { | |||
706 | file = baul_file_new_from_filename (directory, basename, self_owned); | |||
707 | if (self_owned) { | |||
708 | g_assert (directory->details->as_file == NULL)do { if (directory->details->as_file == ((void*)0)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 708, ( (const char*) (__func__)), "directory->details->as_file == NULL" ); } while (0); | |||
709 | directory->details->as_file = file; | |||
710 | } else { | |||
711 | baul_directory_add_file (directory, file); | |||
712 | } | |||
713 | } | |||
714 | ||||
715 | g_free (basename); | |||
716 | baul_directory_unref (directory); | |||
717 | ||||
718 | return file; | |||
719 | } | |||
720 | ||||
721 | BaulFile * | |||
722 | baul_file_get (GFile *location) | |||
723 | { | |||
724 | return baul_file_get_internal (location, TRUE(!(0))); | |||
725 | } | |||
726 | ||||
727 | BaulFile * | |||
728 | baul_file_get_existing (GFile *location) | |||
729 | { | |||
730 | return baul_file_get_internal (location, FALSE(0)); | |||
731 | } | |||
732 | ||||
733 | BaulFile * | |||
734 | baul_file_get_existing_by_uri (const char *uri) | |||
735 | { | |||
736 | GFile *location; | |||
737 | BaulFile *file; | |||
738 | ||||
739 | location = g_file_new_for_uri (uri); | |||
740 | file = baul_file_get_internal (location, FALSE(0)); | |||
741 | g_object_unref (location); | |||
742 | ||||
743 | return file; | |||
744 | } | |||
745 | ||||
746 | BaulFile * | |||
747 | baul_file_get_by_uri (const char *uri) | |||
748 | { | |||
749 | GFile *location; | |||
750 | BaulFile *file; | |||
751 | ||||
752 | location = g_file_new_for_uri (uri); | |||
753 | file = baul_file_get_internal (location, TRUE(!(0))); | |||
754 | g_object_unref (location); | |||
755 | ||||
756 | return file; | |||
757 | } | |||
758 | ||||
759 | gboolean | |||
760 | baul_file_is_self_owned (BaulFile *file) | |||
761 | { | |||
762 | return file->details->directory->details->as_file == file; | |||
763 | } | |||
764 | ||||
765 | static void | |||
766 | finalize (GObject *object) | |||
767 | { | |||
768 | BaulDirectory *directory; | |||
769 | BaulFile *file; | |||
770 | ||||
771 | file = BAUL_FILE (object)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((object)), (baul_file_get_type()))))); | |||
772 | ||||
773 | g_assert (file->details->operations_in_progress == NULL)do { if (file->details->operations_in_progress == ((void *)0)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c" , 773, ((const char*) (__func__)), "file->details->operations_in_progress == NULL" ); } while (0); | |||
774 | ||||
775 | if (file->details->is_thumbnailing) { | |||
776 | char *uri; | |||
777 | ||||
778 | uri = baul_file_get_uri (file); | |||
779 | baul_thumbnail_remove_from_queue (uri); | |||
780 | g_free (uri); | |||
781 | } | |||
782 | ||||
783 | baul_async_destroying_file (file); | |||
784 | ||||
785 | remove_from_link_hash_table (file); | |||
786 | ||||
787 | directory = file->details->directory; | |||
788 | ||||
789 | if (baul_file_is_self_owned (file)) { | |||
790 | directory->details->as_file = NULL((void*)0); | |||
791 | } else { | |||
792 | if (!file->details->is_gone) { | |||
793 | baul_directory_remove_file (directory, file); | |||
794 | } | |||
795 | } | |||
796 | ||||
797 | if (file->details->get_info_error) { | |||
798 | g_error_free (file->details->get_info_error); | |||
799 | } | |||
800 | ||||
801 | baul_directory_unref (directory); | |||
802 | g_clear_pointer (&file->details->name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->name) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->name)) _pp = (&file->details ->name); __typeof__ (*(&file->details->name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
803 | g_clear_pointer (&file->details->display_name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->display_name ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->display_name)) _pp = (&file-> details->display_name); __typeof__ (*(&file->details ->display_name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) (_ptr); } while (0); | |||
804 | g_free (file->details->display_name_collation_key); | |||
805 | g_clear_pointer (&file->details->edit_name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->edit_name ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->edit_name)) _pp = (&file-> details->edit_name); __typeof__ (*(&file->details-> edit_name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
806 | if (file->details->icon) { | |||
807 | g_object_unref (file->details->icon); | |||
808 | } | |||
809 | g_free (file->details->thumbnail_path); | |||
810 | g_free (file->details->symlink_name); | |||
811 | g_clear_pointer (&file->details->mime_type, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->mime_type ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->mime_type)) _pp = (&file-> details->mime_type); __typeof__ (*(&file->details-> mime_type)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
812 | g_clear_pointer (&file->details->owner, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->owner ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->owner)) _pp = (&file->details ->owner); __typeof__ (*(&file->details->owner)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
813 | g_clear_pointer (&file->details->owner_real, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->owner_real ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->owner_real)) _pp = (&file-> details->owner_real); __typeof__ (*(&file->details-> owner_real)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
814 | g_clear_pointer (&file->details->group, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->group ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->group)) _pp = (&file->details ->group); __typeof__ (*(&file->details->group)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
815 | g_free (file->details->selinux_context); | |||
816 | g_free (file->details->description); | |||
817 | g_free (file->details->top_left_text); | |||
818 | g_free (file->details->custom_icon); | |||
819 | g_free (file->details->activation_uri); | |||
820 | g_free (file->details->compare_by_emblem_cache); | |||
821 | ||||
822 | if (file->details->thumbnail) { | |||
823 | g_object_unref (file->details->thumbnail); | |||
824 | } | |||
825 | if (file->details->mount) { | |||
826 | g_signal_handlers_disconnect_by_func (file->details->mount, file_mount_unmounted, file)g_signal_handlers_disconnect_matched ((file->details->mount ), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA ), 0, 0, ((void*)0), (file_mount_unmounted), (file)); | |||
827 | g_object_unref (file->details->mount); | |||
828 | } | |||
829 | ||||
830 | g_clear_pointer (&file->details->filesystem_id, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->filesystem_id ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->filesystem_id)) _pp = (&file ->details->filesystem_id); __typeof__ (*(&file-> details->filesystem_id)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) (_ptr); } while (0); | |||
831 | ||||
832 | g_list_free_full (file->details->mime_list, g_free); | |||
833 | g_list_free_full (file->details->pending_extension_emblems, g_free); | |||
834 | g_list_free_full (file->details->extension_emblems, g_free); | |||
835 | g_list_free_full (file->details->pending_info_providers, g_object_unref); | |||
836 | ||||
837 | if (file->details->pending_extension_attributes) { | |||
838 | g_hash_table_destroy (file->details->pending_extension_attributes); | |||
839 | } | |||
840 | ||||
841 | if (file->details->extension_attributes) { | |||
842 | g_hash_table_destroy (file->details->extension_attributes); | |||
843 | } | |||
844 | ||||
845 | if (file->details->metadata) { | |||
846 | metadata_hash_free (file->details->metadata); | |||
847 | } | |||
848 | ||||
849 | G_OBJECT_CLASS (baul_file_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((baul_file_parent_class)), (((GType) ((20) << (2))) )))))->finalize (object); | |||
850 | } | |||
851 | ||||
852 | BaulFile * | |||
853 | baul_file_ref (BaulFile *file) | |||
854 | { | |||
855 | if (file == NULL((void*)0)) { | |||
856 | return NULL((void*)0); | |||
857 | } | |||
858 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
859 | ||||
860 | #ifdef BAUL_FILE_DEBUG_REF | |||
861 | DEBUG_REF_PRINTFprintf("%10p ref'd", file); | |||
862 | #endif | |||
863 | ||||
864 | return g_object_ref (file)((__typeof__ (file)) (g_object_ref) (file)); | |||
865 | } | |||
866 | ||||
867 | void | |||
868 | baul_file_unref (BaulFile *file) | |||
869 | { | |||
870 | if (file == NULL((void*)0)) { | |||
871 | return; | |||
872 | } | |||
873 | ||||
874 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
875 | ||||
876 | #ifdef BAUL_FILE_DEBUG_REF | |||
877 | DEBUG_REF_PRINTFprintf("%10p unref'd", file); | |||
878 | #endif | |||
879 | ||||
880 | g_object_unref (file); | |||
881 | } | |||
882 | ||||
883 | /** | |||
884 | * baul_file_get_parent_uri_for_display: | |||
885 | * | |||
886 | * Get the uri for the parent directory. | |||
887 | * | |||
888 | * @file: The file in question. | |||
889 | * | |||
890 | * Return value: A string representing the parent's location, | |||
891 | * formatted for user display (including stripping "file://"). | |||
892 | * If the parent is NULL, returns the empty string. | |||
893 | */ | |||
894 | char * | |||
895 | baul_file_get_parent_uri_for_display (BaulFile *file) | |||
896 | { | |||
897 | GFile *parent; | |||
898 | char *result; | |||
899 | ||||
900 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 900, ( (const char*) (__func__)), "BAUL_IS_FILE (file)"); } while (0 ); | |||
901 | ||||
902 | parent = baul_file_get_parent_location (file); | |||
903 | if (parent) { | |||
904 | result = g_file_get_parse_name (parent); | |||
905 | g_object_unref (parent); | |||
906 | } else { | |||
907 | result = g_strdup (""); | |||
908 | } | |||
909 | ||||
910 | return result; | |||
911 | } | |||
912 | ||||
913 | /** | |||
914 | * baul_file_get_parent_uri: | |||
915 | * | |||
916 | * Get the uri for the parent directory. | |||
917 | * | |||
918 | * @file: The file in question. | |||
919 | * | |||
920 | * Return value: A string for the parent's location, in "raw URI" form. | |||
921 | * Use baul_file_get_parent_uri_for_display instead if the | |||
922 | * result is to be displayed on-screen. | |||
923 | * If the parent is NULL, returns the empty string. | |||
924 | */ | |||
925 | char * | |||
926 | baul_file_get_parent_uri (BaulFile *file) | |||
927 | { | |||
928 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 928, ( (const char*) (__func__)), "BAUL_IS_FILE (file)"); } while (0 ); | |||
929 | ||||
930 | if (baul_file_is_self_owned (file)) { | |||
931 | /* Callers expect an empty string, not a NULL. */ | |||
932 | return g_strdup (""); | |||
933 | } | |||
934 | ||||
935 | return baul_directory_get_uri (file->details->directory); | |||
936 | } | |||
937 | ||||
938 | GFile * | |||
939 | baul_file_get_parent_location (BaulFile *file) | |||
940 | { | |||
941 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 941, ( (const char*) (__func__)), "BAUL_IS_FILE (file)"); } while (0 ); | |||
942 | ||||
943 | if (baul_file_is_self_owned (file)) { | |||
944 | /* Callers expect an empty string, not a NULL. */ | |||
945 | return NULL((void*)0); | |||
946 | } | |||
947 | ||||
948 | return baul_directory_get_location (file->details->directory); | |||
949 | } | |||
950 | ||||
951 | BaulFile * | |||
952 | baul_file_get_parent (BaulFile *file) | |||
953 | { | |||
954 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 954, ( (const char*) (__func__)), "BAUL_IS_FILE (file)"); } while (0 ); | |||
955 | ||||
956 | if (baul_file_is_self_owned (file)) { | |||
957 | return NULL((void*)0); | |||
958 | } | |||
959 | ||||
960 | return baul_directory_get_corresponding_file (file->details->directory); | |||
961 | } | |||
962 | ||||
963 | /** | |||
964 | * baul_file_can_read: | |||
965 | * | |||
966 | * Check whether the user is allowed to read the contents of this file. | |||
967 | * | |||
968 | * @file: The file to check. | |||
969 | * | |||
970 | * Return value: FALSE if the user is definitely not allowed to read | |||
971 | * the contents of the file. If the user has read permission, or | |||
972 | * the code can't tell whether the user has read permission, | |||
973 | * returns TRUE (so failures must always be handled). | |||
974 | */ | |||
975 | gboolean | |||
976 | baul_file_can_read (BaulFile *file) | |||
977 | { | |||
978 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
979 | ||||
980 | return file->details->can_read; | |||
981 | } | |||
982 | ||||
983 | /** | |||
984 | * baul_file_can_write: | |||
985 | * | |||
986 | * Check whether the user is allowed to write to this file. | |||
987 | * | |||
988 | * @file: The file to check. | |||
989 | * | |||
990 | * Return value: FALSE if the user is definitely not allowed to write | |||
991 | * to the file. If the user has write permission, or | |||
992 | * the code can't tell whether the user has write permission, | |||
993 | * returns TRUE (so failures must always be handled). | |||
994 | */ | |||
995 | gboolean | |||
996 | baul_file_can_write (BaulFile *file) | |||
997 | { | |||
998 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
999 | ||||
1000 | return file->details->can_write; | |||
1001 | } | |||
1002 | ||||
1003 | /** | |||
1004 | * baul_file_can_execute: | |||
1005 | * | |||
1006 | * Check whether the user is allowed to execute this file. | |||
1007 | * | |||
1008 | * @file: The file to check. | |||
1009 | * | |||
1010 | * Return value: FALSE if the user is definitely not allowed to execute | |||
1011 | * the file. If the user has execute permission, or | |||
1012 | * the code can't tell whether the user has execute permission, | |||
1013 | * returns TRUE (so failures must always be handled). | |||
1014 | */ | |||
1015 | gboolean | |||
1016 | baul_file_can_execute (BaulFile *file) | |||
1017 | { | |||
1018 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1019 | ||||
1020 | return file->details->can_execute; | |||
1021 | } | |||
1022 | ||||
1023 | gboolean | |||
1024 | baul_file_can_mount (BaulFile *file) | |||
1025 | { | |||
1026 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1027 | ||||
1028 | return file->details->can_mount; | |||
1029 | } | |||
1030 | ||||
1031 | gboolean | |||
1032 | baul_file_can_unmount (BaulFile *file) | |||
1033 | { | |||
1034 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1035 | ||||
1036 | return file->details->can_unmount || | |||
1037 | (file->details->mount != NULL((void*)0) && | |||
1038 | g_mount_can_unmount (file->details->mount)); | |||
1039 | } | |||
1040 | ||||
1041 | gboolean | |||
1042 | baul_file_can_eject (BaulFile *file) | |||
1043 | { | |||
1044 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1045 | ||||
1046 | return file->details->can_eject || | |||
1047 | (file->details->mount != NULL((void*)0) && | |||
1048 | g_mount_can_eject (file->details->mount)); | |||
1049 | } | |||
1050 | ||||
1051 | gboolean | |||
1052 | baul_file_can_start (BaulFile *file) | |||
1053 | { | |||
1054 | gboolean ret; | |||
1055 | GDrive *drive; | |||
1056 | ||||
1057 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1058 | ||||
1059 | ret = FALSE(0); | |||
1060 | ||||
1061 | if (file->details->can_start) { | |||
1062 | ret = TRUE(!(0)); | |||
1063 | goto out; | |||
1064 | } | |||
1065 | ||||
1066 | if (file->details->mount != NULL((void*)0)) { | |||
1067 | drive = g_mount_get_drive (file->details->mount); | |||
1068 | if (drive != NULL((void*)0)) { | |||
1069 | ret = g_drive_can_start (drive); | |||
1070 | g_object_unref (drive); | |||
1071 | } | |||
1072 | } | |||
1073 | ||||
1074 | out: | |||
1075 | return ret; | |||
1076 | } | |||
1077 | ||||
1078 | gboolean | |||
1079 | baul_file_can_start_degraded (BaulFile *file) | |||
1080 | { | |||
1081 | gboolean ret; | |||
1082 | GDrive *drive; | |||
1083 | ||||
1084 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1085 | ||||
1086 | ret = FALSE(0); | |||
1087 | ||||
1088 | if (file->details->can_start_degraded) { | |||
1089 | ret = TRUE(!(0)); | |||
1090 | goto out; | |||
1091 | } | |||
1092 | ||||
1093 | if (file->details->mount != NULL((void*)0)) { | |||
1094 | drive = g_mount_get_drive (file->details->mount); | |||
1095 | if (drive != NULL((void*)0)) { | |||
1096 | ret = g_drive_can_start_degraded (drive); | |||
1097 | g_object_unref (drive); | |||
1098 | } | |||
1099 | } | |||
1100 | ||||
1101 | out: | |||
1102 | return ret; | |||
1103 | } | |||
1104 | ||||
1105 | gboolean | |||
1106 | baul_file_can_poll_for_media (BaulFile *file) | |||
1107 | { | |||
1108 | gboolean ret; | |||
1109 | GDrive *drive; | |||
1110 | ||||
1111 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1112 | ||||
1113 | ret = FALSE(0); | |||
1114 | ||||
1115 | if (file->details->can_poll_for_media) { | |||
1116 | ret = TRUE(!(0)); | |||
1117 | goto out; | |||
1118 | } | |||
1119 | ||||
1120 | if (file->details->mount != NULL((void*)0)) { | |||
1121 | drive = g_mount_get_drive (file->details->mount); | |||
1122 | if (drive != NULL((void*)0)) { | |||
1123 | ret = g_drive_can_poll_for_media (drive); | |||
1124 | g_object_unref (drive); | |||
1125 | } | |||
1126 | } | |||
1127 | ||||
1128 | out: | |||
1129 | return ret; | |||
1130 | } | |||
1131 | ||||
1132 | gboolean | |||
1133 | baul_file_is_media_check_automatic (BaulFile *file) | |||
1134 | { | |||
1135 | gboolean ret; | |||
1136 | GDrive *drive; | |||
1137 | ||||
1138 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1139 | ||||
1140 | ret = FALSE(0); | |||
1141 | ||||
1142 | if (file->details->is_media_check_automatic) { | |||
1143 | ret = TRUE(!(0)); | |||
1144 | goto out; | |||
1145 | } | |||
1146 | ||||
1147 | if (file->details->mount != NULL((void*)0)) { | |||
1148 | drive = g_mount_get_drive (file->details->mount); | |||
1149 | if (drive != NULL((void*)0)) { | |||
1150 | ret = g_drive_is_media_check_automatic (drive); | |||
1151 | g_object_unref (drive); | |||
1152 | } | |||
1153 | } | |||
1154 | ||||
1155 | out: | |||
1156 | return ret; | |||
1157 | } | |||
1158 | ||||
1159 | ||||
1160 | gboolean | |||
1161 | baul_file_can_stop (BaulFile *file) | |||
1162 | { | |||
1163 | gboolean ret; | |||
1164 | GDrive *drive; | |||
1165 | ||||
1166 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1167 | ||||
1168 | ret = FALSE(0); | |||
1169 | ||||
1170 | if (file->details->can_stop) { | |||
1171 | ret = TRUE(!(0)); | |||
1172 | goto out; | |||
1173 | } | |||
1174 | ||||
1175 | if (file->details->mount != NULL((void*)0)) { | |||
1176 | drive = g_mount_get_drive (file->details->mount); | |||
1177 | if (drive != NULL((void*)0)) { | |||
1178 | ret = g_drive_can_stop (drive); | |||
1179 | g_object_unref (drive); | |||
1180 | } | |||
1181 | } | |||
1182 | ||||
1183 | out: | |||
1184 | return ret; | |||
1185 | } | |||
1186 | ||||
1187 | GDriveStartStopType | |||
1188 | baul_file_get_start_stop_type (BaulFile *file) | |||
1189 | { | |||
1190 | GDriveStartStopType ret; | |||
1191 | GDrive *drive; | |||
1192 | ||||
1193 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1194 | ||||
1195 | ret = G_DRIVE_START_STOP_TYPE_UNKNOWN; | |||
1196 | ||||
1197 | ret = file->details->start_stop_type; | |||
1198 | if (ret != G_DRIVE_START_STOP_TYPE_UNKNOWN) | |||
1199 | goto out; | |||
1200 | ||||
1201 | if (file->details->mount != NULL((void*)0)) { | |||
1202 | drive = g_mount_get_drive (file->details->mount); | |||
1203 | if (drive != NULL((void*)0)) { | |||
1204 | ret = g_drive_get_start_stop_type (drive); | |||
1205 | g_object_unref (drive); | |||
1206 | } | |||
1207 | } | |||
1208 | ||||
1209 | out: | |||
1210 | return ret; | |||
1211 | } | |||
1212 | ||||
1213 | void | |||
1214 | baul_file_mount (BaulFile *file, | |||
1215 | GMountOperation *mount_op, | |||
1216 | GCancellable *cancellable, | |||
1217 | BaulFileOperationCallback callback, | |||
1218 | gpointer callback_data) | |||
1219 | { | |||
1220 | GError *error; | |||
1221 | ||||
1222 | if (BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->mount == NULL((void*)0)) { | |||
1223 | if (callback) { | |||
1224 | error = NULL((void*)0); | |||
1225 | g_set_error_literal (&error, G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_SUPPORTED, | |||
1226 | _("This file cannot be mounted")gettext ("This file cannot be mounted")); | |||
1227 | callback (file, NULL((void*)0), error, callback_data); | |||
1228 | g_error_free (error); | |||
1229 | } | |||
1230 | } else { | |||
1231 | BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->mount (file, mount_op, cancellable, callback, callback_data); | |||
1232 | } | |||
1233 | } | |||
1234 | ||||
1235 | typedef struct { | |||
1236 | BaulFile *file; | |||
1237 | BaulFileOperationCallback callback; | |||
1238 | gpointer callback_data; | |||
1239 | } UnmountData; | |||
1240 | ||||
1241 | static void | |||
1242 | unmount_done (void *callback_data) | |||
1243 | { | |||
1244 | UnmountData *data; | |||
1245 | ||||
1246 | data = (UnmountData *)callback_data; | |||
1247 | if (data->callback) { | |||
1248 | data->callback (data->file, NULL((void*)0), NULL((void*)0), data->callback_data); | |||
1249 | } | |||
1250 | baul_file_unref (data->file); | |||
1251 | g_free (data); | |||
1252 | } | |||
1253 | ||||
1254 | void | |||
1255 | baul_file_unmount (BaulFile *file, | |||
1256 | GMountOperation *mount_op, | |||
1257 | GCancellable *cancellable, | |||
1258 | BaulFileOperationCallback callback, | |||
1259 | gpointer callback_data) | |||
1260 | { | |||
1261 | GError *error; | |||
1262 | UnmountData *data; | |||
1263 | ||||
1264 | if (file->details->can_unmount) { | |||
1265 | if (BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->unmount != NULL((void*)0)) { | |||
1266 | BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->unmount (file, mount_op, cancellable, callback, callback_data); | |||
1267 | } else { | |||
1268 | if (callback) { | |||
1269 | error = NULL((void*)0); | |||
1270 | g_set_error_literal (&error, G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_SUPPORTED, | |||
1271 | _("This file cannot be unmounted")gettext ("This file cannot be unmounted")); | |||
1272 | callback (file, NULL((void*)0), error, callback_data); | |||
1273 | g_error_free (error); | |||
1274 | } | |||
1275 | } | |||
1276 | } else if (file->details->mount != NULL((void*)0) && | |||
1277 | g_mount_can_unmount (file->details->mount)) { | |||
1278 | data = g_new0 (UnmountData, 1)((UnmountData *) g_malloc0_n ((1), sizeof (UnmountData))); | |||
1279 | data->file = baul_file_ref (file); | |||
1280 | data->callback = callback; | |||
1281 | data->callback_data = callback_data; | |||
1282 | baul_file_operations_unmount_mount_full (NULL((void*)0), file->details->mount, FALSE(0), TRUE(!(0)), unmount_done, data); | |||
1283 | } else if (callback) { | |||
1284 | callback (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
1285 | } | |||
1286 | } | |||
1287 | ||||
1288 | void | |||
1289 | baul_file_eject (BaulFile *file, | |||
1290 | GMountOperation *mount_op, | |||
1291 | GCancellable *cancellable, | |||
1292 | BaulFileOperationCallback callback, | |||
1293 | gpointer callback_data) | |||
1294 | { | |||
1295 | GError *error; | |||
1296 | UnmountData *data; | |||
1297 | ||||
1298 | if (file->details->can_eject) { | |||
1299 | if (BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->eject != NULL((void*)0)) { | |||
1300 | BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->eject (file, mount_op, cancellable, callback, callback_data); | |||
1301 | } else { | |||
1302 | if (callback) { | |||
1303 | error = NULL((void*)0); | |||
1304 | g_set_error_literal (&error, G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_SUPPORTED, | |||
1305 | _("This file cannot be ejected")gettext ("This file cannot be ejected")); | |||
1306 | callback (file, NULL((void*)0), error, callback_data); | |||
1307 | g_error_free (error); | |||
1308 | } | |||
1309 | } | |||
1310 | } else if (file->details->mount != NULL((void*)0) && | |||
1311 | g_mount_can_eject (file->details->mount)) { | |||
1312 | data = g_new0 (UnmountData, 1)((UnmountData *) g_malloc0_n ((1), sizeof (UnmountData))); | |||
1313 | data->file = baul_file_ref (file); | |||
1314 | data->callback = callback; | |||
1315 | data->callback_data = callback_data; | |||
1316 | baul_file_operations_unmount_mount_full (NULL((void*)0), file->details->mount, TRUE(!(0)), TRUE(!(0)), unmount_done, data); | |||
1317 | } else if (callback) { | |||
1318 | callback (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
1319 | } | |||
1320 | } | |||
1321 | ||||
1322 | void | |||
1323 | baul_file_start (BaulFile *file, | |||
1324 | GMountOperation *start_op, | |||
1325 | GCancellable *cancellable, | |||
1326 | BaulFileOperationCallback callback, | |||
1327 | gpointer callback_data) | |||
1328 | { | |||
1329 | GError *error; | |||
1330 | ||||
1331 | if ((file->details->can_start || file->details->can_start_degraded) && | |||
1332 | BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->start != NULL((void*)0)) { | |||
1333 | BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->start (file, start_op, cancellable, callback, callback_data); | |||
1334 | } else { | |||
1335 | if (callback) { | |||
1336 | error = NULL((void*)0); | |||
1337 | g_set_error_literal (&error, G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_SUPPORTED, | |||
1338 | _("This file cannot be started")gettext ("This file cannot be started")); | |||
1339 | callback (file, NULL((void*)0), error, callback_data); | |||
1340 | g_error_free (error); | |||
1341 | } | |||
1342 | } | |||
1343 | } | |||
1344 | ||||
1345 | static void | |||
1346 | file_stop_callback (GObject *source_object, | |||
1347 | GAsyncResult *res, | |||
1348 | gpointer callback_data) | |||
1349 | { | |||
1350 | BaulFileOperation *op; | |||
1351 | gboolean stopped; | |||
1352 | GError *error; | |||
1353 | ||||
1354 | op = callback_data; | |||
1355 | ||||
1356 | error = NULL((void*)0); | |||
1357 | stopped = g_drive_stop_finish (G_DRIVE (source_object)((((GDrive*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_drive_get_type ())))))), | |||
1358 | res, &error); | |||
1359 | ||||
1360 | if (!stopped && | |||
1361 | error->domain == G_IO_ERRORg_io_error_quark() && | |||
1362 | (error->code == G_IO_ERROR_FAILED_HANDLED || | |||
1363 | error->code == G_IO_ERROR_CANCELLED)) { | |||
1364 | g_error_free (error); | |||
1365 | error = NULL((void*)0); | |||
1366 | } | |||
1367 | ||||
1368 | baul_file_operation_complete (op, NULL((void*)0), error); | |||
1369 | if (error) { | |||
1370 | g_error_free (error); | |||
1371 | } | |||
1372 | } | |||
1373 | ||||
1374 | void | |||
1375 | baul_file_stop (BaulFile *file, | |||
1376 | GMountOperation *mount_op, | |||
1377 | GCancellable *cancellable, | |||
1378 | BaulFileOperationCallback callback, | |||
1379 | gpointer callback_data) | |||
1380 | { | |||
1381 | GError *error; | |||
1382 | ||||
1383 | if (BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->stop != NULL((void*)0)) { | |||
1384 | if (file->details->can_stop) { | |||
1385 | BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->stop (file, mount_op, cancellable, callback, callback_data); | |||
1386 | } else { | |||
1387 | if (callback) { | |||
1388 | error = NULL((void*)0); | |||
1389 | g_set_error_literal (&error, G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_SUPPORTED, | |||
1390 | _("This file cannot be stopped")gettext ("This file cannot be stopped")); | |||
1391 | callback (file, NULL((void*)0), error, callback_data); | |||
1392 | g_error_free (error); | |||
1393 | } | |||
1394 | } | |||
1395 | } else { | |||
1396 | GDrive *drive; | |||
1397 | ||||
1398 | drive = NULL((void*)0); | |||
1399 | if (file->details->mount != NULL((void*)0)) | |||
1400 | drive = g_mount_get_drive (file->details->mount); | |||
1401 | ||||
1402 | if (drive != NULL((void*)0) && g_drive_can_stop (drive)) { | |||
1403 | BaulFileOperation *op; | |||
1404 | ||||
1405 | op = baul_file_operation_new (file, callback, callback_data); | |||
1406 | if (cancellable) { | |||
1407 | g_object_unref (op->cancellable); | |||
1408 | op->cancellable = g_object_ref (cancellable)((__typeof__ (cancellable)) (g_object_ref) (cancellable)); | |||
1409 | } | |||
1410 | ||||
1411 | g_drive_stop (drive, | |||
1412 | G_MOUNT_UNMOUNT_NONE, | |||
1413 | mount_op, | |||
1414 | op->cancellable, | |||
1415 | file_stop_callback, | |||
1416 | op); | |||
1417 | } else { | |||
1418 | if (callback) { | |||
1419 | error = NULL((void*)0); | |||
1420 | g_set_error_literal (&error, G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_SUPPORTED, | |||
1421 | _("This file cannot be stopped")gettext ("This file cannot be stopped")); | |||
1422 | callback (file, NULL((void*)0), error, callback_data); | |||
1423 | g_error_free (error); | |||
1424 | } | |||
1425 | } | |||
1426 | ||||
1427 | if (drive != NULL((void*)0)) { | |||
1428 | g_object_unref (drive); | |||
1429 | } | |||
1430 | } | |||
1431 | } | |||
1432 | ||||
1433 | void | |||
1434 | baul_file_poll_for_media (BaulFile *file) | |||
1435 | { | |||
1436 | if (file->details->can_poll_for_media) { | |||
1437 | if (BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->stop != NULL((void*)0)) { | |||
1438 | BAUL_FILE_GET_CLASS (file)((((BaulFileClass*) (((GTypeInstance*) ((file)))->g_class) )))->poll_for_media (file); | |||
1439 | } | |||
1440 | } else if (file->details->mount != NULL((void*)0)) { | |||
1441 | GDrive *drive; | |||
1442 | drive = g_mount_get_drive (file->details->mount); | |||
1443 | if (drive != NULL((void*)0)) { | |||
1444 | g_drive_poll_for_media (drive, | |||
1445 | NULL((void*)0), /* cancellable */ | |||
1446 | NULL((void*)0), /* GAsyncReadyCallback */ | |||
1447 | NULL((void*)0)); /* user_data */ | |||
1448 | g_object_unref (drive); | |||
1449 | } | |||
1450 | } | |||
1451 | } | |||
1452 | ||||
1453 | /** | |||
1454 | * baul_file_is_desktop_directory: | |||
1455 | * | |||
1456 | * Check whether this file is the desktop directory. | |||
1457 | * | |||
1458 | * @file: The file to check. | |||
1459 | * | |||
1460 | * Return value: TRUE if this is the physical desktop directory. | |||
1461 | */ | |||
1462 | gboolean | |||
1463 | baul_file_is_desktop_directory (BaulFile *file) | |||
1464 | { | |||
1465 | GFile *dir; | |||
1466 | ||||
1467 | dir = file->details->directory->details->location; | |||
1468 | ||||
1469 | if (dir == NULL((void*)0)) { | |||
1470 | return FALSE(0); | |||
1471 | } | |||
1472 | ||||
1473 | return baul_is_desktop_directory_file (dir, file->details->name); | |||
1474 | } | |||
1475 | ||||
1476 | static gboolean | |||
1477 | is_desktop_file (BaulFile *file) | |||
1478 | { | |||
1479 | return baul_file_is_mime_type (file, "application/x-desktop"); | |||
1480 | } | |||
1481 | ||||
1482 | static gboolean | |||
1483 | can_rename_desktop_file (BaulFile *file) | |||
1484 | { | |||
1485 | GFile *location; | |||
1486 | gboolean res; | |||
1487 | ||||
1488 | location = baul_file_get_location (file); | |||
1489 | res = g_file_is_native (location); | |||
1490 | g_object_unref (location); | |||
1491 | return res; | |||
1492 | } | |||
1493 | ||||
1494 | /** | |||
1495 | * baul_file_can_rename: | |||
1496 | * | |||
1497 | * Check whether the user is allowed to change the name of the file. | |||
1498 | * | |||
1499 | * @file: The file to check. | |||
1500 | * | |||
1501 | * Return value: FALSE if the user is definitely not allowed to change | |||
1502 | * the name of the file. If the user is allowed to change the name, or | |||
1503 | * the code can't tell whether the user is allowed to change the name, | |||
1504 | * returns TRUE (so rename failures must always be handled). | |||
1505 | */ | |||
1506 | gboolean | |||
1507 | baul_file_can_rename (BaulFile *file) | |||
1508 | { | |||
1509 | gboolean can_rename; | |||
1510 | ||||
1511 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1512 | ||||
1513 | /* Nonexistent files can't be renamed. */ | |||
1514 | if (baul_file_is_gone (file)) { | |||
1515 | return FALSE(0); | |||
1516 | } | |||
1517 | ||||
1518 | /* Self-owned files can't be renamed */ | |||
1519 | if (baul_file_is_self_owned (file)) { | |||
1520 | return FALSE(0); | |||
1521 | } | |||
1522 | ||||
1523 | if ((is_desktop_file (file) && !can_rename_desktop_file (file)) || | |||
1524 | baul_file_is_home (file)) { | |||
1525 | return FALSE(0); | |||
1526 | } | |||
1527 | ||||
1528 | can_rename = TRUE(!(0)); | |||
1529 | ||||
1530 | /* Certain types of links can't be renamed */ | |||
1531 | if (BAUL_IS_DESKTOP_ICON_FILE (file)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (file)); GType __t = (baul_desktop_icon_file_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) { | |||
1532 | BaulDesktopLink *link; | |||
1533 | ||||
1534 | link = baul_desktop_icon_file_get_link (BAUL_DESKTOP_ICON_FILE (file)((((BaulDesktopIconFile*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file)), (baul_desktop_icon_file_get_type ())))))); | |||
1535 | ||||
1536 | if (link != NULL((void*)0)) { | |||
1537 | can_rename = baul_desktop_link_can_rename (link); | |||
1538 | g_object_unref (link); | |||
1539 | } | |||
1540 | } | |||
1541 | ||||
1542 | if (!can_rename) { | |||
1543 | return FALSE(0); | |||
1544 | } | |||
1545 | ||||
1546 | return file->details->can_rename; | |||
1547 | } | |||
1548 | ||||
1549 | gboolean | |||
1550 | baul_file_can_delete (BaulFile *file) | |||
1551 | { | |||
1552 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1553 | ||||
1554 | /* Nonexistent files can't be deleted. */ | |||
1555 | if (baul_file_is_gone (file)) { | |||
1556 | return FALSE(0); | |||
1557 | } | |||
1558 | ||||
1559 | /* Self-owned files can't be deleted */ | |||
1560 | if (baul_file_is_self_owned (file)) { | |||
1561 | return FALSE(0); | |||
1562 | } | |||
1563 | ||||
1564 | return file->details->can_delete; | |||
1565 | } | |||
1566 | ||||
1567 | gboolean | |||
1568 | baul_file_can_trash (BaulFile *file) | |||
1569 | { | |||
1570 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
1571 | ||||
1572 | /* Nonexistent files can't be deleted. */ | |||
1573 | if (baul_file_is_gone (file)) { | |||
1574 | return FALSE(0); | |||
1575 | } | |||
1576 | ||||
1577 | /* Self-owned files can't be deleted */ | |||
1578 | if (baul_file_is_self_owned (file)) { | |||
1579 | return FALSE(0); | |||
1580 | } | |||
1581 | ||||
1582 | return file->details->can_trash; | |||
1583 | } | |||
1584 | ||||
1585 | GFile * | |||
1586 | baul_file_get_location (BaulFile *file) | |||
1587 | { | |||
1588 | GFile *dir; | |||
1589 | ||||
1590 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
1591 | ||||
1592 | dir = file->details->directory->details->location; | |||
1593 | ||||
1594 | if (baul_file_is_self_owned (file)) { | |||
1595 | return g_object_ref (dir)((__typeof__ (dir)) (g_object_ref) (dir)); | |||
1596 | } | |||
1597 | ||||
1598 | return g_file_get_child (dir, file->details->name); | |||
1599 | } | |||
1600 | ||||
1601 | /* Return the actual uri associated with the passed-in file. */ | |||
1602 | char * | |||
1603 | baul_file_get_uri (BaulFile *file) | |||
1604 | { | |||
1605 | char *uri; | |||
1606 | GFile *loc; | |||
1607 | ||||
1608 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
1609 | ||||
1610 | loc = baul_file_get_location (file); | |||
1611 | uri = g_file_get_uri (loc); | |||
1612 | g_object_unref (loc); | |||
1613 | ||||
1614 | return uri; | |||
1615 | } | |||
1616 | ||||
1617 | char * | |||
1618 | baul_file_get_uri_scheme (BaulFile *file) | |||
1619 | { | |||
1620 | GFile *loc; | |||
1621 | char *scheme; | |||
1622 | ||||
1623 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
1624 | ||||
1625 | if (file->details->directory == NULL((void*)0) || | |||
1626 | file->details->directory->details->location == NULL((void*)0)) { | |||
1627 | return NULL((void*)0); | |||
1628 | } | |||
1629 | ||||
1630 | loc = baul_directory_get_location (file->details->directory); | |||
1631 | scheme = g_file_get_uri_scheme (loc); | |||
1632 | g_object_unref (loc); | |||
1633 | ||||
1634 | return scheme; | |||
1635 | } | |||
1636 | ||||
1637 | BaulFileOperation * | |||
1638 | baul_file_operation_new (BaulFile *file, | |||
1639 | BaulFileOperationCallback callback, | |||
1640 | gpointer callback_data) | |||
1641 | { | |||
1642 | BaulFileOperation *op; | |||
1643 | ||||
1644 | op = g_new0 (BaulFileOperation, 1)((BaulFileOperation *) g_malloc0_n ((1), sizeof (BaulFileOperation ))); | |||
1645 | op->file = baul_file_ref (file); | |||
1646 | op->callback = callback; | |||
1647 | op->callback_data = callback_data; | |||
1648 | op->cancellable = g_cancellable_new (); | |||
1649 | ||||
1650 | op->file->details->operations_in_progress = g_list_prepend | |||
1651 | (op->file->details->operations_in_progress, op); | |||
1652 | ||||
1653 | return op; | |||
1654 | } | |||
1655 | ||||
1656 | static void | |||
1657 | baul_file_operation_remove (BaulFileOperation *op) | |||
1658 | { | |||
1659 | op->file->details->operations_in_progress = g_list_remove | |||
1660 | (op->file->details->operations_in_progress, op); | |||
1661 | } | |||
1662 | ||||
1663 | void | |||
1664 | baul_file_operation_free (BaulFileOperation *op) | |||
1665 | { | |||
1666 | baul_file_operation_remove (op); | |||
1667 | baul_file_unref (op->file); | |||
1668 | g_object_unref (op->cancellable); | |||
1669 | if (op->free_data) { | |||
1670 | op->free_data (op->data); | |||
1671 | } | |||
1672 | // Start UNDO-REDO | |||
1673 | baul_undostack_manager_add_action (baul_undostack_manager_instance(), | |||
1674 | op->undo_redo_data); | |||
1675 | // End UNDO-REDO | |||
1676 | g_free (op); | |||
1677 | } | |||
1678 | ||||
1679 | void | |||
1680 | baul_file_operation_complete (BaulFileOperation *op, GFile *result_file, GError *error) | |||
1681 | { | |||
1682 | /* Claim that something changed even if the operation failed. | |||
1683 | * This makes it easier for some clients who see the "reverting" | |||
1684 | * as "changing back". | |||
1685 | */ | |||
1686 | baul_file_operation_remove (op); | |||
1687 | baul_file_changed (op->file); | |||
1688 | if (op->callback) { | |||
1689 | (* op->callback) (op->file, result_file, error, op->callback_data); | |||
1690 | } | |||
1691 | baul_file_operation_free (op); | |||
1692 | } | |||
1693 | ||||
1694 | void | |||
1695 | baul_file_operation_cancel (BaulFileOperation *op) | |||
1696 | { | |||
1697 | /* Cancel the operation if it's still in progress. */ | |||
1698 | g_cancellable_cancel (op->cancellable); | |||
1699 | } | |||
1700 | ||||
1701 | static void | |||
1702 | rename_get_info_callback (GObject *source_object, | |||
1703 | GAsyncResult *res, | |||
1704 | gpointer callback_data) | |||
1705 | { | |||
1706 | BaulFileOperation *op; | |||
1707 | GFileInfo *new_info; | |||
1708 | GError *error; | |||
1709 | ||||
1710 | op = callback_data; | |||
1711 | ||||
1712 | error = NULL((void*)0); | |||
1713 | new_info = g_file_query_info_finish (G_FILE (source_object)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_file_get_type ())))))), res, &error); | |||
1714 | if (new_info != NULL((void*)0)) { | |||
1715 | BaulDirectory *directory; | |||
1716 | BaulFile *existing_file; | |||
1717 | char *old_name; | |||
1718 | char *old_uri; | |||
1719 | char *new_uri; | |||
1720 | const char *new_name; | |||
1721 | ||||
1722 | directory = op->file->details->directory; | |||
1723 | ||||
1724 | new_name = g_file_info_get_name (new_info); | |||
1725 | ||||
1726 | /* If there was another file by the same name in this | |||
1727 | * directory, mark it gone. | |||
1728 | */ | |||
1729 | existing_file = baul_directory_find_file_by_name (directory, new_name); | |||
1730 | if (existing_file != NULL((void*)0)) { | |||
1731 | baul_file_mark_gone (existing_file); | |||
1732 | baul_file_changed (existing_file); | |||
1733 | } | |||
1734 | ||||
1735 | old_uri = baul_file_get_uri (op->file); | |||
1736 | old_name = g_strdup (op->file->details->name); | |||
1737 | ||||
1738 | update_info_and_name (op->file, new_info); | |||
1739 | ||||
1740 | g_free (old_name); | |||
1741 | ||||
1742 | new_uri = baul_file_get_uri (op->file); | |||
1743 | baul_directory_moved (old_uri, new_uri); | |||
1744 | g_free (new_uri); | |||
1745 | g_free (old_uri); | |||
1746 | ||||
1747 | /* the rename could have affected the display name if e.g. | |||
1748 | * we're in a vfolder where the name comes from a desktop file | |||
1749 | * and a rename affects the contents of the desktop file. | |||
1750 | */ | |||
1751 | if (op->file->details->got_custom_display_name) { | |||
1752 | baul_file_invalidate_attributes (op->file, | |||
1753 | BAUL_FILE_ATTRIBUTE_INFO | | |||
1754 | BAUL_FILE_ATTRIBUTE_LINK_INFO); | |||
1755 | } | |||
1756 | ||||
1757 | g_object_unref (new_info); | |||
1758 | } | |||
1759 | baul_file_operation_complete (op, NULL((void*)0), error); | |||
1760 | if (error) { | |||
1761 | g_error_free (error); | |||
1762 | } | |||
1763 | } | |||
1764 | ||||
1765 | static void | |||
1766 | rename_callback (GObject *source_object, | |||
1767 | GAsyncResult *res, | |||
1768 | gpointer callback_data) | |||
1769 | { | |||
1770 | BaulFileOperation *op; | |||
1771 | GFile *new_file; | |||
1772 | GError *error; | |||
1773 | ||||
1774 | op = callback_data; | |||
1775 | ||||
1776 | error = NULL((void*)0); | |||
1777 | new_file = g_file_set_display_name_finish (G_FILE (source_object)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_file_get_type ())))))), | |||
1778 | res, &error); | |||
1779 | ||||
1780 | if (new_file != NULL((void*)0)) { | |||
1781 | // Start UNDO-REDO | |||
1782 | baul_undostack_manager_data_set_rename_information(op->undo_redo_data, G_FILE (source_object)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_file_get_type ())))))), new_file); | |||
1783 | // End UNDO-REDO | |||
1784 | g_file_query_info_async (new_file, | |||
1785 | BAUL_FILE_DEFAULT_ATTRIBUTES"standard::*,access::*,mountable::*,time::*,unix::*,owner::*,selinux::*,thumbnail::*,id::filesystem,trash::orig-path,trash::deletion-date,metadata::*", | |||
1786 | 0, | |||
1787 | G_PRIORITY_DEFAULT0, | |||
1788 | op->cancellable, | |||
1789 | rename_get_info_callback, op); | |||
1790 | } else { | |||
1791 | baul_file_operation_complete (op, NULL((void*)0), error); | |||
1792 | g_error_free (error); | |||
1793 | } | |||
1794 | } | |||
1795 | ||||
1796 | static gboolean | |||
1797 | name_is (BaulFile *file, const char *new_name) | |||
1798 | { | |||
1799 | const char *old_name; | |||
1800 | old_name = file->details->name; | |||
1801 | return strcmp (new_name, old_name) == 0; | |||
1802 | } | |||
1803 | ||||
1804 | void | |||
1805 | baul_file_rename (BaulFile *file, | |||
1806 | const char *new_name, | |||
1807 | BaulFileOperationCallback callback, | |||
1808 | gpointer callback_data) | |||
1809 | { | |||
1810 | BaulFileOperation *op; | |||
1811 | char *old_name; | |||
1812 | char *new_file_name; | |||
1813 | gboolean success, name_changed; | |||
1814 | gboolean is_renameable_desktop_file; | |||
1815 | GFile *location; | |||
1816 | GError *error; | |||
1817 | ||||
1818 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
1819 | g_return_if_fail (new_name != NULL)do { if ((new_name != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "new_name != NULL" ); return; } } while (0); | |||
1820 | g_return_if_fail (callback != NULL)do { if ((callback != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "callback != NULL" ); return; } } while (0); | |||
1821 | ||||
1822 | is_renameable_desktop_file = | |||
1823 | is_desktop_file (file) && can_rename_desktop_file (file); | |||
1824 | ||||
1825 | /* Return an error for incoming names containing path separators. | |||
1826 | * But not for .desktop files as '/' are allowed for them */ | |||
1827 | if (strstr (new_name, "/") != NULL((void*)0) && !is_renameable_desktop_file) { | |||
1828 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_INVALID_ARGUMENT, | |||
1829 | _("Slashes are not allowed in filenames")gettext ("Slashes are not allowed in filenames")); | |||
1830 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
1831 | g_error_free (error); | |||
1832 | return; | |||
1833 | } | |||
1834 | ||||
1835 | /* Can't rename a file that's already gone. | |||
1836 | * We need to check this here because there may be a new | |||
1837 | * file with the same name. | |||
1838 | */ | |||
1839 | if (baul_file_is_gone (file)) { | |||
1840 | /* Claim that something changed even if the rename | |||
1841 | * failed. This makes it easier for some clients who | |||
1842 | * see the "reverting" to the old name as "changing | |||
1843 | * back". | |||
1844 | */ | |||
1845 | baul_file_changed (file); | |||
1846 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_FOUND, | |||
1847 | _("File not found")gettext ("File not found")); | |||
1848 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
1849 | g_error_free (error); | |||
1850 | return; | |||
1851 | } | |||
1852 | ||||
1853 | /* Test the name-hasn't-changed case explicitly, for two reasons. | |||
1854 | * (1) rename returns an error if new & old are same. | |||
1855 | * (2) We don't want to send file-changed signal if nothing changed. | |||
1856 | */ | |||
1857 | if (!BAUL_IS_DESKTOP_ICON_FILE (file)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (file)); GType __t = (baul_desktop_icon_file_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))) && | |||
1858 | !is_renameable_desktop_file && | |||
1859 | name_is (file, new_name)) { | |||
1860 | (* callback) (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
1861 | return; | |||
1862 | } | |||
1863 | ||||
1864 | /* Self-owned files can't be renamed. Test the name-not-actually-changing | |||
1865 | * case before this case. | |||
1866 | */ | |||
1867 | if (baul_file_is_self_owned (file)) { | |||
1868 | /* Claim that something changed even if the rename | |||
1869 | * failed. This makes it easier for some clients who | |||
1870 | * see the "reverting" to the old name as "changing | |||
1871 | * back". | |||
1872 | */ | |||
1873 | baul_file_changed (file); | |||
1874 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_NOT_SUPPORTED, | |||
1875 | _("Toplevel files cannot be renamed")gettext ("Toplevel files cannot be renamed")); | |||
1876 | ||||
1877 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
1878 | g_error_free (error); | |||
1879 | return; | |||
1880 | } | |||
1881 | ||||
1882 | if (BAUL_IS_DESKTOP_ICON_FILE (file)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (file)); GType __t = (baul_desktop_icon_file_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) { | |||
1883 | BaulDesktopLink *link; | |||
1884 | ||||
1885 | link = baul_desktop_icon_file_get_link (BAUL_DESKTOP_ICON_FILE (file)((((BaulDesktopIconFile*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file)), (baul_desktop_icon_file_get_type ())))))); | |||
1886 | old_name = baul_file_get_display_name (file); | |||
1887 | ||||
1888 | if ((old_name != NULL((void*)0) && strcmp (new_name, old_name) == 0)) { | |||
1889 | success = TRUE(!(0)); | |||
1890 | } else { | |||
1891 | success = (link != NULL((void*)0) && baul_desktop_link_rename (link, new_name)); | |||
1892 | } | |||
1893 | ||||
1894 | if (success) { | |||
1895 | (* callback) (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
1896 | } else { | |||
1897 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_FAILED, | |||
1898 | _("Unable to rename desktop icon")gettext ("Unable to rename desktop icon")); | |||
1899 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
1900 | g_error_free (error); | |||
1901 | } | |||
1902 | ||||
1903 | g_free (old_name); | |||
1904 | g_object_unref (link); | |||
1905 | return; | |||
1906 | } | |||
1907 | ||||
1908 | if (is_renameable_desktop_file) { | |||
1909 | char *uri; | |||
1910 | ||||
1911 | /* Don't actually change the name if the new name is the same. | |||
1912 | * This helps for the vfolder method where this can happen and | |||
1913 | * we want to minimize actual changes | |||
1914 | */ | |||
1915 | uri = baul_file_get_uri (file); | |||
1916 | old_name = baul_link_local_get_text (uri); | |||
1917 | if (old_name != NULL((void*)0) && strcmp (new_name, old_name) == 0) { | |||
1918 | success = TRUE(!(0)); | |||
1919 | name_changed = FALSE(0); | |||
1920 | } else { | |||
1921 | success = baul_link_local_set_text (uri, new_name); | |||
1922 | name_changed = TRUE(!(0)); | |||
1923 | } | |||
1924 | g_free (old_name); | |||
1925 | g_free (uri); | |||
1926 | ||||
1927 | if (!success) { | |||
1928 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_FAILED, | |||
1929 | _("Unable to rename desktop file")gettext ("Unable to rename desktop file")); | |||
1930 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
1931 | g_error_free (error); | |||
1932 | return; | |||
1933 | } | |||
1934 | new_file_name = g_strdup_printf ("%s.desktop", new_name); | |||
1935 | new_file_name = g_strdelimit (new_file_name, "/", '-'); | |||
1936 | ||||
1937 | if (name_is (file, new_file_name)) { | |||
1938 | if (name_changed) { | |||
1939 | baul_file_invalidate_attributes (file, | |||
1940 | BAUL_FILE_ATTRIBUTE_INFO | | |||
1941 | BAUL_FILE_ATTRIBUTE_LINK_INFO); | |||
1942 | } | |||
1943 | ||||
1944 | (* callback) (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
1945 | g_free (new_file_name); | |||
1946 | return; | |||
1947 | } | |||
1948 | } else { | |||
1949 | new_file_name = g_strdup (new_name); | |||
1950 | } | |||
1951 | ||||
1952 | /* Set up a renaming operation. */ | |||
1953 | op = baul_file_operation_new (file, callback, callback_data); | |||
1954 | op->is_rename = TRUE(!(0)); | |||
1955 | ||||
1956 | /* Do the renaming. */ | |||
1957 | ||||
1958 | location = baul_file_get_location (file); | |||
1959 | ||||
1960 | // Start UNDO-REDO | |||
1961 | if (!baul_undostack_manager_is_undo_redo(baul_undostack_manager_instance())) { | |||
1962 | op->undo_redo_data = baul_undostack_manager_data_new (BAUL_UNDOSTACK_RENAME, 1); | |||
1963 | } | |||
1964 | // End UNDO-REDO | |||
1965 | ||||
1966 | g_file_set_display_name_async (location, | |||
1967 | new_file_name, | |||
1968 | G_PRIORITY_DEFAULT0, | |||
1969 | op->cancellable, | |||
1970 | rename_callback, | |||
1971 | op); | |||
1972 | g_free (new_file_name); | |||
1973 | g_object_unref (location); | |||
1974 | } | |||
1975 | ||||
1976 | gboolean | |||
1977 | baul_file_rename_in_progress (BaulFile *file) | |||
1978 | { | |||
1979 | GList *node; | |||
1980 | BaulFileOperation *op = NULL((void*)0); | |||
1981 | ||||
1982 | for (node = file->details->operations_in_progress; node != NULL((void*)0); node = node->next) { | |||
1983 | op = node->data; | |||
1984 | if (op->is_rename) { | |||
1985 | return TRUE(!(0)); | |||
1986 | } | |||
1987 | } | |||
1988 | return FALSE(0); | |||
1989 | } | |||
1990 | ||||
1991 | void | |||
1992 | baul_file_cancel (BaulFile *file, | |||
1993 | BaulFileOperationCallback callback, | |||
1994 | gpointer callback_data) | |||
1995 | { | |||
1996 | GList *node, *next; | |||
1997 | BaulFileOperation *op = NULL((void*)0); | |||
1998 | ||||
1999 | for (node = file->details->operations_in_progress; node != NULL((void*)0); node = next) { | |||
2000 | next = node->next; | |||
2001 | op = node->data; | |||
2002 | ||||
2003 | g_assert (op->file == file)do { if (op->file == file) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 2003, ((const char*) (__func__ )), "op->file == file"); } while (0); | |||
2004 | if (op->callback == callback && op->callback_data == callback_data) { | |||
2005 | baul_file_operation_cancel (op); | |||
2006 | } | |||
2007 | } | |||
2008 | } | |||
2009 | ||||
2010 | gboolean | |||
2011 | baul_file_matches_uri (BaulFile *file, const char *match_uri) | |||
2012 | { | |||
2013 | GFile *match_file, *location; | |||
2014 | gboolean result; | |||
2015 | ||||
2016 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
2017 | g_return_val_if_fail (match_uri != NULL, FALSE)do { if ((match_uri != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "match_uri != NULL" ); return ((0)); } } while (0); | |||
2018 | ||||
2019 | location = baul_file_get_location (file); | |||
2020 | match_file = g_file_new_for_uri (match_uri); | |||
2021 | result = g_file_equal (location, match_file); | |||
2022 | g_object_unref (location); | |||
2023 | g_object_unref (match_file); | |||
2024 | ||||
2025 | return result; | |||
2026 | } | |||
2027 | ||||
2028 | int | |||
2029 | baul_file_compare_location (BaulFile *file_1, | |||
2030 | BaulFile *file_2) | |||
2031 | { | |||
2032 | GFile *loc_a, *loc_b; | |||
2033 | gboolean res; | |||
2034 | ||||
2035 | loc_a = baul_file_get_location (file_1); | |||
2036 | loc_b = baul_file_get_location (file_2); | |||
2037 | ||||
2038 | res = !g_file_equal (loc_a, loc_b); | |||
2039 | ||||
2040 | g_object_unref (loc_a); | |||
2041 | g_object_unref (loc_b); | |||
2042 | ||||
2043 | return (gint) res; | |||
2044 | } | |||
2045 | ||||
2046 | gboolean | |||
2047 | baul_file_is_local (BaulFile *file) | |||
2048 | { | |||
2049 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
2050 | ||||
2051 | return baul_directory_is_local (file->details->directory); | |||
2052 | } | |||
2053 | ||||
2054 | static void | |||
2055 | update_link (BaulFile *link_file, BaulFile *target_file) | |||
2056 | { | |||
2057 | g_assert (BAUL_IS_FILE (link_file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((link_file)); GType __t = (baul_file_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 2057, ((const char*) (__func__)), "BAUL_IS_FILE (link_file)"); } while (0); | |||
2058 | g_assert (BAUL_IS_FILE (target_file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((target_file)); GType __t = (baul_file_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 2058, ((const char*) (__func__)), "BAUL_IS_FILE (target_file)"); } while (0); | |||
2059 | ||||
2060 | /* FIXME bugzilla.gnome.org 42044: If we don't put any code | |||
2061 | * here then the hash table is a waste of time. | |||
2062 | */ | |||
2063 | } | |||
2064 | ||||
2065 | static GList * | |||
2066 | get_link_files (BaulFile *target_file) | |||
2067 | { | |||
2068 | GList **link_files; | |||
2069 | ||||
2070 | if (symbolic_links == NULL((void*)0)) { | |||
2071 | link_files = NULL((void*)0); | |||
2072 | } else { | |||
2073 | char *uri; | |||
2074 | ||||
2075 | uri = baul_file_get_uri (target_file); | |||
2076 | link_files = g_hash_table_lookup (symbolic_links, uri); | |||
2077 | g_free (uri); | |||
2078 | } | |||
2079 | if (link_files) { | |||
2080 | return baul_file_list_copy (*link_files); | |||
2081 | } | |||
2082 | return NULL((void*)0); | |||
2083 | } | |||
2084 | ||||
2085 | static void | |||
2086 | update_links_if_target (BaulFile *target_file) | |||
2087 | { | |||
2088 | GList *link_files, *p; | |||
2089 | ||||
2090 | link_files = get_link_files (target_file); | |||
2091 | for (p = link_files; p != NULL((void*)0); p = p->next) { | |||
2092 | update_link (BAUL_FILE (p->data)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((p->data)), (baul_file_get_type()))))), target_file); | |||
2093 | } | |||
2094 | baul_file_list_free (link_files); | |||
2095 | } | |||
2096 | ||||
2097 | static gboolean | |||
2098 | update_info_internal (BaulFile *file, | |||
2099 | GFileInfo *info, | |||
2100 | gboolean update_name) | |||
2101 | { | |||
2102 | gboolean changed; | |||
2103 | gboolean is_symlink, is_hidden, is_backup, is_mountpoint; | |||
2104 | gboolean has_permissions; | |||
2105 | guint32 permissions; | |||
2106 | gboolean can_read, can_write, can_execute, can_delete, can_trash, can_rename, can_mount, can_unmount, can_eject; | |||
2107 | gboolean can_start, can_start_degraded, can_stop, can_poll_for_media, is_media_check_automatic; | |||
2108 | GDriveStartStopType start_stop_type; | |||
2109 | gboolean thumbnailing_failed; | |||
2110 | int uid, gid; | |||
2111 | goffset size; | |||
2112 | goffset size_on_disk; | |||
2113 | int sort_order; | |||
2114 | time_t atime, mtime, ctime; | |||
2115 | time_t trash_time; | |||
2116 | GTimeVal g_trash_time; | |||
2117 | const char * time_string; | |||
2118 | const char *symlink_name, *mime_type, *selinux_context, *thumbnail_path; | |||
2119 | GFileType file_type; | |||
2120 | GIcon *icon; | |||
2121 | const char *description; | |||
2122 | const char *filesystem_id; | |||
2123 | const char *trash_orig_path; | |||
2124 | const char *group, *owner, *owner_real; | |||
2125 | gboolean free_owner, free_group; | |||
2126 | ||||
2127 | if (file->details->is_gone) { | |||
2128 | return FALSE(0); | |||
2129 | } | |||
2130 | ||||
2131 | if (info == NULL((void*)0)) { | |||
2132 | baul_file_mark_gone (file); | |||
2133 | return TRUE(!(0)); | |||
2134 | } | |||
2135 | ||||
2136 | file->details->file_info_is_up_to_date = TRUE(!(0)); | |||
2137 | ||||
2138 | /* FIXME bugzilla.gnome.org 42044: Need to let links that | |||
2139 | * point to the old name know that the file has been renamed. | |||
2140 | */ | |||
2141 | ||||
2142 | remove_from_link_hash_table (file); | |||
2143 | ||||
2144 | changed = FALSE(0); | |||
2145 | ||||
2146 | if (!file->details->got_file_info) { | |||
2147 | changed = TRUE(!(0)); | |||
2148 | } | |||
2149 | file->details->got_file_info = TRUE(!(0)); | |||
2150 | ||||
2151 | changed |= baul_file_set_display_name (file, | |||
2152 | g_file_info_get_display_name (info), | |||
2153 | g_file_info_get_edit_name (info), | |||
2154 | FALSE(0)); | |||
2155 | ||||
2156 | file_type = g_file_info_get_file_type (info); | |||
2157 | if (file->details->type != file_type) { | |||
2158 | changed = TRUE(!(0)); | |||
2159 | } | |||
2160 | file->details->type = file_type; | |||
2161 | ||||
2162 | if (!file->details->got_custom_activation_uri) { | |||
2163 | const char *activation_uri; | |||
2164 | ||||
2165 | activation_uri = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI"standard::target-uri"); | |||
2166 | if (activation_uri == NULL((void*)0)) { | |||
2167 | if (file->details->activation_uri) { | |||
2168 | g_free (file->details->activation_uri); | |||
2169 | file->details->activation_uri = NULL((void*)0); | |||
2170 | changed = TRUE(!(0)); | |||
2171 | } | |||
2172 | } else { | |||
2173 | char *old_activation_uri; | |||
2174 | ||||
2175 | old_activation_uri = file->details->activation_uri; | |||
2176 | file->details->activation_uri = g_strdup (activation_uri); | |||
2177 | ||||
2178 | if (old_activation_uri) { | |||
2179 | if (strcmp (old_activation_uri, | |||
2180 | file->details->activation_uri) != 0) { | |||
2181 | changed = TRUE(!(0)); | |||
2182 | } | |||
2183 | g_free (old_activation_uri); | |||
2184 | } else { | |||
2185 | changed = TRUE(!(0)); | |||
2186 | } | |||
2187 | } | |||
2188 | } | |||
2189 | ||||
2190 | is_symlink = g_file_info_get_is_symlink (info); | |||
2191 | if (file->details->is_symlink != is_symlink) { | |||
2192 | changed = TRUE(!(0)); | |||
2193 | } | |||
2194 | file->details->is_symlink = is_symlink; | |||
2195 | ||||
2196 | is_hidden = g_file_info_get_is_hidden (info); | |||
2197 | is_backup = g_file_info_get_is_backup (info); | |||
2198 | if (file->details->is_hidden != is_hidden || | |||
2199 | file->details->is_backup != is_backup) { | |||
2200 | changed = TRUE(!(0)); | |||
2201 | } | |||
2202 | file->details->is_hidden = is_hidden; | |||
2203 | file->details->is_backup = is_backup; | |||
2204 | ||||
2205 | is_mountpoint = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT"unix::is-mountpoint"); | |||
2206 | if (file->details->is_mountpoint != is_mountpoint) { | |||
2207 | changed = TRUE(!(0)); | |||
2208 | } | |||
2209 | file->details->is_mountpoint = is_mountpoint; | |||
2210 | ||||
2211 | has_permissions = g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_MODE"unix::mode"); | |||
2212 | permissions = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE"unix::mode");; | |||
2213 | if (file->details->has_permissions != has_permissions || | |||
2214 | file->details->permissions != permissions) { | |||
2215 | changed = TRUE(!(0)); | |||
2216 | } | |||
2217 | file->details->has_permissions = has_permissions; | |||
2218 | file->details->permissions = permissions; | |||
2219 | ||||
2220 | /* We default to TRUE for this if we can't know */ | |||
2221 | can_read = TRUE(!(0)); | |||
2222 | can_write = TRUE(!(0)); | |||
2223 | can_execute = TRUE(!(0)); | |||
2224 | can_delete = TRUE(!(0)); | |||
2225 | can_trash = TRUE(!(0)); | |||
2226 | can_rename = TRUE(!(0)); | |||
2227 | can_mount = FALSE(0); | |||
2228 | can_unmount = FALSE(0); | |||
2229 | can_eject = FALSE(0); | |||
2230 | can_start = FALSE(0); | |||
2231 | can_start_degraded = FALSE(0); | |||
2232 | can_stop = FALSE(0); | |||
2233 | can_poll_for_media = FALSE(0); | |||
2234 | is_media_check_automatic = FALSE(0); | |||
2235 | start_stop_type = G_DRIVE_START_STOP_TYPE_UNKNOWN; | |||
2236 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ"access::can-read")) { | |||
2237 | can_read = g_file_info_get_attribute_boolean (info, | |||
2238 | G_FILE_ATTRIBUTE_ACCESS_CAN_READ"access::can-read"); | |||
2239 | } | |||
2240 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE"access::can-write")) { | |||
2241 | can_write = g_file_info_get_attribute_boolean (info, | |||
2242 | G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE"access::can-write"); | |||
2243 | } | |||
2244 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE"access::can-execute")) { | |||
2245 | can_execute = g_file_info_get_attribute_boolean (info, | |||
2246 | G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE"access::can-execute"); | |||
2247 | } | |||
2248 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE"access::can-delete")) { | |||
2249 | can_delete = g_file_info_get_attribute_boolean (info, | |||
2250 | G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE"access::can-delete"); | |||
2251 | } | |||
2252 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH"access::can-trash")) { | |||
2253 | can_trash = g_file_info_get_attribute_boolean (info, | |||
2254 | G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH"access::can-trash"); | |||
2255 | } | |||
2256 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME"access::can-rename")) { | |||
2257 | can_rename = g_file_info_get_attribute_boolean (info, | |||
2258 | G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME"access::can-rename"); | |||
2259 | } | |||
2260 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT"mountable::can-mount")) { | |||
2261 | can_mount = g_file_info_get_attribute_boolean (info, | |||
2262 | G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT"mountable::can-mount"); | |||
2263 | } | |||
2264 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT"mountable::can-unmount")) { | |||
2265 | can_unmount = g_file_info_get_attribute_boolean (info, | |||
2266 | G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT"mountable::can-unmount"); | |||
2267 | } | |||
2268 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT"mountable::can-eject")) { | |||
2269 | can_eject = g_file_info_get_attribute_boolean (info, | |||
2270 | G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT"mountable::can-eject"); | |||
2271 | } | |||
2272 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START"mountable::can-start")) { | |||
2273 | can_start = g_file_info_get_attribute_boolean (info, | |||
2274 | G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START"mountable::can-start"); | |||
2275 | } | |||
2276 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED"mountable::can-start-degraded")) { | |||
2277 | can_start_degraded = g_file_info_get_attribute_boolean (info, | |||
2278 | G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED"mountable::can-start-degraded"); | |||
2279 | } | |||
2280 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP"mountable::can-stop")) { | |||
2281 | can_stop = g_file_info_get_attribute_boolean (info, | |||
2282 | G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP"mountable::can-stop"); | |||
2283 | } | |||
2284 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE"mountable::start-stop-type")) { | |||
2285 | start_stop_type = g_file_info_get_attribute_uint32 (info, | |||
2286 | G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE"mountable::start-stop-type"); | |||
2287 | } | |||
2288 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL"mountable::can-poll")) { | |||
2289 | can_poll_for_media = g_file_info_get_attribute_boolean (info, | |||
2290 | G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL"mountable::can-poll"); | |||
2291 | } | |||
2292 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC"mountable::is-media-check-automatic")) { | |||
2293 | is_media_check_automatic = g_file_info_get_attribute_boolean (info, | |||
2294 | G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC"mountable::is-media-check-automatic"); | |||
2295 | } | |||
2296 | if (file->details->can_read != can_read || | |||
2297 | file->details->can_write != can_write || | |||
2298 | file->details->can_execute != can_execute || | |||
2299 | file->details->can_delete != can_delete || | |||
2300 | file->details->can_trash != can_trash || | |||
2301 | file->details->can_rename != can_rename || | |||
2302 | file->details->can_mount != can_mount || | |||
2303 | file->details->can_unmount != can_unmount || | |||
2304 | file->details->can_eject != can_eject || | |||
2305 | file->details->can_start != can_start || | |||
2306 | file->details->can_start_degraded != can_start_degraded || | |||
2307 | file->details->can_stop != can_stop || | |||
2308 | file->details->start_stop_type != start_stop_type || | |||
2309 | file->details->can_poll_for_media != can_poll_for_media || | |||
2310 | file->details->is_media_check_automatic != is_media_check_automatic) { | |||
2311 | changed = TRUE(!(0)); | |||
2312 | } | |||
2313 | ||||
2314 | file->details->can_read = can_read; | |||
2315 | file->details->can_write = can_write; | |||
2316 | file->details->can_execute = can_execute; | |||
2317 | file->details->can_delete = can_delete; | |||
2318 | file->details->can_trash = can_trash; | |||
2319 | file->details->can_rename = can_rename; | |||
2320 | file->details->can_mount = can_mount; | |||
2321 | file->details->can_unmount = can_unmount; | |||
2322 | file->details->can_eject = can_eject; | |||
2323 | file->details->can_start = can_start; | |||
2324 | file->details->can_start_degraded = can_start_degraded; | |||
2325 | file->details->can_stop = can_stop; | |||
2326 | file->details->start_stop_type = start_stop_type; | |||
2327 | file->details->can_poll_for_media = can_poll_for_media; | |||
2328 | file->details->is_media_check_automatic = is_media_check_automatic; | |||
2329 | ||||
2330 | free_owner = FALSE(0); | |||
2331 | owner = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_USER"owner::user"); | |||
2332 | owner_real = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_USER_REAL"owner::user-real"); | |||
2333 | free_group = FALSE(0); | |||
2334 | group = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP"owner::group"); | |||
2335 | ||||
2336 | uid = -1; | |||
2337 | gid = -1; | |||
2338 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_UID"unix::uid")) { | |||
2339 | uid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID"unix::uid"); | |||
2340 | if (owner == NULL((void*)0)) { | |||
2341 | free_owner = TRUE(!(0)); | |||
2342 | owner = g_strdup_printf ("%d", uid); | |||
2343 | } | |||
2344 | } | |||
2345 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_GID"unix::gid")) { | |||
2346 | gid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_GID"unix::gid"); | |||
2347 | if (group == NULL((void*)0)) { | |||
2348 | free_group = TRUE(!(0)); | |||
2349 | group = g_strdup_printf ("%d", gid); | |||
2350 | } | |||
2351 | } | |||
2352 | if (file->details->uid != uid || | |||
2353 | file->details->gid != gid) { | |||
2354 | changed = TRUE(!(0)); | |||
2355 | } | |||
2356 | file->details->uid = uid; | |||
2357 | file->details->gid = gid; | |||
2358 | ||||
2359 | if (eel_strcmp (file->details->owner, owner) != 0) { | |||
2360 | changed = TRUE(!(0)); | |||
2361 | g_clear_pointer (&file->details->owner, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->owner ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->owner)) _pp = (&file->details ->owner); __typeof__ (*(&file->details->owner)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
2362 | file->details->owner = g_ref_string_new_intern (owner); | |||
2363 | } | |||
2364 | ||||
2365 | if (eel_strcmp (file->details->owner_real, owner_real) != 0) { | |||
2366 | changed = TRUE(!(0)); | |||
2367 | g_clear_pointer (&file->details->owner_real, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->owner_real ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->owner_real)) _pp = (&file-> details->owner_real); __typeof__ (*(&file->details-> owner_real)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
2368 | file->details->owner_real = g_ref_string_new_intern (owner_real); | |||
2369 | } | |||
2370 | ||||
2371 | if (eel_strcmp (file->details->group, group) != 0) { | |||
2372 | changed = TRUE(!(0)); | |||
2373 | g_clear_pointer (&file->details->group, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->group ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->group)) _pp = (&file->details ->group); __typeof__ (*(&file->details->group)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
2374 | file->details->group = g_ref_string_new_intern (group); | |||
2375 | } | |||
2376 | ||||
2377 | if (free_owner) { | |||
2378 | g_free ((char *)owner); | |||
2379 | } | |||
2380 | if (free_group) { | |||
2381 | g_free ((char *)group); | |||
2382 | } | |||
2383 | ||||
2384 | size = -1; | |||
2385 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE"standard::size")) { | |||
2386 | size = g_file_info_get_size (info); | |||
2387 | } | |||
2388 | if (file->details->size != size) { | |||
2389 | changed = TRUE(!(0)); | |||
2390 | } | |||
2391 | file->details->size = size; | |||
2392 | ||||
2393 | size_on_disk = -1; | |||
2394 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE"standard::allocated-size")) { | |||
2395 | size_on_disk = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE"standard::allocated-size"); | |||
2396 | } | |||
2397 | if (file->details->size_on_disk != size_on_disk) { | |||
2398 | changed = TRUE(!(0)); | |||
2399 | } | |||
2400 | file->details->size_on_disk = size_on_disk; | |||
2401 | ||||
2402 | sort_order = g_file_info_get_sort_order (info); | |||
2403 | if (file->details->sort_order != sort_order) { | |||
2404 | changed = TRUE(!(0)); | |||
2405 | } | |||
2406 | file->details->sort_order = sort_order; | |||
2407 | ||||
2408 | atime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_ACCESS"time::access"); | |||
2409 | ctime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_CHANGED"time::changed"); | |||
2410 | mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED"time::modified"); | |||
2411 | if (file->details->atime != atime || | |||
2412 | file->details->mtime != mtime || | |||
2413 | file->details->ctime != ctime) { | |||
2414 | if (file->details->thumbnail == NULL((void*)0)) { | |||
2415 | file->details->thumbnail_is_up_to_date = FALSE(0); | |||
2416 | } | |||
2417 | ||||
2418 | changed = TRUE(!(0)); | |||
2419 | } | |||
2420 | file->details->atime = atime; | |||
2421 | file->details->ctime = ctime; | |||
2422 | file->details->mtime = mtime; | |||
2423 | ||||
2424 | if (file->details->thumbnail != NULL((void*)0) && | |||
2425 | file->details->thumbnail_mtime != 0 && | |||
2426 | file->details->thumbnail_mtime != mtime) { | |||
2427 | file->details->thumbnail_is_up_to_date = FALSE(0); | |||
2428 | changed = TRUE(!(0)); | |||
2429 | } | |||
2430 | ||||
2431 | icon = g_file_info_get_icon (info); | |||
2432 | if (!g_icon_equal (icon, file->details->icon)) { | |||
2433 | changed = TRUE(!(0)); | |||
2434 | ||||
2435 | if (file->details->icon) { | |||
2436 | g_object_unref (file->details->icon); | |||
2437 | } | |||
2438 | file->details->icon = g_object_ref (icon)((__typeof__ (icon)) (g_object_ref) (icon)); | |||
2439 | } | |||
2440 | ||||
2441 | thumbnail_path = g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_THUMBNAIL_PATH"thumbnail::path"); | |||
2442 | if (eel_strcmp (file->details->thumbnail_path, thumbnail_path) != 0) { | |||
2443 | changed = TRUE(!(0)); | |||
2444 | g_free (file->details->thumbnail_path); | |||
2445 | file->details->thumbnail_path = g_strdup (thumbnail_path); | |||
2446 | } | |||
2447 | ||||
2448 | thumbnailing_failed = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_THUMBNAILING_FAILED"thumbnail::failed"); | |||
2449 | if (file->details->thumbnailing_failed != thumbnailing_failed) { | |||
2450 | changed = TRUE(!(0)); | |||
2451 | file->details->thumbnailing_failed = thumbnailing_failed; | |||
2452 | } | |||
2453 | ||||
2454 | symlink_name = g_file_info_get_symlink_target (info); | |||
2455 | if (eel_strcmp (file->details->symlink_name, symlink_name) != 0) { | |||
2456 | changed = TRUE(!(0)); | |||
2457 | g_free (file->details->symlink_name); | |||
2458 | file->details->symlink_name = g_strdup (symlink_name); | |||
2459 | } | |||
2460 | ||||
2461 | mime_type = g_file_info_get_content_type (info); | |||
2462 | if (eel_strcmp (file->details->mime_type, mime_type) != 0) { | |||
2463 | changed = TRUE(!(0)); | |||
2464 | g_clear_pointer (&file->details->mime_type, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->mime_type ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->mime_type)) _pp = (&file-> details->mime_type); __typeof__ (*(&file->details-> mime_type)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release ) (_ptr); } while (0); | |||
2465 | file->details->mime_type = g_ref_string_new_intern (mime_type); | |||
2466 | } | |||
2467 | ||||
2468 | selinux_context = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_SELINUX_CONTEXT"selinux::context"); | |||
2469 | if (eel_strcmp (file->details->selinux_context, selinux_context) != 0) { | |||
2470 | changed = TRUE(!(0)); | |||
2471 | g_free (file->details->selinux_context); | |||
2472 | file->details->selinux_context = g_strdup (selinux_context); | |||
2473 | } | |||
2474 | ||||
2475 | description = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION"standard::description"); | |||
2476 | if (eel_strcmp (file->details->description, description) != 0) { | |||
2477 | changed = TRUE(!(0)); | |||
2478 | g_free (file->details->description); | |||
2479 | file->details->description = g_strdup (description); | |||
2480 | } | |||
2481 | ||||
2482 | filesystem_id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILESYSTEM"id::filesystem"); | |||
2483 | if (eel_strcmp (file->details->filesystem_id, filesystem_id) != 0) { | |||
2484 | changed = TRUE(!(0)); | |||
2485 | g_clear_pointer (&file->details->filesystem_id, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->filesystem_id ) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->filesystem_id)) _pp = (&file ->details->filesystem_id); __typeof__ (*(&file-> details->filesystem_id)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) (_ptr); } while (0); | |||
2486 | file->details->filesystem_id = g_ref_string_new_intern (filesystem_id); | |||
2487 | } | |||
2488 | ||||
2489 | trash_time = 0; | |||
2490 | time_string = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_TRASH_DELETION_DATE"trash::deletion-date"); | |||
2491 | if (time_string != NULL((void*)0)) { | |||
2492 | g_time_val_from_iso8601 (time_string, &g_trash_time); | |||
2493 | trash_time = g_trash_time.tv_sec; | |||
2494 | } | |||
2495 | if (file->details->trash_time != trash_time) { | |||
2496 | changed = TRUE(!(0)); | |||
2497 | file->details->trash_time = trash_time; | |||
2498 | } | |||
2499 | ||||
2500 | trash_orig_path = g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_TRASH_ORIG_PATH"trash::orig-path"); | |||
2501 | if (eel_strcmp (file->details->trash_orig_path, trash_orig_path) != 0) { | |||
2502 | changed = TRUE(!(0)); | |||
2503 | g_free (file->details->trash_orig_path); | |||
2504 | file->details->trash_orig_path = g_strdup (trash_orig_path); | |||
2505 | } | |||
2506 | ||||
2507 | changed |= | |||
2508 | baul_file_update_metadata_from_info (file, info); | |||
2509 | ||||
2510 | if (update_name) { | |||
2511 | const char *name; | |||
2512 | ||||
2513 | name = g_file_info_get_name (info); | |||
2514 | if (file->details->name == NULL((void*)0) || | |||
2515 | strcmp (file->details->name, name) != 0) { | |||
2516 | GList *node; | |||
2517 | ||||
2518 | changed = TRUE(!(0)); | |||
2519 | ||||
2520 | node = baul_directory_begin_file_name_change | |||
2521 | (file->details->directory, file); | |||
2522 | ||||
2523 | g_clear_pointer (&file->details->name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->name) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->name)) _pp = (&file->details ->name); __typeof__ (*(&file->details->name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
2524 | if (eel_strcmp (file->details->display_name, name) == 0) { | |||
2525 | file->details->name = g_ref_string_acquire (file->details->display_name); | |||
2526 | } else { | |||
2527 | file->details->name = g_ref_string_new (name); | |||
2528 | } | |||
2529 | ||||
2530 | if (!file->details->got_custom_display_name && | |||
2531 | g_file_info_get_display_name (info) == NULL((void*)0)) { | |||
2532 | /* If the file info's display name is NULL, | |||
2533 | * baul_file_set_display_name() did | |||
2534 | * not unset the display name. | |||
2535 | */ | |||
2536 | baul_file_clear_display_name (file); | |||
2537 | } | |||
2538 | ||||
2539 | baul_directory_end_file_name_change | |||
2540 | (file->details->directory, file, node); | |||
2541 | } | |||
2542 | } | |||
2543 | ||||
2544 | if (changed) { | |||
2545 | add_to_link_hash_table (file); | |||
2546 | ||||
2547 | update_links_if_target (file); | |||
2548 | } | |||
2549 | ||||
2550 | return changed; | |||
2551 | } | |||
2552 | ||||
2553 | static gboolean | |||
2554 | update_info_and_name (BaulFile *file, | |||
2555 | GFileInfo *info) | |||
2556 | { | |||
2557 | return update_info_internal (file, info, TRUE(!(0))); | |||
2558 | } | |||
2559 | ||||
2560 | gboolean | |||
2561 | baul_file_update_info (BaulFile *file, | |||
2562 | GFileInfo *info) | |||
2563 | { | |||
2564 | return update_info_internal (file, info, FALSE(0)); | |||
2565 | } | |||
2566 | ||||
2567 | void | |||
2568 | baul_file_refresh_info (BaulFile *file) | |||
2569 | { | |||
2570 | GFile *gfile; | |||
2571 | GFileInfo *new_info; | |||
2572 | ||||
2573 | gfile = baul_file_get_location (file); | |||
2574 | new_info = g_file_query_info (gfile, BAUL_FILE_DEFAULT_ATTRIBUTES"standard::*,access::*,mountable::*,time::*,unix::*,owner::*,selinux::*,thumbnail::*,id::filesystem,trash::orig-path,trash::deletion-date,metadata::*", | |||
2575 | G_FILE_QUERY_INFO_NONE, NULL((void*)0), NULL((void*)0)); | |||
2576 | if (new_info != NULL((void*)0)) { | |||
2577 | if (baul_file_update_info (file, new_info)) { | |||
2578 | baul_file_changed (file); | |||
2579 | } | |||
2580 | g_object_unref (new_info); | |||
2581 | } | |||
2582 | g_object_unref (gfile); | |||
2583 | } | |||
2584 | ||||
2585 | static gboolean | |||
2586 | update_name_internal (BaulFile *file, | |||
2587 | const char *name, | |||
2588 | gboolean in_directory) | |||
2589 | { | |||
2590 | GList *node; | |||
2591 | ||||
2592 | g_assert (name != NULL)do { if (name != ((void*)0)) ; else g_assertion_message_expr ( ((gchar*) 0), "baul-file.c", 2592, ((const char*) (__func__)) , "name != NULL"); } while (0); | |||
2593 | ||||
2594 | if (file->details->is_gone) { | |||
2595 | return FALSE(0); | |||
2596 | } | |||
2597 | ||||
2598 | if (name_is (file, name)) { | |||
2599 | return FALSE(0); | |||
2600 | } | |||
2601 | ||||
2602 | node = NULL((void*)0); | |||
2603 | if (in_directory) { | |||
2604 | node = baul_directory_begin_file_name_change | |||
2605 | (file->details->directory, file); | |||
2606 | } | |||
2607 | ||||
2608 | g_clear_pointer (&file->details->name, g_ref_string_release)do { _Static_assert (sizeof *(&file->details->name) == sizeof (gpointer), "Expression evaluates to false"); __typeof__ ((&file->details->name)) _pp = (&file->details ->name); __typeof__ (*(&file->details->name)) _ptr = *_pp; *_pp = ((void*)0); if (_ptr) (g_ref_string_release) ( _ptr); } while (0); | |||
2609 | file->details->name = g_ref_string_new (name); | |||
2610 | ||||
2611 | if (!file->details->got_custom_display_name) { | |||
2612 | baul_file_clear_display_name (file); | |||
2613 | } | |||
2614 | ||||
2615 | if (in_directory) { | |||
2616 | baul_directory_end_file_name_change | |||
2617 | (file->details->directory, file, node); | |||
2618 | } | |||
2619 | ||||
2620 | return TRUE(!(0)); | |||
2621 | } | |||
2622 | ||||
2623 | gboolean | |||
2624 | baul_file_update_name (BaulFile *file, const char *name) | |||
2625 | { | |||
2626 | gboolean ret; | |||
2627 | ||||
2628 | ret = update_name_internal (file, name, TRUE(!(0))); | |||
2629 | ||||
2630 | if (ret) { | |||
2631 | update_links_if_target (file); | |||
2632 | } | |||
2633 | ||||
2634 | return ret; | |||
2635 | } | |||
2636 | ||||
2637 | gboolean | |||
2638 | baul_file_update_name_and_directory (BaulFile *file, | |||
2639 | const char *name, | |||
2640 | BaulDirectory *new_directory) | |||
2641 | { | |||
2642 | BaulDirectory *old_directory; | |||
2643 | FileMonitors *monitors; | |||
2644 | ||||
2645 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
2646 | g_return_val_if_fail (BAUL_IS_DIRECTORY (file->details->directory), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file->details->directory)); GType __t = (baul_directory_get_type ()); gboolean __r; if (!__inst) __r = (0); else if (__inst-> g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0 ), ((const char*) (__func__)), "BAUL_IS_DIRECTORY (file->details->directory)" ); return ((0)); } } while (0); | |||
2647 | g_return_val_if_fail (!file->details->is_gone, FALSE)do { if ((!file->details->is_gone)) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "!file->details->is_gone" ); return ((0)); } } while (0); | |||
2648 | g_return_val_if_fail (!baul_file_is_self_owned (file), FALSE)do { if ((!baul_file_is_self_owned (file))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "!baul_file_is_self_owned (file)" ); return ((0)); } } while (0); | |||
2649 | g_return_val_if_fail (BAUL_IS_DIRECTORY (new_directory), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((new_directory)); GType __t = (baul_directory_get_type()) ; gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0) ); else __r = g_type_check_instance_is_a (__inst, __t); __r; } )))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "BAUL_IS_DIRECTORY (new_directory)"); return ((0)); } } while (0); | |||
2650 | ||||
2651 | old_directory = file->details->directory; | |||
2652 | if (old_directory == new_directory) { | |||
2653 | if (name) { | |||
2654 | return update_name_internal (file, name, TRUE(!(0))); | |||
2655 | } else { | |||
2656 | return FALSE(0); | |||
2657 | } | |||
2658 | } | |||
2659 | ||||
2660 | baul_file_ref (file); | |||
2661 | ||||
2662 | /* FIXME bugzilla.gnome.org 42044: Need to let links that | |||
2663 | * point to the old name know that the file has been moved. | |||
2664 | */ | |||
2665 | ||||
2666 | remove_from_link_hash_table (file); | |||
2667 | ||||
2668 | monitors = baul_directory_remove_file_monitors (old_directory, file); | |||
2669 | baul_directory_remove_file (old_directory, file); | |||
2670 | ||||
2671 | file->details->directory = baul_directory_ref (new_directory); | |||
2672 | baul_directory_unref (old_directory); | |||
2673 | ||||
2674 | if (name) { | |||
2675 | update_name_internal (file, name, FALSE(0)); | |||
2676 | } | |||
2677 | ||||
2678 | baul_directory_add_file (new_directory, file); | |||
2679 | baul_directory_add_file_monitors (new_directory, file, monitors); | |||
2680 | ||||
2681 | add_to_link_hash_table (file); | |||
2682 | ||||
2683 | update_links_if_target (file); | |||
2684 | ||||
2685 | baul_file_unref (file); | |||
2686 | ||||
2687 | return TRUE(!(0)); | |||
2688 | } | |||
2689 | ||||
2690 | void | |||
2691 | baul_file_set_directory (BaulFile *file, | |||
2692 | BaulDirectory *new_directory) | |||
2693 | { | |||
2694 | baul_file_update_name_and_directory (file, NULL((void*)0), new_directory); | |||
2695 | } | |||
2696 | ||||
2697 | static Knowledge | |||
2698 | get_item_count (BaulFile *file, | |||
2699 | guint *count) | |||
2700 | { | |||
2701 | gboolean known, unreadable; | |||
2702 | ||||
2703 | known = baul_file_get_directory_item_count | |||
2704 | (file, count, &unreadable); | |||
2705 | if (!known) { | |||
2706 | return UNKNOWN; | |||
2707 | } | |||
2708 | if (unreadable) { | |||
2709 | return UNKNOWABLE; | |||
2710 | } | |||
2711 | return KNOWN; | |||
2712 | } | |||
2713 | ||||
2714 | static Knowledge | |||
2715 | get_size (BaulFile *file, | |||
2716 | goffset *size, | |||
2717 | gboolean size_on_disk) | |||
2718 | { | |||
2719 | /* If we tried and failed, then treat it like there is no size | |||
2720 | * to know. | |||
2721 | */ | |||
2722 | if (file->details->get_info_failed) { | |||
2723 | return UNKNOWABLE; | |||
2724 | } | |||
2725 | ||||
2726 | /* If the info is NULL that means we haven't even tried yet, | |||
2727 | * so it's just unknown, not unknowable. | |||
2728 | */ | |||
2729 | if (!file->details->got_file_info) { | |||
2730 | return UNKNOWN; | |||
2731 | } | |||
2732 | ||||
2733 | /* If we got info with no size in it, it means there is no | |||
2734 | * such thing as a size as far as cafe-vfs is concerned, | |||
2735 | * so "unknowable". | |||
2736 | */ | |||
2737 | if (size_on_disk && file->details->size_on_disk == -1) { | |||
2738 | return UNKNOWABLE; | |||
2739 | } | |||
2740 | ||||
2741 | if (!size_on_disk && file->details->size == -1) { | |||
2742 | return UNKNOWABLE; | |||
2743 | } | |||
2744 | ||||
2745 | /* We have a size! */ | |||
2746 | if (size_on_disk) { | |||
2747 | *size = file->details->size_on_disk; | |||
2748 | } else { | |||
2749 | *size = file->details->size; | |||
2750 | } | |||
2751 | ||||
2752 | return KNOWN; | |||
2753 | } | |||
2754 | ||||
2755 | static Knowledge | |||
2756 | get_time (BaulFile *file, | |||
2757 | time_t *time_out, | |||
2758 | BaulDateType type) | |||
2759 | { | |||
2760 | time_t time; | |||
2761 | ||||
2762 | /* If we tried and failed, then treat it like there is no size | |||
2763 | * to know. | |||
2764 | */ | |||
2765 | if (file->details->get_info_failed) { | |||
2766 | return UNKNOWABLE; | |||
2767 | } | |||
2768 | ||||
2769 | /* If the info is NULL that means we haven't even tried yet, | |||
2770 | * so it's just unknown, not unknowable. | |||
2771 | */ | |||
2772 | if (!file->details->got_file_info) { | |||
2773 | return UNKNOWN; | |||
2774 | } | |||
2775 | ||||
2776 | time = 0; | |||
2777 | switch (type) { | |||
2778 | case BAUL_DATE_TYPE_MODIFIED: | |||
2779 | time = file->details->mtime; | |||
2780 | break; | |||
2781 | case BAUL_DATE_TYPE_ACCESSED: | |||
2782 | time = file->details->atime; | |||
2783 | break; | |||
2784 | case BAUL_DATE_TYPE_TRASHED: | |||
2785 | time = file->details->trash_time; | |||
2786 | break; | |||
2787 | default: | |||
2788 | g_assert_not_reached ()do { g_assertion_message_expr (((gchar*) 0), "baul-file.c", 2788 , ((const char*) (__func__)), ((void*)0)); } while (0); | |||
2789 | break; | |||
2790 | } | |||
2791 | ||||
2792 | *time_out = time; | |||
2793 | ||||
2794 | /* If we got info with no modification time in it, it means | |||
2795 | * there is no such thing as a modification time as far as | |||
2796 | * cafe-vfs is concerned, so "unknowable". | |||
2797 | */ | |||
2798 | if (time == 0) { | |||
2799 | return UNKNOWABLE; | |||
2800 | } | |||
2801 | return KNOWN; | |||
2802 | } | |||
2803 | ||||
2804 | static int | |||
2805 | compare_directories_by_count (BaulFile *file_1, BaulFile *file_2) | |||
2806 | { | |||
2807 | /* Sort order: | |||
2808 | * Directories with unknown # of items | |||
2809 | * Directories with "unknowable" # of items | |||
2810 | * Directories with 0 items | |||
2811 | * Directories with n items | |||
2812 | */ | |||
2813 | ||||
2814 | Knowledge count_known_1, count_known_2; | |||
2815 | guint count_1, count_2; | |||
2816 | ||||
2817 | count_known_1 = get_item_count (file_1, &count_1); | |||
2818 | count_known_2 = get_item_count (file_2, &count_2); | |||
2819 | ||||
2820 | if (count_known_1 > count_known_2) { | |||
2821 | return -1; | |||
2822 | } | |||
2823 | if (count_known_1 < count_known_2) { | |||
2824 | return +1; | |||
2825 | } | |||
2826 | ||||
2827 | /* count_known_1 and count_known_2 are equal now. Check if count | |||
2828 | * details are UNKNOWABLE or UNKNOWN. | |||
2829 | */ | |||
2830 | if (count_known_1 == UNKNOWABLE || count_known_1 == UNKNOWN) { | |||
2831 | return 0; | |||
2832 | } | |||
2833 | ||||
2834 | if (count_1 < count_2) { | |||
2835 | return -1; | |||
2836 | } | |||
2837 | if (count_1 > count_2) { | |||
2838 | return +1; | |||
2839 | } | |||
2840 | ||||
2841 | return 0; | |||
2842 | } | |||
2843 | ||||
2844 | static int | |||
2845 | compare_files_by_size (BaulFile *file_1, BaulFile *file_2, gboolean size_on_disk) | |||
2846 | { | |||
2847 | /* Sort order: | |||
2848 | * Files with unknown size. | |||
2849 | * Files with "unknowable" size. | |||
2850 | * Files with smaller sizes. | |||
2851 | * Files with large sizes. | |||
2852 | */ | |||
2853 | ||||
2854 | Knowledge size_known_1, size_known_2; | |||
2855 | goffset size_1 = 0, size_2 = 0; | |||
2856 | ||||
2857 | size_known_1 = get_size (file_1, &size_1, size_on_disk); | |||
2858 | size_known_2 = get_size (file_2, &size_2, size_on_disk); | |||
2859 | ||||
2860 | if (size_known_1 > size_known_2) { | |||
2861 | return -1; | |||
2862 | } | |||
2863 | if (size_known_1 < size_known_2) { | |||
2864 | return +1; | |||
2865 | } | |||
2866 | ||||
2867 | /* size_known_1 and size_known_2 are equal now. Check if size | |||
2868 | * details are UNKNOWABLE or UNKNOWN | |||
2869 | */ | |||
2870 | if (size_known_1 == UNKNOWABLE || size_known_1 == UNKNOWN) { | |||
2871 | return 0; | |||
2872 | } | |||
2873 | ||||
2874 | if (size_1 < size_2) { | |||
2875 | return -1; | |||
2876 | } | |||
2877 | if (size_1 > size_2) { | |||
2878 | return +1; | |||
2879 | } | |||
2880 | ||||
2881 | return 0; | |||
2882 | } | |||
2883 | ||||
2884 | static int | |||
2885 | compare_by_size (BaulFile *file_1, BaulFile *file_2, gboolean size_on_disk) | |||
2886 | { | |||
2887 | /* Sort order: | |||
2888 | * Directories with n items | |||
2889 | * Directories with 0 items | |||
2890 | * Directories with "unknowable" # of items | |||
2891 | * Directories with unknown # of items | |||
2892 | * Files with large sizes. | |||
2893 | * Files with smaller sizes. | |||
2894 | * Files with "unknowable" size. | |||
2895 | * Files with unknown size. | |||
2896 | */ | |||
2897 | ||||
2898 | gboolean is_directory_1, is_directory_2; | |||
2899 | ||||
2900 | is_directory_1 = baul_file_is_directory (file_1); | |||
2901 | is_directory_2 = baul_file_is_directory (file_2); | |||
2902 | ||||
2903 | if (is_directory_1 && !is_directory_2) { | |||
2904 | return -1; | |||
2905 | } | |||
2906 | if (is_directory_2 && !is_directory_1) { | |||
2907 | return +1; | |||
2908 | } | |||
2909 | ||||
2910 | if (is_directory_1) { | |||
2911 | return compare_directories_by_count (file_1, file_2); | |||
2912 | } else { | |||
2913 | return compare_files_by_size (file_1, file_2, size_on_disk); | |||
2914 | } | |||
2915 | } | |||
2916 | ||||
2917 | static int | |||
2918 | compare_by_display_name (BaulFile *file_1, BaulFile *file_2) | |||
2919 | { | |||
2920 | const char *name_1, *name_2; | |||
2921 | const char *key_1, *key_2; | |||
2922 | gboolean sort_last_1, sort_last_2; | |||
2923 | int compare; | |||
2924 | ||||
2925 | name_1 = baul_file_peek_display_name (file_1); | |||
2926 | name_2 = baul_file_peek_display_name (file_2); | |||
2927 | ||||
2928 | sort_last_1 = name_1[0] == SORT_LAST_CHAR1'.' || name_1[0] == SORT_LAST_CHAR2'#'; | |||
2929 | sort_last_2 = name_2[0] == SORT_LAST_CHAR1'.' || name_2[0] == SORT_LAST_CHAR2'#'; | |||
2930 | ||||
2931 | if (sort_last_1 && !sort_last_2) { | |||
2932 | compare = +1; | |||
2933 | } else if (!sort_last_1 && sort_last_2) { | |||
2934 | compare = -1; | |||
2935 | } else { | |||
2936 | key_1 = baul_file_peek_display_name_collation_key (file_1); | |||
2937 | key_2 = baul_file_peek_display_name_collation_key (file_2); | |||
2938 | compare = strcmp (key_1, key_2); | |||
2939 | } | |||
2940 | ||||
2941 | return compare; | |||
2942 | } | |||
2943 | ||||
2944 | static int | |||
2945 | compare_by_directory_name (BaulFile *file_1, BaulFile *file_2) | |||
2946 | { | |||
2947 | char *directory_1, *directory_2; | |||
2948 | int compare; | |||
2949 | ||||
2950 | if (file_1->details->directory == file_2->details->directory) { | |||
2951 | return 0; | |||
2952 | } | |||
2953 | ||||
2954 | directory_1 = baul_file_get_parent_uri_for_display (file_1); | |||
2955 | directory_2 = baul_file_get_parent_uri_for_display (file_2); | |||
2956 | ||||
2957 | compare = g_utf8_collate (directory_1, directory_2); | |||
2958 | ||||
2959 | g_free (directory_1); | |||
2960 | g_free (directory_2); | |||
2961 | ||||
2962 | return compare; | |||
2963 | } | |||
2964 | ||||
2965 | static gboolean | |||
2966 | file_has_note (BaulFile *file) | |||
2967 | { | |||
2968 | char *note; | |||
2969 | gboolean res; | |||
2970 | ||||
2971 | note = baul_file_get_metadata (file, BAUL_METADATA_KEY_ANNOTATION"annotation", NULL((void*)0)); | |||
2972 | res = note != NULL((void*)0) && note[0] != 0; | |||
2973 | g_free (note); | |||
2974 | ||||
2975 | return res; | |||
2976 | } | |||
2977 | ||||
2978 | static GList * | |||
2979 | prepend_automatic_keywords (BaulFile *file, | |||
2980 | GList *names) | |||
2981 | { | |||
2982 | /* Prepend in reverse order. */ | |||
2983 | BaulFile *parent; | |||
2984 | ||||
2985 | parent = baul_file_get_parent (file); | |||
2986 | ||||
2987 | #ifdef TRASH_IS_FAST_ENOUGH | |||
2988 | if (baul_file_is_in_trash (file)) { | |||
2989 | names = g_list_prepend | |||
2990 | (names, g_strdup (BAUL_FILE_EMBLEM_NAME_TRASH"trash")); | |||
2991 | } | |||
2992 | #endif | |||
2993 | if (file_has_note (file)) { | |||
2994 | names = g_list_prepend | |||
2995 | (names, g_strdup (BAUL_FILE_EMBLEM_NAME_NOTE"note")); | |||
2996 | } | |||
2997 | ||||
2998 | /* Trash files are assumed to be read-only, | |||
2999 | * so we want to ignore them here. */ | |||
3000 | if (!baul_file_can_write (file) && | |||
3001 | !baul_file_is_in_trash (file) && | |||
3002 | (parent == NULL((void*)0) || baul_file_can_write (parent))) { | |||
3003 | names = g_list_prepend | |||
3004 | (names, g_strdup (BAUL_FILE_EMBLEM_NAME_CANT_WRITE"nowrite")); | |||
3005 | } | |||
3006 | if (!baul_file_can_read (file)) { | |||
3007 | names = g_list_prepend | |||
3008 | (names, g_strdup (BAUL_FILE_EMBLEM_NAME_CANT_READ"noread")); | |||
3009 | } | |||
3010 | if (baul_file_is_symbolic_link (file)) { | |||
3011 | names = g_list_prepend | |||
3012 | (names, g_strdup (BAUL_FILE_EMBLEM_NAME_SYMBOLIC_LINK"symbolic-link")); | |||
3013 | } | |||
3014 | ||||
3015 | if (parent) { | |||
3016 | baul_file_unref (parent); | |||
3017 | } | |||
3018 | ||||
3019 | ||||
3020 | return names; | |||
3021 | } | |||
3022 | ||||
3023 | static void | |||
3024 | fill_emblem_cache_if_needed (BaulFile *file) | |||
3025 | { | |||
3026 | GList *node, *keywords; | |||
3027 | char *scanner; | |||
3028 | size_t length; | |||
3029 | ||||
3030 | if (file->details->compare_by_emblem_cache != NULL((void*)0)) { | |||
3031 | /* Got a cache already. */ | |||
3032 | return; | |||
3033 | } | |||
3034 | ||||
3035 | keywords = baul_file_get_keywords (file); | |||
3036 | ||||
3037 | /* Add up the keyword string lengths */ | |||
3038 | length = 1; | |||
3039 | for (node = keywords; node != NULL((void*)0); node = node->next) { | |||
3040 | length += strlen ((const char *) node->data) + 1; | |||
3041 | } | |||
3042 | ||||
3043 | /* Now that we know how large the cache struct needs to be, allocate it. */ | |||
3044 | file->details->compare_by_emblem_cache = g_malloc (sizeof(BaulFileSortByEmblemCache) + length); | |||
3045 | ||||
3046 | /* Copy them into the cache. */ | |||
3047 | scanner = file->details->compare_by_emblem_cache->emblem_keywords; | |||
3048 | for (node = keywords; node
| |||
3049 | length = strlen ((const char *) node->data) + 1; | |||
3050 | memcpy (scanner, (const char *) node->data, length); | |||
3051 | scanner += length; | |||
3052 | } | |||
3053 | ||||
3054 | /* Zero-terminate so we can tell where the list ends. */ | |||
3055 | *scanner = 0; | |||
| ||||
3056 | ||||
3057 | g_list_free_full (keywords, g_free); | |||
3058 | } | |||
3059 | ||||
3060 | static int | |||
3061 | compare_by_emblems (BaulFile *file_1, BaulFile *file_2) | |||
3062 | { | |||
3063 | const char *keyword_cache_1, *keyword_cache_2; | |||
3064 | int compare_result; | |||
3065 | ||||
3066 | fill_emblem_cache_if_needed (file_1); | |||
| ||||
3067 | fill_emblem_cache_if_needed (file_2); | |||
3068 | ||||
3069 | /* We ignore automatic emblems, and only sort by user-added keywords. */ | |||
3070 | compare_result = 0; | |||
3071 | keyword_cache_1 = file_1->details->compare_by_emblem_cache->emblem_keywords; | |||
3072 | keyword_cache_2 = file_2->details->compare_by_emblem_cache->emblem_keywords; | |||
3073 | for (; *keyword_cache_1 != '\0' && *keyword_cache_2 != '\0';) { | |||
3074 | size_t length; | |||
3075 | ||||
3076 | compare_result = g_utf8_collate (keyword_cache_1, keyword_cache_2); | |||
3077 | if (compare_result != 0) { | |||
3078 | return compare_result; | |||
3079 | } | |||
3080 | ||||
3081 | /* Advance to the next keyword */ | |||
3082 | length = strlen (keyword_cache_1); | |||
3083 | keyword_cache_1 += length + 1; | |||
3084 | keyword_cache_2 += length + 1; | |||
3085 | } | |||
3086 | ||||
3087 | ||||
3088 | /* One or both is now NULL. */ | |||
3089 | if (*keyword_cache_1 != '\0') { | |||
3090 | g_assert (*keyword_cache_2 == '\0')do { if (*keyword_cache_2 == '\0') ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 3090, ((const char*) (__func__ )), "*keyword_cache_2 == '\\0'"); } while (0); | |||
3091 | return -1; | |||
3092 | } else if (*keyword_cache_2 != '\0') { | |||
3093 | return +1; | |||
3094 | } | |||
3095 | ||||
3096 | return 0; | |||
3097 | } | |||
3098 | ||||
3099 | static int | |||
3100 | compare_by_type (BaulFile *file_1, BaulFile *file_2) | |||
3101 | { | |||
3102 | gboolean is_directory_1; | |||
3103 | gboolean is_directory_2; | |||
3104 | char *type_string_1; | |||
3105 | char *type_string_2; | |||
3106 | int result; | |||
3107 | ||||
3108 | /* Directories go first. Then, if mime types are identical, | |||
3109 | * don't bother getting strings (for speed). This assumes | |||
3110 | * that the string is dependent entirely on the mime type, | |||
3111 | * which is true now but might not be later. | |||
3112 | */ | |||
3113 | is_directory_1 = baul_file_is_directory (file_1); | |||
3114 | is_directory_2 = baul_file_is_directory (file_2); | |||
3115 | ||||
3116 | if (is_directory_1 && is_directory_2) { | |||
3117 | return 0; | |||
3118 | } | |||
3119 | ||||
3120 | if (is_directory_1) { | |||
3121 | return -1; | |||
3122 | } | |||
3123 | ||||
3124 | if (is_directory_2) { | |||
3125 | return +1; | |||
3126 | } | |||
3127 | ||||
3128 | if (file_1->details->mime_type != NULL((void*)0) && | |||
3129 | file_2->details->mime_type != NULL((void*)0) && | |||
3130 | strcmp (file_1->details->mime_type, | |||
3131 | file_2->details->mime_type) == 0) { | |||
3132 | return 0; | |||
3133 | } | |||
3134 | ||||
3135 | type_string_1 = baul_file_get_type_as_string (file_1); | |||
3136 | type_string_2 = baul_file_get_type_as_string (file_2); | |||
3137 | ||||
3138 | result = g_utf8_collate (type_string_1, type_string_2); | |||
3139 | ||||
3140 | g_free (type_string_1); | |||
3141 | g_free (type_string_2); | |||
3142 | ||||
3143 | return result; | |||
3144 | } | |||
3145 | ||||
3146 | static int | |||
3147 | compare_by_time (BaulFile *file_1, BaulFile *file_2, BaulDateType type) | |||
3148 | { | |||
3149 | /* Sort order: | |||
3150 | * Files with unknown times. | |||
3151 | * Files with "unknowable" times. | |||
3152 | * Files with older times. | |||
3153 | * Files with newer times. | |||
3154 | */ | |||
3155 | ||||
3156 | Knowledge time_known_1, time_known_2; | |||
3157 | time_t time_1, time_2; | |||
3158 | ||||
3159 | time_1 = 0; | |||
3160 | time_2 = 0; | |||
3161 | ||||
3162 | time_known_1 = get_time (file_1, &time_1, type); | |||
3163 | time_known_2 = get_time (file_2, &time_2, type); | |||
3164 | ||||
3165 | if (time_known_1 > time_known_2) { | |||
3166 | return -1; | |||
3167 | } | |||
3168 | if (time_known_1 < time_known_2) { | |||
3169 | return +1; | |||
3170 | } | |||
3171 | ||||
3172 | /* Now time_known_1 is equal to time_known_2. Check whether | |||
3173 | * we failed to get modification times for files | |||
3174 | */ | |||
3175 | if(time_known_1 == UNKNOWABLE || time_known_1 == UNKNOWN) { | |||
3176 | return 0; | |||
3177 | } | |||
3178 | ||||
3179 | if (time_1 < time_2) { | |||
3180 | return -1; | |||
3181 | } | |||
3182 | if (time_1 > time_2) { | |||
3183 | return +1; | |||
3184 | } | |||
3185 | ||||
3186 | return 0; | |||
3187 | } | |||
3188 | ||||
3189 | static int | |||
3190 | compare_by_full_path (BaulFile *file_1, BaulFile *file_2) | |||
3191 | { | |||
3192 | int compare; | |||
3193 | ||||
3194 | compare = compare_by_directory_name (file_1, file_2); | |||
3195 | if (compare != 0) { | |||
3196 | return compare; | |||
3197 | } | |||
3198 | return compare_by_display_name (file_1, file_2); | |||
3199 | } | |||
3200 | ||||
3201 | /* prev_extension_segment: | |||
3202 | * @basename The basename of a file | |||
3203 | * @rem_chars A pointer to the amount of remaining characters | |||
3204 | * | |||
3205 | * Finds the next segment delimiter to the left. A starting character of '.' is | |||
3206 | * set to '\0'. | |||
3207 | * | |||
3208 | * Return value: The start of the previous segment (right of the dot) or | |||
3209 | * basename if there are none remaining. | |||
3210 | */ | |||
3211 | static char * | |||
3212 | prev_extension_segment (char *basename, int *rem_chars) | |||
3213 | { | |||
3214 | if (*basename == '.') { | |||
3215 | *basename = 0; | |||
3216 | basename--; | |||
3217 | (*rem_chars)--; | |||
3218 | } | |||
3219 | ||||
3220 | while (*rem_chars > 0 && *basename != '.') { | |||
3221 | (*rem_chars)--; | |||
3222 | basename--; | |||
3223 | } | |||
3224 | ||||
3225 | return basename + 1; | |||
3226 | } | |||
3227 | ||||
3228 | /* is_valid_extension_segment: | |||
3229 | * @segment Part of a modifiable zero-terminated string | |||
3230 | * @segment_index The index of the current segment | |||
3231 | * | |||
3232 | * Uses a heuristic to identify valid file extensions. | |||
3233 | * | |||
3234 | * Return value: Whether the segment is part of the file extension. | |||
3235 | */ | |||
3236 | static gboolean | |||
3237 | is_valid_extension_segment (const char *segment, int segment_index) | |||
3238 | { | |||
3239 | gboolean result; | |||
3240 | gboolean has_letters; | |||
3241 | int char_offset; | |||
3242 | switch (segment_index) { | |||
3243 | case 0: | |||
3244 | /* extremely long segments are probably not part of the extension */ | |||
3245 | result = strlen (segment) < 20; | |||
3246 | break; | |||
3247 | default: | |||
3248 | has_letters = FALSE(0); | |||
3249 | char_offset = 0; | |||
3250 | while (TRUE(!(0))) { | |||
3251 | char c; | |||
3252 | ||||
3253 | c = *(segment + char_offset); | |||
3254 | if (c == '\0') { | |||
3255 | result = has_letters; | |||
3256 | break; | |||
3257 | } | |||
3258 | /* allow digits if there are also letters */ | |||
3259 | else if (isalpha (c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISalpha )) { | |||
3260 | has_letters = TRUE(!(0)); | |||
3261 | } | |||
3262 | /* fail if it is neither digit nor letter */ | |||
3263 | else if (!isdigit (c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISdigit )) { | |||
3264 | result = FALSE(0); | |||
3265 | break; | |||
3266 | } | |||
3267 | ||||
3268 | if (char_offset >= SORT_BY_EXTENSION_FOLLOWING_MAX_LENGTH3) { | |||
3269 | result = FALSE(0); | |||
3270 | break; | |||
3271 | } | |||
3272 | char_offset++; | |||
3273 | } | |||
3274 | } | |||
3275 | return result; | |||
3276 | } | |||
3277 | ||||
3278 | static int | |||
3279 | compare_by_extension_segments (BaulFile *file_1, BaulFile *file_2) | |||
3280 | { | |||
3281 | char *name_1, *name_2; | |||
3282 | char *segment_1, *segment_2; | |||
3283 | int compare; | |||
3284 | int rem_chars_1, rem_chars_2; | |||
3285 | gboolean done_1, done_2; | |||
3286 | gboolean is_directory_1, is_directory_2; | |||
3287 | int segment_index; | |||
3288 | ||||
3289 | ||||
3290 | /* Directories do not have an extension */ | |||
3291 | is_directory_1 = baul_file_is_directory (file_1); | |||
3292 | is_directory_2 = baul_file_is_directory (file_2); | |||
3293 | ||||
3294 | if (is_directory_1 && is_directory_2) { | |||
3295 | return 0; | |||
3296 | } else if (is_directory_1) { | |||
3297 | return -1; | |||
3298 | } else if (is_directory_2) { | |||
3299 | return 1; | |||
3300 | } | |||
3301 | ||||
3302 | name_1 = baul_file_get_display_name (file_1); | |||
3303 | name_2 = baul_file_get_display_name (file_2); | |||
3304 | rem_chars_1 = strlen (name_1); | |||
3305 | rem_chars_2 = strlen (name_2); | |||
3306 | ||||
3307 | /* Point to one after the zero character */ | |||
3308 | segment_1 = name_1 + rem_chars_1 + 1; | |||
3309 | segment_2 = name_2 + rem_chars_2 + 1; | |||
3310 | ||||
3311 | segment_index = 0; | |||
3312 | do { | |||
3313 | segment_1 = prev_extension_segment (segment_1 - 1, &rem_chars_1); | |||
3314 | segment_2 = prev_extension_segment (segment_2 - 1, &rem_chars_2); | |||
3315 | ||||
3316 | done_1 = rem_chars_1 <= 0 || !is_valid_extension_segment (segment_1, segment_index); | |||
3317 | done_2 = rem_chars_2 <= 0 || !is_valid_extension_segment (segment_2, segment_index); | |||
3318 | if (done_1 && !done_2) { | |||
3319 | compare = -1; | |||
3320 | break; | |||
3321 | } | |||
3322 | else if (!done_1 && done_2) { | |||
3323 | compare = 1; | |||
3324 | break; | |||
3325 | } | |||
3326 | else if (done_1 && done_2) { | |||
3327 | compare = 0; | |||
3328 | break; | |||
3329 | } | |||
3330 | ||||
3331 | segment_index++; | |||
3332 | if (segment_index > SORT_BY_EXTENSION_MAX_SEGMENTS3 - 1) { | |||
3333 | break; | |||
3334 | } | |||
3335 | compare = strcmp (segment_1, segment_2); | |||
3336 | } while (compare == 0); | |||
3337 | ||||
3338 | g_free (name_1); | |||
3339 | g_free (name_2); | |||
3340 | ||||
3341 | return compare; | |||
3342 | } | |||
3343 | ||||
3344 | static gchar * | |||
3345 | baul_file_get_extension_as_string (BaulFile *file) | |||
3346 | { | |||
3347 | int rem_chars; | |||
3348 | char *segment; | |||
3349 | ||||
3350 | if (!baul_file_is_directory (file)) { | |||
3351 | char *name; | |||
3352 | ||||
3353 | name = baul_file_get_display_name (file); | |||
3354 | rem_chars = strlen (name); | |||
3355 | segment = prev_extension_segment (name + rem_chars, &rem_chars); | |||
3356 | ||||
3357 | if (rem_chars > 0 && is_valid_extension_segment (segment, 0)) { | |||
3358 | int segment_index; | |||
3359 | char *right_segment; | |||
3360 | char *result; | |||
3361 | ||||
3362 | segment_index = 1; | |||
3363 | do { | |||
3364 | right_segment = segment; | |||
3365 | segment = prev_extension_segment (segment - 1, &rem_chars); | |||
3366 | if (rem_chars > 0 && is_valid_extension_segment (segment, segment_index)) { | |||
3367 | /* remove zero-termination of segment */ | |||
3368 | *(right_segment - 1) = '.'; | |||
3369 | } | |||
3370 | else { | |||
3371 | break; | |||
3372 | } | |||
3373 | ||||
3374 | segment_index++; | |||
3375 | } while (segment_index < SORT_BY_EXTENSION_MAX_SEGMENTS3 + 1); | |||
3376 | result = g_strdup (right_segment); | |||
3377 | g_free (name); | |||
3378 | return result; | |||
3379 | } | |||
3380 | g_free (name); | |||
3381 | } | |||
3382 | return g_strdup (""); | |||
3383 | } | |||
3384 | ||||
3385 | static int | |||
3386 | baul_file_compare_for_sort_internal (BaulFile *file_1, | |||
3387 | BaulFile *file_2, | |||
3388 | gboolean directories_first, | |||
3389 | gboolean reversed) | |||
3390 | { | |||
3391 | gboolean is_directory_1, is_directory_2; | |||
3392 | ||||
3393 | if (directories_first) { | |||
3394 | is_directory_1 = baul_file_is_directory (file_1); | |||
3395 | is_directory_2 = baul_file_is_directory (file_2); | |||
3396 | ||||
3397 | if (is_directory_1 && !is_directory_2) { | |||
3398 | return -1; | |||
3399 | } | |||
3400 | ||||
3401 | if (is_directory_2 && !is_directory_1) { | |||
3402 | return +1; | |||
3403 | } | |||
3404 | } | |||
3405 | ||||
3406 | if (file_1->details->sort_order < file_2->details->sort_order) { | |||
3407 | return reversed ? 1 : -1; | |||
3408 | } else if (file_1->details->sort_order > file_2->details->sort_order) { | |||
3409 | return reversed ? -1 : 1; | |||
3410 | } | |||
3411 | ||||
3412 | return 0; | |||
3413 | } | |||
3414 | ||||
3415 | /** | |||
3416 | * baul_file_compare_for_sort: | |||
3417 | * @file_1: A file object | |||
3418 | * @file_2: Another file object | |||
3419 | * @sort_type: Sort criterion | |||
3420 | * @directories_first: Put all directories before any non-directories | |||
3421 | * @reversed: Reverse the order of the items, except that | |||
3422 | * the directories_first flag is still respected. | |||
3423 | * | |||
3424 | * Return value: int < 0 if @file_1 should come before file_2 in a | |||
3425 | * sorted list; int > 0 if @file_2 should come before file_1 in a | |||
3426 | * sorted list; 0 if @file_1 and @file_2 are equal for this sort criterion. Note | |||
3427 | * that each named sort type may actually break ties several ways, with the name | |||
3428 | * of the sort criterion being the primary but not only differentiator. | |||
3429 | **/ | |||
3430 | int | |||
3431 | baul_file_compare_for_sort (BaulFile *file_1, | |||
3432 | BaulFile *file_2, | |||
3433 | BaulFileSortType sort_type, | |||
3434 | gboolean directories_first, | |||
3435 | gboolean reversed) | |||
3436 | { | |||
3437 | int result; | |||
3438 | ||||
3439 | if (file_1 == file_2) { | |||
3440 | return 0; | |||
3441 | } | |||
3442 | ||||
3443 | result = baul_file_compare_for_sort_internal (file_1, file_2, directories_first, reversed); | |||
3444 | ||||
3445 | if (result == 0) { | |||
3446 | switch (sort_type) { | |||
3447 | case BAUL_FILE_SORT_BY_DISPLAY_NAME: | |||
3448 | result = compare_by_display_name (file_1, file_2); | |||
3449 | if (result == 0) { | |||
3450 | result = compare_by_directory_name (file_1, file_2); | |||
3451 | } | |||
3452 | break; | |||
3453 | case BAUL_FILE_SORT_BY_DIRECTORY: | |||
3454 | result = compare_by_full_path (file_1, file_2); | |||
3455 | break; | |||
3456 | case BAUL_FILE_SORT_BY_SIZE: | |||
3457 | /* Compare directory sizes ourselves, then if necessary | |||
3458 | * use CafeVFS to compare file sizes. | |||
3459 | */ | |||
3460 | result = compare_by_size (file_1, file_2, FALSE(0)); | |||
3461 | if (result == 0) { | |||
3462 | result = compare_by_full_path (file_1, file_2); | |||
3463 | } | |||
3464 | break; | |||
3465 | case BAUL_FILE_SORT_BY_SIZE_ON_DISK: | |||
3466 | /* Compare directory sizes ourselves, then if necessary | |||
3467 | * use CafeVFS to compare file sizes. | |||
3468 | */ | |||
3469 | result = compare_by_size (file_1, file_2, TRUE(!(0))); | |||
3470 | if (result == 0) { | |||
3471 | result = compare_by_full_path (file_1, file_2); | |||
3472 | } | |||
3473 | break; | |||
3474 | case BAUL_FILE_SORT_BY_TYPE: | |||
3475 | /* CafeVFS doesn't know about our special text for certain | |||
3476 | * mime types, so we handle the mime-type sorting ourselves. | |||
3477 | */ | |||
3478 | result = compare_by_type (file_1, file_2); | |||
3479 | if (result == 0) { | |||
3480 | result = compare_by_full_path (file_1, file_2); | |||
3481 | } | |||
3482 | break; | |||
3483 | case BAUL_FILE_SORT_BY_MTIME: | |||
3484 | result = compare_by_time (file_1, file_2, BAUL_DATE_TYPE_MODIFIED); | |||
3485 | if (result == 0) { | |||
3486 | result = compare_by_full_path (file_1, file_2); | |||
3487 | } | |||
3488 | break; | |||
3489 | case BAUL_FILE_SORT_BY_ATIME: | |||
3490 | result = compare_by_time (file_1, file_2, BAUL_DATE_TYPE_ACCESSED); | |||
3491 | if (result == 0) { | |||
3492 | result = compare_by_full_path (file_1, file_2); | |||
3493 | } | |||
3494 | break; | |||
3495 | case BAUL_FILE_SORT_BY_TRASHED_TIME: | |||
3496 | result = compare_by_time (file_1, file_2, BAUL_DATE_TYPE_TRASHED); | |||
3497 | if (result == 0) { | |||
3498 | result = compare_by_full_path (file_1, file_2); | |||
3499 | } | |||
3500 | break; | |||
3501 | case BAUL_FILE_SORT_BY_EMBLEMS: | |||
3502 | /* CafeVFS doesn't know squat about our emblems, so | |||
3503 | * we handle comparing them here, before falling back | |||
3504 | * to tie-breakers. | |||
3505 | */ | |||
3506 | result = compare_by_emblems (file_1, file_2); | |||
3507 | if (result == 0) { | |||
3508 | result = compare_by_full_path (file_1, file_2); | |||
3509 | } | |||
3510 | break; | |||
3511 | case BAUL_FILE_SORT_BY_EXTENSION: | |||
3512 | result = compare_by_extension_segments (file_1, file_2); | |||
3513 | if (result == 0) { | |||
3514 | result = compare_by_full_path (file_1, file_2); | |||
3515 | } | |||
3516 | break; | |||
3517 | default: | |||
3518 | g_return_val_if_reached (0)do { g_log (((gchar*) 0), G_LOG_LEVEL_CRITICAL, "file %s: line %d (%s): should not be reached" , "baul-file.c", 3518, ((const char*) (__func__))); return (0 ); } while (0); | |||
3519 | } | |||
3520 | ||||
3521 | if (reversed) { | |||
3522 | result = -result; | |||
3523 | } | |||
3524 | } | |||
3525 | ||||
3526 | return result; | |||
3527 | } | |||
3528 | ||||
3529 | int | |||
3530 | baul_file_compare_for_sort_by_attribute_q (BaulFile *file_1, | |||
3531 | BaulFile *file_2, | |||
3532 | GQuark attribute, | |||
3533 | gboolean directories_first, | |||
3534 | gboolean reversed) | |||
3535 | { | |||
3536 | int result; | |||
3537 | ||||
3538 | if (file_1 == file_2) { | |||
3539 | return 0; | |||
3540 | } | |||
3541 | ||||
3542 | /* Convert certain attributes into BaulFileSortTypes and use | |||
3543 | * baul_file_compare_for_sort() | |||
3544 | */ | |||
3545 | if (attribute == 0 || attribute == attribute_name_q) { | |||
3546 | return baul_file_compare_for_sort (file_1, file_2, | |||
3547 | BAUL_FILE_SORT_BY_DISPLAY_NAME, | |||
3548 | directories_first, | |||
3549 | reversed); | |||
3550 | } else if (attribute == attribute_size_q) { | |||
3551 | return baul_file_compare_for_sort (file_1, file_2, | |||
3552 | BAUL_FILE_SORT_BY_SIZE, | |||
3553 | directories_first, | |||
3554 | reversed); | |||
3555 | } else if (attribute == attribute_size_on_disk_q) { | |||
3556 | return baul_file_compare_for_sort (file_1, file_2, | |||
3557 | BAUL_FILE_SORT_BY_SIZE_ON_DISK, | |||
3558 | directories_first, | |||
3559 | reversed); | |||
3560 | } else if (attribute == attribute_type_q) { | |||
3561 | return baul_file_compare_for_sort (file_1, file_2, | |||
3562 | BAUL_FILE_SORT_BY_TYPE, | |||
3563 | directories_first, | |||
3564 | reversed); | |||
3565 | } else if (attribute == attribute_modification_date_q || attribute == attribute_date_modified_q) { | |||
3566 | return baul_file_compare_for_sort (file_1, file_2, | |||
3567 | BAUL_FILE_SORT_BY_MTIME, | |||
3568 | directories_first, | |||
3569 | reversed); | |||
3570 | } else if (attribute == attribute_accessed_date_q || attribute == attribute_date_accessed_q) { | |||
3571 | return baul_file_compare_for_sort (file_1, file_2, | |||
3572 | BAUL_FILE_SORT_BY_ATIME, | |||
3573 | directories_first, | |||
3574 | reversed); | |||
3575 | } else if (attribute == attribute_trashed_on_q) { | |||
3576 | return baul_file_compare_for_sort (file_1, file_2, | |||
3577 | BAUL_FILE_SORT_BY_TRASHED_TIME, | |||
3578 | directories_first, | |||
3579 | reversed); | |||
3580 | } else if (attribute == attribute_emblems_q) { | |||
3581 | return baul_file_compare_for_sort (file_1, file_2, | |||
3582 | BAUL_FILE_SORT_BY_EMBLEMS, | |||
3583 | directories_first, | |||
3584 | reversed); | |||
3585 | } else if (attribute == attribute_extension_q) { | |||
3586 | return baul_file_compare_for_sort (file_1, file_2, | |||
3587 | BAUL_FILE_SORT_BY_EXTENSION, | |||
3588 | directories_first, | |||
3589 | reversed); | |||
3590 | } | |||
3591 | ||||
3592 | /* it is a normal attribute, compare by strings */ | |||
3593 | ||||
3594 | result = baul_file_compare_for_sort_internal (file_1, file_2, directories_first, reversed); | |||
3595 | ||||
3596 | if (result == 0) { | |||
3597 | char *value_1; | |||
3598 | char *value_2; | |||
3599 | ||||
3600 | value_1 = baul_file_get_string_attribute_q (file_1, | |||
3601 | attribute); | |||
3602 | value_2 = baul_file_get_string_attribute_q (file_2, | |||
3603 | attribute); | |||
3604 | ||||
3605 | if (value_1 != NULL((void*)0) && value_2 != NULL((void*)0)) { | |||
3606 | result = strcmp (value_1, value_2); | |||
3607 | } | |||
3608 | ||||
3609 | g_free (value_1); | |||
3610 | g_free (value_2); | |||
3611 | ||||
3612 | if (reversed) { | |||
3613 | result = -result; | |||
3614 | } | |||
3615 | } | |||
3616 | ||||
3617 | return result; | |||
3618 | } | |||
3619 | ||||
3620 | int | |||
3621 | baul_file_compare_for_sort_by_attribute (BaulFile *file_1, | |||
3622 | BaulFile *file_2, | |||
3623 | const char *attribute, | |||
3624 | gboolean directories_first, | |||
3625 | gboolean reversed) | |||
3626 | { | |||
3627 | return baul_file_compare_for_sort_by_attribute_q (file_1, file_2, | |||
3628 | g_quark_from_string (attribute), | |||
3629 | directories_first, | |||
3630 | reversed); | |||
3631 | } | |||
3632 | ||||
3633 | ||||
3634 | /** | |||
3635 | * baul_file_compare_name: | |||
3636 | * @file: A file object | |||
3637 | * @pattern: A string we are comparing it with | |||
3638 | * | |||
3639 | * Return value: result of a comparison of the file name and the given pattern, | |||
3640 | * using the same sorting order as sort by name. | |||
3641 | **/ | |||
3642 | int | |||
3643 | baul_file_compare_display_name (BaulFile *file, | |||
3644 | const char *pattern) | |||
3645 | { | |||
3646 | const char *name; | |||
3647 | int result; | |||
3648 | ||||
3649 | g_return_val_if_fail (pattern != NULL, -1)do { if ((pattern != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "pattern != NULL" ); return (-1); } } while (0); | |||
3650 | ||||
3651 | name = baul_file_peek_display_name (file); | |||
3652 | result = g_utf8_collate (name, pattern); | |||
3653 | return result; | |||
3654 | } | |||
3655 | ||||
3656 | ||||
3657 | gboolean | |||
3658 | baul_file_is_hidden_file (BaulFile *file) | |||
3659 | { | |||
3660 | return file->details->is_hidden; | |||
3661 | } | |||
3662 | ||||
3663 | gboolean | |||
3664 | baul_file_is_backup_file (BaulFile *file) | |||
3665 | { | |||
3666 | return file->details->is_backup; | |||
3667 | } | |||
3668 | ||||
3669 | /** | |||
3670 | * baul_file_should_show: | |||
3671 | * @file: the file to check. | |||
3672 | * @show_hidden: whether we want to show hidden files or not. | |||
3673 | * @show_backup: whether we want to show backup files or not. | |||
3674 | * | |||
3675 | * Determines if a #BaulFile should be shown. Note that when browsing | |||
3676 | * a trash directory, this function will always return %TRUE. | |||
3677 | * | |||
3678 | * Returns: %TRUE if the file should be shown, %FALSE if it shouldn't. | |||
3679 | */ | |||
3680 | gboolean | |||
3681 | baul_file_should_show (BaulFile *file, | |||
3682 | gboolean show_hidden, | |||
3683 | gboolean show_foreign, | |||
3684 | gboolean show_backup) | |||
3685 | { | |||
3686 | /* Never hide any files in trash. */ | |||
3687 | if (baul_file_is_in_trash (file)) { | |||
3688 | return TRUE(!(0)); | |||
3689 | } else { | |||
3690 | return (show_hidden || !baul_file_is_hidden_file (file)) && | |||
3691 | (show_backup || !baul_file_is_backup_file (file)) && | |||
3692 | (show_foreign || !(baul_file_is_in_desktop (file) && baul_file_is_foreign_link (file))); | |||
3693 | } | |||
3694 | } | |||
3695 | ||||
3696 | gboolean | |||
3697 | baul_file_is_home (BaulFile *file) | |||
3698 | { | |||
3699 | GFile *dir; | |||
3700 | ||||
3701 | dir = file->details->directory->details->location; | |||
3702 | if (dir == NULL((void*)0)) { | |||
3703 | return FALSE(0); | |||
3704 | } | |||
3705 | ||||
3706 | return baul_is_home_directory_file (dir, file->details->name); | |||
3707 | } | |||
3708 | ||||
3709 | gboolean | |||
3710 | baul_file_is_in_desktop (BaulFile *file) | |||
3711 | { | |||
3712 | if (file->details->directory->details->location) { | |||
3713 | return baul_is_desktop_directory (file->details->directory->details->location); | |||
3714 | } | |||
3715 | return FALSE(0); | |||
3716 | ||||
3717 | } | |||
3718 | ||||
3719 | static gboolean | |||
3720 | filter_hidden_partition_callback (gpointer data, | |||
3721 | gpointer callback_data) | |||
3722 | { | |||
3723 | BaulFile *file; | |||
3724 | FilterOptions options; | |||
3725 | ||||
3726 | file = BAUL_FILE (data)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((data)), (baul_file_get_type()))))); | |||
3727 | options = GPOINTER_TO_INT (callback_data)((gint) (glong) (callback_data)); | |||
3728 | ||||
3729 | return baul_file_should_show (file, | |||
3730 | options & SHOW_HIDDEN, | |||
3731 | TRUE(!(0)), | |||
3732 | options & SHOW_BACKUP); | |||
3733 | } | |||
3734 | ||||
3735 | GList * | |||
3736 | baul_file_list_filter_hidden (GList *files, | |||
3737 | gboolean show_hidden) | |||
3738 | { | |||
3739 | GList *filtered_files; | |||
3740 | GList *removed_files; | |||
3741 | ||||
3742 | /* FIXME bugzilla.gnome.org 40653: | |||
3743 | * Eventually this should become a generic filtering thingy. | |||
3744 | */ | |||
3745 | ||||
3746 | filtered_files = baul_file_list_copy (files); | |||
3747 | filtered_files = eel_g_list_partition (filtered_files, | |||
3748 | filter_hidden_partition_callback, | |||
3749 | GINT_TO_POINTER ((show_hidden ? SHOW_HIDDEN : 0))((gpointer) (glong) ((show_hidden ? SHOW_HIDDEN : 0))), | |||
3750 | &removed_files); | |||
3751 | baul_file_list_free (removed_files); | |||
3752 | ||||
3753 | return filtered_files; | |||
3754 | } | |||
3755 | ||||
3756 | char * | |||
3757 | baul_file_get_metadata (BaulFile *file, | |||
3758 | const char *key, | |||
3759 | const char *default_metadata) | |||
3760 | { | |||
3761 | guint id; | |||
3762 | char *value; | |||
3763 | ||||
3764 | g_return_val_if_fail (key != NULL, g_strdup (default_metadata))do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return (g_strdup (default_metadata)); } } while (0); | |||
3765 | g_return_val_if_fail (key[0] != '\0', g_strdup (default_metadata))do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return (g_strdup (default_metadata)); } } while (0); | |||
3766 | ||||
3767 | if (file == NULL((void*)0) || | |||
3768 | file->details->metadata == NULL((void*)0)) { | |||
3769 | return g_strdup (default_metadata); | |||
3770 | } | |||
3771 | ||||
3772 | g_return_val_if_fail (BAUL_IS_FILE (file), g_strdup (default_metadata))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (g_strdup (default_metadata )); } } while (0); | |||
3773 | ||||
3774 | id = baul_metadata_get_id (key); | |||
3775 | value = g_hash_table_lookup (file->details->metadata, GUINT_TO_POINTER (id)((gpointer) (gulong) (id))); | |||
3776 | ||||
3777 | if (value) { | |||
3778 | return g_strdup (value); | |||
3779 | } | |||
3780 | return g_strdup (default_metadata); | |||
3781 | } | |||
3782 | ||||
3783 | GList * | |||
3784 | baul_file_get_metadata_list (BaulFile *file, | |||
3785 | const char *key) | |||
3786 | { | |||
3787 | guint id; | |||
3788 | char **value; | |||
3789 | ||||
3790 | g_return_val_if_fail (key != NULL, NULL)do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return (((void*)0)); } } while (0); | |||
3791 | g_return_val_if_fail (key[0] != '\0', NULL)do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return (((void*)0)); } } while (0); | |||
3792 | ||||
3793 | if (file == NULL((void*)0) || | |||
3794 | file->details->metadata == NULL((void*)0)) { | |||
3795 | return NULL((void*)0); | |||
3796 | } | |||
3797 | ||||
3798 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
3799 | ||||
3800 | id = baul_metadata_get_id (key); | |||
3801 | id |= METADATA_ID_IS_LIST_MASK(1U<<31); | |||
3802 | ||||
3803 | value = g_hash_table_lookup (file->details->metadata, GUINT_TO_POINTER (id)((gpointer) (gulong) (id))); | |||
3804 | ||||
3805 | if (value) { | |||
3806 | GList *res; | |||
3807 | int i; | |||
3808 | ||||
3809 | res = NULL((void*)0); | |||
3810 | for (i = 0; value[i] != NULL((void*)0); i++) { | |||
3811 | res = g_list_prepend (res, g_strdup (value[i])); | |||
3812 | } | |||
3813 | return g_list_reverse (res); | |||
3814 | } | |||
3815 | ||||
3816 | return NULL((void*)0); | |||
3817 | } | |||
3818 | ||||
3819 | void | |||
3820 | baul_file_set_metadata (BaulFile *file, | |||
3821 | const char *key, | |||
3822 | const char *default_metadata, | |||
3823 | const char *metadata) | |||
3824 | { | |||
3825 | const char *val; | |||
3826 | ||||
3827 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
3828 | g_return_if_fail (key != NULL)do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return ; } } while (0); | |||
3829 | g_return_if_fail (key[0] != '\0')do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return; } } while (0); | |||
3830 | ||||
3831 | val = metadata; | |||
3832 | if (val == NULL((void*)0)) { | |||
3833 | val = default_metadata; | |||
3834 | } | |||
3835 | ||||
3836 | EEL_CALL_METHODdo { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata ) (file, key, val); } } while (0) | |||
3837 | (BAUL_FILE_CLASS, file,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata ) (file, key, val); } } while (0) | |||
3838 | set_metadata, (file, key, val))do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata ) (file, key, val); } } while (0); | |||
3839 | } | |||
3840 | ||||
3841 | void | |||
3842 | baul_file_set_metadata_list (BaulFile *file, | |||
3843 | const char *key, | |||
3844 | GList *list) | |||
3845 | { | |||
3846 | char **val; | |||
3847 | int len, i; | |||
3848 | GList *l; | |||
3849 | ||||
3850 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
3851 | g_return_if_fail (key != NULL)do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return ; } } while (0); | |||
3852 | g_return_if_fail (key[0] != '\0')do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return; } } while (0); | |||
3853 | ||||
3854 | len = g_list_length (list); | |||
3855 | val = g_new (char *, len + 1)((char * *) g_malloc_n ((len + 1), sizeof (char *))); | |||
3856 | for (l = list, i = 0; l != NULL((void*)0); l = l->next, i++) { | |||
3857 | val[i] = l->data; | |||
3858 | } | |||
3859 | val[i] = NULL((void*)0); | |||
3860 | ||||
3861 | EEL_CALL_METHODdo { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata_as_list != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata_as_list ) (file, key, val); } } while (0) | |||
3862 | (BAUL_FILE_CLASS, file,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata_as_list != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata_as_list ) (file, key, val); } } while (0) | |||
3863 | set_metadata_as_list, (file, key, val))do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata_as_list != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->set_metadata_as_list ) (file, key, val); } } while (0); | |||
3864 | ||||
3865 | g_free (val); | |||
3866 | } | |||
3867 | ||||
3868 | ||||
3869 | gboolean | |||
3870 | baul_file_get_boolean_metadata (BaulFile *file, | |||
3871 | const char *key, | |||
3872 | gboolean default_metadata) | |||
3873 | { | |||
3874 | char *result_as_string; | |||
3875 | gboolean result; | |||
3876 | ||||
3877 | g_return_val_if_fail (key != NULL, default_metadata)do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return (default_metadata); } } while (0); | |||
3878 | g_return_val_if_fail (key[0] != '\0', default_metadata)do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return (default_metadata); } } while (0); | |||
3879 | ||||
3880 | if (file == NULL((void*)0)) { | |||
3881 | return default_metadata; | |||
3882 | } | |||
3883 | ||||
3884 | g_return_val_if_fail (BAUL_IS_FILE (file), default_metadata)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (default_metadata ); } } while (0); | |||
3885 | ||||
3886 | result_as_string = baul_file_get_metadata | |||
3887 | (file, key, default_metadata ? "true" : "false"); | |||
3888 | g_assert (result_as_string != NULL)do { if (result_as_string != ((void*)0)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 3888, ((const char*) (__func__ )), "result_as_string != NULL"); } while (0); | |||
3889 | ||||
3890 | if (g_ascii_strcasecmp (result_as_string, "true") == 0) { | |||
3891 | result = TRUE(!(0)); | |||
3892 | } else if (g_ascii_strcasecmp (result_as_string, "false") == 0) { | |||
3893 | result = FALSE(0); | |||
3894 | } else { | |||
3895 | g_error ("boolean metadata with value other than true or false"); | |||
3896 | result = default_metadata; | |||
3897 | } | |||
3898 | ||||
3899 | g_free (result_as_string); | |||
3900 | return result; | |||
3901 | } | |||
3902 | ||||
3903 | int | |||
3904 | baul_file_get_integer_metadata (BaulFile *file, | |||
3905 | const char *key, | |||
3906 | int default_metadata) | |||
3907 | { | |||
3908 | char *result_as_string; | |||
3909 | char default_as_string[32]; | |||
3910 | int result; | |||
3911 | char c; | |||
3912 | ||||
3913 | g_return_val_if_fail (key != NULL, default_metadata)do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return (default_metadata); } } while (0); | |||
3914 | g_return_val_if_fail (key[0] != '\0', default_metadata)do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return (default_metadata); } } while (0); | |||
3915 | ||||
3916 | if (file == NULL((void*)0)) { | |||
3917 | return default_metadata; | |||
3918 | } | |||
3919 | g_return_val_if_fail (BAUL_IS_FILE (file), default_metadata)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (default_metadata ); } } while (0); | |||
3920 | ||||
3921 | g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata); | |||
3922 | result_as_string = baul_file_get_metadata | |||
3923 | (file, key, default_as_string); | |||
3924 | ||||
3925 | /* Normally we can't get a a NULL, but we check for it here to | |||
3926 | * handle the oddball case of a non-existent directory. | |||
3927 | */ | |||
3928 | if (result_as_string == NULL((void*)0)) { | |||
3929 | result = default_metadata; | |||
3930 | } else { | |||
3931 | if (sscanf (result_as_string, " %d %c", &result, &c) != 1) { | |||
3932 | result = default_metadata; | |||
3933 | } | |||
3934 | g_free (result_as_string); | |||
3935 | } | |||
3936 | ||||
3937 | return result; | |||
3938 | } | |||
3939 | ||||
3940 | static gboolean | |||
3941 | get_time_from_time_string (const char *time_string, | |||
3942 | time_t *time) | |||
3943 | { | |||
3944 | long scanned_time; | |||
3945 | char c; | |||
3946 | ||||
3947 | g_assert (time != NULL)do { if (time != ((void*)0)) ; else g_assertion_message_expr ( ((gchar*) 0), "baul-file.c", 3947, ((const char*) (__func__)) , "time != NULL"); } while (0); | |||
3948 | ||||
3949 | /* Only accept string if it has one integer with nothing | |||
3950 | * afterwards. | |||
3951 | */ | |||
3952 | if (time_string == NULL((void*)0) || | |||
3953 | sscanf (time_string, "%ld%c", &scanned_time, &c) != 1) { | |||
3954 | return FALSE(0); | |||
3955 | } | |||
3956 | *time = (time_t) scanned_time; | |||
3957 | return TRUE(!(0)); | |||
3958 | } | |||
3959 | ||||
3960 | time_t | |||
3961 | baul_file_get_time_metadata (BaulFile *file, | |||
3962 | const char *key) | |||
3963 | { | |||
3964 | time_t time; | |||
3965 | char *time_string; | |||
3966 | ||||
3967 | time_string = baul_file_get_metadata (file, key, NULL((void*)0)); | |||
3968 | if (!get_time_from_time_string (time_string, &time)) { | |||
3969 | time = UNDEFINED_TIME((time_t) (-1)); | |||
3970 | } | |||
3971 | g_free (time_string); | |||
3972 | ||||
3973 | return time; | |||
3974 | } | |||
3975 | ||||
3976 | void | |||
3977 | baul_file_set_time_metadata (BaulFile *file, | |||
3978 | const char *key, | |||
3979 | time_t time) | |||
3980 | { | |||
3981 | char time_str[21]; | |||
3982 | char *metadata; | |||
3983 | ||||
3984 | if (time != UNDEFINED_TIME((time_t) (-1))) { | |||
3985 | /* 2^64 turns out to be 20 characters */ | |||
3986 | g_snprintf (time_str, 20, "%ld", (long int)time); | |||
3987 | time_str[20] = '\0'; | |||
3988 | metadata = time_str; | |||
3989 | } else { | |||
3990 | metadata = NULL((void*)0); | |||
3991 | } | |||
3992 | ||||
3993 | baul_file_set_metadata (file, key, NULL((void*)0), metadata); | |||
3994 | } | |||
3995 | ||||
3996 | ||||
3997 | void | |||
3998 | baul_file_set_boolean_metadata (BaulFile *file, | |||
3999 | const char *key, | |||
4000 | gboolean default_metadata, | |||
4001 | gboolean metadata) | |||
4002 | { | |||
4003 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
4004 | g_return_if_fail (key != NULL)do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return ; } } while (0); | |||
4005 | g_return_if_fail (key[0] != '\0')do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return; } } while (0); | |||
4006 | ||||
4007 | baul_file_set_metadata (file, key, | |||
4008 | default_metadata ? "true" : "false", | |||
4009 | metadata ? "true" : "false"); | |||
4010 | } | |||
4011 | ||||
4012 | void | |||
4013 | baul_file_set_integer_metadata (BaulFile *file, | |||
4014 | const char *key, | |||
4015 | int default_metadata, | |||
4016 | int metadata) | |||
4017 | { | |||
4018 | char value_as_string[32]; | |||
4019 | char default_as_string[32]; | |||
4020 | ||||
4021 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
4022 | g_return_if_fail (key != NULL)do { if ((key != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key != NULL"); return ; } } while (0); | |||
4023 | g_return_if_fail (key[0] != '\0')do { if ((key[0] != '\0')) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "key[0] != '\\0'" ); return; } } while (0); | |||
4024 | ||||
4025 | g_snprintf (value_as_string, sizeof (value_as_string), "%d", metadata); | |||
4026 | g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata); | |||
4027 | ||||
4028 | baul_file_set_metadata (file, key, | |||
4029 | default_as_string, value_as_string); | |||
4030 | } | |||
4031 | ||||
4032 | static const char * | |||
4033 | baul_file_peek_display_name_collation_key (BaulFile *file) | |||
4034 | { | |||
4035 | const char *res; | |||
4036 | ||||
4037 | res = file->details->display_name_collation_key; | |||
4038 | if (res == NULL((void*)0)) | |||
4039 | res = ""; | |||
4040 | ||||
4041 | return res; | |||
4042 | } | |||
4043 | ||||
4044 | static const char * | |||
4045 | baul_file_peek_display_name (BaulFile *file) | |||
4046 | { | |||
4047 | /* | |||
4048 | stefano-k: Imported 15_nautilus_file_peek_crash.patch from debian nautilus | |||
4049 | Date: Thu, 27 Jan 2011 10:22:10 +0000 | |||
4050 | Subject: Prevent a crash in nautilus_file_peek_display_name() on invalid NautilusFile | |||
4051 | This is more a workaround only, expect assert failures at other | |||
4052 | places when something bad happens. There's a race condition somewhere, | |||
4053 | this patch only prevents immediate crash. | |||
4054 | Patch by Marcus Husar <marcus.husar@rose.uni-heidelberg.de> | |||
4055 | https://bugzilla.gnome.org/show_bug.cgi?id=602500 | |||
4056 | */ | |||
4057 | if (file == NULL((void*)0) || baul_file_is_gone (file)) | |||
4058 | return ""; | |||
4059 | ||||
4060 | /* Default to display name based on filename if its not set yet */ | |||
4061 | ||||
4062 | if (file->details->display_name == NULL((void*)0)) { | |||
4063 | const char *name; | |||
4064 | ||||
4065 | name = file->details->name; | |||
4066 | if (g_utf8_validate (name, -1, NULL((void*)0))) { | |||
4067 | baul_file_set_display_name (file, | |||
4068 | name, | |||
4069 | NULL((void*)0), | |||
4070 | FALSE(0)); | |||
4071 | } else { | |||
4072 | char *escaped_name; | |||
4073 | ||||
4074 | escaped_name = g_uri_escape_string (name, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH"!$&'()*+,;=" ":@" "/", TRUE(!(0))); | |||
4075 | baul_file_set_display_name (file, | |||
4076 | escaped_name, | |||
4077 | NULL((void*)0), | |||
4078 | FALSE(0)); | |||
4079 | g_free (escaped_name); | |||
4080 | } | |||
4081 | } | |||
4082 | ||||
4083 | return file->details->display_name; | |||
4084 | } | |||
4085 | ||||
4086 | char * | |||
4087 | baul_file_get_display_name (BaulFile *file) | |||
4088 | { | |||
4089 | return g_strdup (baul_file_peek_display_name (file)); | |||
4090 | } | |||
4091 | ||||
4092 | char * | |||
4093 | baul_file_get_edit_name (BaulFile *file) | |||
4094 | { | |||
4095 | const char *res; | |||
4096 | ||||
4097 | res = file->details->edit_name; | |||
4098 | if (res == NULL((void*)0)) | |||
4099 | res = ""; | |||
4100 | ||||
4101 | return g_strdup (res); | |||
4102 | } | |||
4103 | ||||
4104 | char * | |||
4105 | baul_file_get_name (BaulFile *file) | |||
4106 | { | |||
4107 | return g_strdup (file->details->name); | |||
4108 | } | |||
4109 | ||||
4110 | /** | |||
4111 | * baul_file_get_description: | |||
4112 | * @file: a #BaulFile. | |||
4113 | * | |||
4114 | * Gets the standard::description key from @file, if | |||
4115 | * it has been cached. | |||
4116 | * | |||
4117 | * Returns: a string containing the value of the standard::description | |||
4118 | * key, or %NULL. | |||
4119 | */ | |||
4120 | char * | |||
4121 | baul_file_get_description (BaulFile *file) | |||
4122 | { | |||
4123 | return g_strdup (file->details->description); | |||
4124 | } | |||
4125 | ||||
4126 | void | |||
4127 | baul_file_monitor_add (BaulFile *file, | |||
4128 | gconstpointer client, | |||
4129 | BaulFileAttributes attributes) | |||
4130 | { | |||
4131 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
4132 | g_return_if_fail (client != NULL)do { if ((client != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "client != NULL") ; return; } } while (0); | |||
4133 | ||||
4134 | EEL_CALL_METHODdo { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_add != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_add ) (file, client, attributes); } } while (0) | |||
4135 | (BAUL_FILE_CLASS, file,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_add != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_add ) (file, client, attributes); } } while (0) | |||
4136 | monitor_add, (file, client, attributes))do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_add != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_add ) (file, client, attributes); } } while (0); | |||
4137 | } | |||
4138 | ||||
4139 | void | |||
4140 | baul_file_monitor_remove (BaulFile *file, | |||
4141 | gconstpointer client) | |||
4142 | { | |||
4143 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
4144 | g_return_if_fail (client != NULL)do { if ((client != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "client != NULL") ; return; } } while (0); | |||
4145 | ||||
4146 | EEL_CALL_METHODdo { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_remove != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_remove ) (file, client); } } while (0) | |||
4147 | (BAUL_FILE_CLASS, file,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_remove != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_remove ) (file, client); } } while (0) | |||
4148 | monitor_remove, (file, client))do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_remove != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->monitor_remove ) (file, client); } } while (0); | |||
4149 | } | |||
4150 | ||||
4151 | gboolean | |||
4152 | baul_file_is_launcher (BaulFile *file) | |||
4153 | { | |||
4154 | return file->details->is_launcher; | |||
4155 | } | |||
4156 | ||||
4157 | gboolean | |||
4158 | baul_file_is_foreign_link (BaulFile *file) | |||
4159 | { | |||
4160 | return file->details->is_foreign_link; | |||
4161 | } | |||
4162 | ||||
4163 | gboolean | |||
4164 | baul_file_is_trusted_link (BaulFile *file) | |||
4165 | { | |||
4166 | return file->details->is_trusted_link; | |||
4167 | } | |||
4168 | ||||
4169 | gboolean | |||
4170 | baul_file_has_activation_uri (BaulFile *file) | |||
4171 | { | |||
4172 | return file->details->activation_uri != NULL((void*)0); | |||
4173 | } | |||
4174 | ||||
4175 | ||||
4176 | /* Return the uri associated with the passed-in file, which may not be | |||
4177 | * the actual uri if the file is an desktop file or a baul | |||
4178 | * xml link file. | |||
4179 | */ | |||
4180 | char * | |||
4181 | baul_file_get_activation_uri (BaulFile *file) | |||
4182 | { | |||
4183 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
4184 | ||||
4185 | if (file->details->activation_uri != NULL((void*)0)) { | |||
4186 | return g_strdup (file->details->activation_uri); | |||
4187 | } | |||
4188 | ||||
4189 | return baul_file_get_uri (file); | |||
4190 | } | |||
4191 | ||||
4192 | GFile * | |||
4193 | baul_file_get_activation_location (BaulFile *file) | |||
4194 | { | |||
4195 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
4196 | ||||
4197 | if (file->details->activation_uri != NULL((void*)0)) { | |||
4198 | return g_file_new_for_uri (file->details->activation_uri); | |||
4199 | } | |||
4200 | ||||
4201 | return baul_file_get_location (file); | |||
4202 | } | |||
4203 | ||||
4204 | ||||
4205 | char * | |||
4206 | baul_file_get_drop_target_uri (BaulFile *file) | |||
4207 | { | |||
4208 | char *uri, *target_uri; | |||
4209 | GFile *location; | |||
4210 | ||||
4211 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
4212 | ||||
4213 | if (BAUL_IS_DESKTOP_ICON_FILE (file)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (file)); GType __t = (baul_desktop_icon_file_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) { | |||
4214 | BaulDesktopLink *link; | |||
4215 | ||||
4216 | link = baul_desktop_icon_file_get_link (BAUL_DESKTOP_ICON_FILE (file)((((BaulDesktopIconFile*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file)), (baul_desktop_icon_file_get_type ())))))); | |||
4217 | ||||
4218 | if (link != NULL((void*)0)) { | |||
4219 | location = baul_desktop_link_get_activation_location (link); | |||
4220 | g_object_unref (link); | |||
4221 | if (location != NULL((void*)0)) { | |||
4222 | uri = g_file_get_uri (location); | |||
4223 | g_object_unref (location); | |||
4224 | return uri; | |||
4225 | } | |||
4226 | } | |||
4227 | } | |||
4228 | ||||
4229 | uri = baul_file_get_uri (file); | |||
4230 | ||||
4231 | /* Check for Baul link */ | |||
4232 | if (baul_file_is_baul_link (file)) { | |||
4233 | location = baul_file_get_location (file); | |||
4234 | /* FIXME bugzilla.gnome.org 43020: This does sync. I/O and works only locally. */ | |||
4235 | if (g_file_is_native (location)) { | |||
4236 | target_uri = baul_link_local_get_link_uri (uri); | |||
4237 | if (target_uri != NULL((void*)0)) { | |||
4238 | g_free (uri); | |||
4239 | uri = target_uri; | |||
4240 | } | |||
4241 | } | |||
4242 | g_object_unref (location); | |||
4243 | } | |||
4244 | ||||
4245 | return uri; | |||
4246 | } | |||
4247 | ||||
4248 | static gboolean | |||
4249 | is_uri_relative (const char *uri) | |||
4250 | { | |||
4251 | char *scheme; | |||
4252 | gboolean ret; | |||
4253 | ||||
4254 | scheme = g_uri_parse_scheme (uri); | |||
4255 | ret = (scheme == NULL((void*)0)); | |||
4256 | g_free (scheme); | |||
4257 | return ret; | |||
4258 | } | |||
4259 | ||||
4260 | static char * | |||
4261 | get_custom_icon_metadata_uri (BaulFile *file) | |||
4262 | { | |||
4263 | char *custom_icon_uri; | |||
4264 | char *uri; | |||
4265 | ||||
4266 | uri = baul_file_get_metadata (file, BAUL_METADATA_KEY_CUSTOM_ICON"custom-icon", NULL((void*)0)); | |||
4267 | if (uri != NULL((void*)0) && | |||
4268 | baul_file_is_directory (file) && | |||
4269 | is_uri_relative (uri)) { | |||
4270 | char *dir_uri; | |||
4271 | ||||
4272 | dir_uri = baul_file_get_uri (file); | |||
4273 | custom_icon_uri = g_build_filename (dir_uri, uri, NULL((void*)0)); | |||
4274 | g_free (dir_uri); | |||
4275 | g_free (uri); | |||
4276 | } else { | |||
4277 | custom_icon_uri = uri; | |||
4278 | } | |||
4279 | return custom_icon_uri; | |||
4280 | } | |||
4281 | ||||
4282 | static GIcon * | |||
4283 | get_custom_icon (BaulFile *file) | |||
4284 | { | |||
4285 | char *custom_icon_uri; | |||
4286 | GFile *icon_file; | |||
4287 | GIcon *icon; | |||
4288 | ||||
4289 | if (file == NULL((void*)0)) { | |||
4290 | return NULL((void*)0); | |||
4291 | } | |||
4292 | ||||
4293 | icon = NULL((void*)0); | |||
4294 | ||||
4295 | /* Metadata takes precedence */ | |||
4296 | custom_icon_uri = get_custom_icon_metadata_uri (file); | |||
4297 | ||||
4298 | if (custom_icon_uri) { | |||
4299 | icon_file = g_file_new_for_uri (custom_icon_uri); | |||
4300 | icon = g_file_icon_new (icon_file); | |||
4301 | g_object_unref (icon_file); | |||
4302 | g_free (custom_icon_uri); | |||
4303 | } | |||
4304 | ||||
4305 | if (icon == NULL((void*)0) && file->details->got_link_info && file->details->custom_icon != NULL((void*)0)) { | |||
4306 | if (g_path_is_absolute (file->details->custom_icon)) { | |||
4307 | icon_file = g_file_new_for_path (file->details->custom_icon); | |||
4308 | icon = g_file_icon_new (icon_file); | |||
4309 | g_object_unref (icon_file); | |||
4310 | } else { | |||
4311 | icon = g_themed_icon_new (file->details->custom_icon); | |||
4312 | } | |||
4313 | } | |||
4314 | ||||
4315 | return icon; | |||
4316 | } | |||
4317 | ||||
4318 | ||||
4319 | static guint64 cached_thumbnail_limit; | |||
4320 | int cached_thumbnail_size; | |||
4321 | static int show_image_thumbs; | |||
4322 | ||||
4323 | GFilesystemPreviewType | |||
4324 | baul_file_get_filesystem_use_preview (BaulFile *file) | |||
4325 | { | |||
4326 | GFilesystemPreviewType use_preview; | |||
4327 | BaulFile *parent; | |||
4328 | ||||
4329 | parent = baul_file_get_parent (file); | |||
4330 | if (parent != NULL((void*)0)) { | |||
4331 | use_preview = parent->details->filesystem_use_preview; | |||
4332 | g_object_unref (parent); | |||
4333 | } else { | |||
4334 | use_preview = 0; | |||
4335 | } | |||
4336 | ||||
4337 | return use_preview; | |||
4338 | } | |||
4339 | ||||
4340 | gboolean | |||
4341 | baul_file_should_show_thumbnail (BaulFile *file) | |||
4342 | { | |||
4343 | const char *mime_type; | |||
4344 | GFilesystemPreviewType use_preview; | |||
4345 | ||||
4346 | use_preview = baul_file_get_filesystem_use_preview (file); | |||
4347 | ||||
4348 | mime_type = file->details->mime_type; | |||
4349 | if (mime_type == NULL((void*)0)) { | |||
4350 | mime_type = "application/octet-stream"; | |||
4351 | } | |||
4352 | ||||
4353 | /* If the thumbnail has already been created, don't care about the size | |||
4354 | * of the original file. | |||
4355 | */ | |||
4356 | if (baul_thumbnail_is_mimetype_limited_by_size (mime_type) && | |||
4357 | file->details->thumbnail_path == NULL((void*)0) && | |||
4358 | baul_file_get_size (file) > cached_thumbnail_limit) { | |||
4359 | return FALSE(0); | |||
4360 | } | |||
4361 | ||||
4362 | if (show_image_thumbs == BAUL_SPEED_TRADEOFF_ALWAYS) { | |||
4363 | if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) { | |||
4364 | return FALSE(0); | |||
4365 | } else { | |||
4366 | return TRUE(!(0)); | |||
4367 | } | |||
4368 | } else if (show_image_thumbs == BAUL_SPEED_TRADEOFF_NEVER) { | |||
4369 | return FALSE(0); | |||
4370 | } else { | |||
4371 | if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) { | |||
4372 | /* file system says to never thumbnail anything */ | |||
4373 | return FALSE(0); | |||
4374 | } else if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL) { | |||
4375 | /* file system says we should treat file as if it's local */ | |||
4376 | return TRUE(!(0)); | |||
4377 | } else { | |||
4378 | /* only local files */ | |||
4379 | return baul_file_is_local (file); | |||
4380 | } | |||
4381 | } | |||
4382 | ||||
4383 | return FALSE(0); | |||
4384 | } | |||
4385 | ||||
4386 | static void | |||
4387 | prepend_icon_name (const char *name, | |||
4388 | GThemedIcon *icon) | |||
4389 | { | |||
4390 | g_themed_icon_prepend_name(icon, name); | |||
4391 | } | |||
4392 | ||||
4393 | GIcon * | |||
4394 | baul_file_get_gicon (BaulFile *file, | |||
4395 | BaulFileIconFlags flags) | |||
4396 | { | |||
4397 | const char * const * names; | |||
4398 | GIcon *icon, *mount_icon = NULL((void*)0), *emblemed_icon; | |||
4399 | gboolean is_folder = FALSE(0), is_preview = FALSE(0), is_inode_directory = FALSE(0); | |||
4400 | ||||
4401 | if (file == NULL((void*)0)) { | |||
4402 | return NULL((void*)0); | |||
4403 | } | |||
4404 | ||||
4405 | icon = get_custom_icon (file); | |||
4406 | if (icon != NULL((void*)0)) { | |||
4407 | return icon; | |||
4408 | } | |||
4409 | ||||
4410 | if (file->details->icon) { | |||
4411 | icon = NULL((void*)0); | |||
4412 | ||||
4413 | /* fetch the mount icon here, we'll use it later */ | |||
4414 | if (flags & BAUL_FILE_ICON_FLAGS_USE_MOUNT_ICON || | |||
4415 | flags & BAUL_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM) { | |||
4416 | GMount *mount; | |||
4417 | ||||
4418 | mount = baul_file_get_mount (file); | |||
4419 | ||||
4420 | if (mount != NULL((void*)0)) { | |||
4421 | mount_icon = g_mount_get_icon (mount); | |||
4422 | g_object_unref (mount); | |||
4423 | } | |||
4424 | } | |||
4425 | ||||
4426 | if (((flags & BAUL_FILE_ICON_FLAGS_EMBEDDING_TEXT) || | |||
4427 | (flags & BAUL_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT) || | |||
4428 | (flags & BAUL_FILE_ICON_FLAGS_FOR_OPEN_FOLDER) || | |||
4429 | (flags & BAUL_FILE_ICON_FLAGS_USE_MOUNT_ICON) || | |||
4430 | (flags & BAUL_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM) || | |||
4431 | ((flags & BAUL_FILE_ICON_FLAGS_IGNORE_VISITING) == 0 && | |||
4432 | baul_file_has_open_window (file))) && | |||
4433 | G_IS_THEMED_ICON (file->details->icon)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (file->details->icon)); GType __t = ((g_themed_icon_get_type ())); gboolean __r; if (!__inst) __r = (0); else if (__inst-> g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) { | |||
4434 | GPtrArray *prepend_array; | |||
4435 | int i; | |||
4436 | ||||
4437 | names = g_themed_icon_get_names (G_THEMED_ICON (file->details->icon)((((GThemedIcon*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((file->details->icon)), ((g_themed_icon_get_type () ))))))); | |||
4438 | prepend_array = g_ptr_array_new (); | |||
4439 | ||||
4440 | for (i = 0; names[i] != NULL((void*)0); i++) { | |||
4441 | const char *name; | |||
4442 | ||||
4443 | name = names[i]; | |||
4444 | ||||
4445 | if (strcmp (name, "folder") == 0) { | |||
4446 | is_folder = TRUE(!(0)); | |||
4447 | } | |||
4448 | if (strcmp (name, "inode-directory") == 0) { | |||
4449 | is_inode_directory = TRUE(!(0)); | |||
4450 | } | |||
4451 | if (strcmp (name, "text-x-generic") == 0 && | |||
4452 | (flags & BAUL_FILE_ICON_FLAGS_EMBEDDING_TEXT)) { | |||
4453 | is_preview = TRUE(!(0)); | |||
4454 | } | |||
4455 | } | |||
4456 | ||||
4457 | /* Here, we add icons in reverse order of precedence, | |||
4458 | * because they are later prepended */ | |||
4459 | if (is_preview) { | |||
4460 | g_ptr_array_add (prepend_array, "text-x-preview"); | |||
4461 | } | |||
4462 | ||||
4463 | /* "folder" should override "inode-directory", not the other way around */ | |||
4464 | if (is_inode_directory) { | |||
4465 | g_ptr_array_add (prepend_array, "folder"); | |||
4466 | } | |||
4467 | if (is_folder && (flags & BAUL_FILE_ICON_FLAGS_FOR_OPEN_FOLDER)) { | |||
4468 | g_ptr_array_add (prepend_array, "folder-open"); | |||
4469 | } | |||
4470 | if (is_folder && | |||
4471 | (flags & BAUL_FILE_ICON_FLAGS_IGNORE_VISITING) == 0 && | |||
4472 | baul_file_has_open_window (file)) { | |||
4473 | g_ptr_array_add (prepend_array, "folder-visiting"); | |||
4474 | } | |||
4475 | if (is_folder && | |||
4476 | (flags & BAUL_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT)) { | |||
4477 | g_ptr_array_add (prepend_array, "folder-drag-accept"); | |||
4478 | } | |||
4479 | ||||
4480 | if (prepend_array->len) { | |||
4481 | /* When constructing GThemed Icon, pointers from the array | |||
4482 | * are reused, but not the array itself, so the cast is safe */ | |||
4483 | icon = g_themed_icon_new_from_names ((char**) names, -1); | |||
4484 | g_ptr_array_foreach (prepend_array, (GFunc) prepend_icon_name, icon); | |||
4485 | } | |||
4486 | ||||
4487 | g_ptr_array_free (prepend_array, TRUE(!(0))); | |||
4488 | } | |||
4489 | ||||
4490 | if (icon == NULL((void*)0)) { | |||
4491 | icon = g_object_ref (file->details->icon)((__typeof__ (file->details->icon)) (g_object_ref) (file ->details->icon)); | |||
4492 | } | |||
4493 | ||||
4494 | if ((flags & BAUL_FILE_ICON_FLAGS_USE_MOUNT_ICON) && | |||
4495 | mount_icon != NULL((void*)0)) { | |||
4496 | g_object_unref (icon); | |||
4497 | icon = mount_icon; | |||
4498 | } else if ((flags & BAUL_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM) && | |||
4499 | mount_icon != NULL((void*)0) && !g_icon_equal (mount_icon, icon)) { | |||
4500 | GEmblem *emblem; | |||
4501 | ||||
4502 | emblem = g_emblem_new (mount_icon); | |||
4503 | emblemed_icon = g_emblemed_icon_new (icon, emblem); | |||
4504 | ||||
4505 | g_object_unref (emblem); | |||
4506 | g_object_unref (icon); | |||
4507 | g_object_unref (mount_icon); | |||
4508 | ||||
4509 | icon = emblemed_icon; | |||
4510 | } else if (mount_icon != NULL((void*)0)) { | |||
4511 | g_object_unref (mount_icon); | |||
4512 | } | |||
4513 | ||||
4514 | return icon; | |||
4515 | } | |||
4516 | ||||
4517 | return g_themed_icon_new ("text-x-generic"); | |||
4518 | } | |||
4519 | ||||
4520 | static GIcon * | |||
4521 | get_default_file_icon (BaulFileIconFlags flags) | |||
4522 | { | |||
4523 | static GIcon *fallback_icon = NULL((void*)0); | |||
4524 | static GIcon *fallback_icon_preview = NULL((void*)0); | |||
4525 | if (fallback_icon == NULL((void*)0)) { | |||
4526 | fallback_icon = g_themed_icon_new ("text-x-generic"); | |||
4527 | fallback_icon_preview = g_themed_icon_new ("text-x-preview"); | |||
4528 | g_themed_icon_append_name (G_THEMED_ICON (fallback_icon_preview)((((GThemedIcon*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((fallback_icon_preview)), ((g_themed_icon_get_type ())))) )), "text-x-generic"); | |||
4529 | } | |||
4530 | if (flags & BAUL_FILE_ICON_FLAGS_EMBEDDING_TEXT) { | |||
4531 | return fallback_icon_preview; | |||
4532 | } else { | |||
4533 | return fallback_icon; | |||
4534 | } | |||
4535 | } | |||
4536 | ||||
4537 | BaulIconInfo * | |||
4538 | baul_file_get_icon (BaulFile *file, | |||
4539 | int size, | |||
4540 | int scale, | |||
4541 | BaulFileIconFlags flags) | |||
4542 | { | |||
4543 | BaulIconInfo *icon; | |||
4544 | GIcon *gicon; | |||
4545 | GdkPixbuf *scaled_pixbuf; | |||
4546 | ||||
4547 | if (file == NULL((void*)0)) { | |||
4548 | return NULL((void*)0); | |||
4549 | } | |||
4550 | ||||
4551 | gicon = get_custom_icon (file); | |||
4552 | if (gicon) { | |||
4553 | GdkPixbuf *pixbuf; | |||
4554 | ||||
4555 | icon = baul_icon_info_lookup (gicon, size, scale); | |||
4556 | g_object_unref (gicon); | |||
4557 | ||||
4558 | pixbuf = baul_icon_info_get_pixbuf (icon); | |||
4559 | if (pixbuf != NULL((void*)0)) { | |||
4560 | if (!file->details->is_launcher && !gdk_pixbuf_get_has_alpha (pixbuf)) { | |||
4561 | baul_ui_frame_image (&pixbuf); | |||
4562 | } | |||
4563 | g_object_unref (icon); | |||
4564 | ||||
4565 | icon = baul_icon_info_new_for_pixbuf (pixbuf, scale); | |||
4566 | g_object_unref (pixbuf); | |||
4567 | } | |||
4568 | ||||
4569 | return icon; | |||
4570 | } | |||
4571 | ||||
4572 | if (flags & BAUL_FILE_ICON_FLAGS_USE_THUMBNAILS && | |||
4573 | baul_file_should_show_thumbnail (file)) { | |||
4574 | int modified_size; | |||
4575 | ||||
4576 | if (flags & BAUL_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE) { | |||
4577 | modified_size = size * scale; | |||
4578 | } else { | |||
4579 | modified_size = size * scale * cached_thumbnail_size / BAUL_ICON_SIZE_STANDARD48; | |||
4580 | } | |||
4581 | ||||
4582 | if (file->details->thumbnail) { | |||
4583 | int w, h, s; | |||
4584 | double thumb_scale; | |||
4585 | GdkPixbuf *raw_pixbuf; | |||
4586 | ||||
4587 | raw_pixbuf = g_object_ref (file->details->thumbnail)((__typeof__ (file->details->thumbnail)) (g_object_ref) (file->details->thumbnail)); | |||
4588 | ||||
4589 | w = gdk_pixbuf_get_width (raw_pixbuf); | |||
4590 | h = gdk_pixbuf_get_height (raw_pixbuf); | |||
4591 | ||||
4592 | s = MAX (w, h)(((w) > (h)) ? (w) : (h)); | |||
4593 | /* Don't scale up small thumbnails in the standard view */ | |||
4594 | if (s <= cached_thumbnail_size) { | |||
4595 | thumb_scale = (double)size / BAUL_ICON_SIZE_STANDARD48; | |||
4596 | } | |||
4597 | else { | |||
4598 | thumb_scale = (double)modified_size / s; | |||
4599 | } | |||
4600 | /* Make sure that icons don't get smaller than BAUL_ICON_SIZE_SMALLEST */ | |||
4601 | if (s*thumb_scale <= BAUL_ICON_SIZE_SMALLEST16) { | |||
4602 | thumb_scale = (double) BAUL_ICON_SIZE_SMALLEST16 / s; | |||
4603 | } | |||
4604 | ||||
4605 | scaled_pixbuf = gdk_pixbuf_scale_simple (raw_pixbuf, | |||
4606 | MAX (w * thumb_scale, 1)(((w * thumb_scale) > (1)) ? (w * thumb_scale) : (1)), | |||
4607 | MAX (h * thumb_scale, 1)(((h * thumb_scale) > (1)) ? (h * thumb_scale) : (1)), | |||
4608 | GDK_INTERP_BILINEAR); | |||
4609 | ||||
4610 | /* Render frames only for thumbnails of non-image files | |||
4611 | and for images with no alpha channel. */ | |||
4612 | gboolean is_image = file->details->mime_type && | |||
4613 | (strncmp (file->details->mime_type, "image/", 6) == 0); | |||
4614 | if (!is_image || !gdk_pixbuf_get_has_alpha (raw_pixbuf)) { | |||
4615 | baul_ui_frame_image (&scaled_pixbuf); | |||
4616 | } | |||
4617 | ||||
4618 | g_object_unref (raw_pixbuf); | |||
4619 | ||||
4620 | /* Don't scale up if more than 25%, then read the original | |||
4621 | image instead. We don't want to compare to exactly 100%, | |||
4622 | since the zoom level 150% gives thumbnails at 144, which is | |||
4623 | ok to scale up from 128. */ | |||
4624 | if (modified_size > 128 * 1.25 * scale && | |||
4625 | !file->details->thumbnail_wants_original && | |||
4626 | baul_can_thumbnail_internally (file)) { | |||
4627 | /* Invalidate if we resize upward */ | |||
4628 | file->details->thumbnail_wants_original = TRUE(!(0)); | |||
4629 | baul_file_invalidate_attributes (file, BAUL_FILE_ATTRIBUTE_THUMBNAIL); | |||
4630 | } | |||
4631 | ||||
4632 | icon = baul_icon_info_new_for_pixbuf (scaled_pixbuf, scale); | |||
4633 | g_object_unref (scaled_pixbuf); | |||
4634 | return icon; | |||
4635 | } else if (file->details->thumbnail_path == NULL((void*)0) && | |||
4636 | file->details->can_read && | |||
4637 | !file->details->is_thumbnailing && | |||
4638 | !file->details->thumbnailing_failed) { | |||
4639 | if (baul_can_thumbnail (file)) { | |||
4640 | baul_create_thumbnail (file); | |||
4641 | } | |||
4642 | } | |||
4643 | } | |||
4644 | ||||
4645 | if (file->details->is_thumbnailing && | |||
4646 | flags & BAUL_FILE_ICON_FLAGS_USE_THUMBNAILS) | |||
4647 | gicon = g_themed_icon_new (ICON_NAME_THUMBNAIL_LOADING"image-loading"); | |||
4648 | else | |||
4649 | gicon = baul_file_get_gicon (file, flags); | |||
4650 | ||||
4651 | if (gicon) { | |||
4652 | icon = baul_icon_info_lookup (gicon, size, scale); | |||
4653 | g_object_unref (gicon); | |||
4654 | return icon; | |||
4655 | } else { | |||
4656 | return baul_icon_info_lookup (get_default_file_icon (flags), size, scale); | |||
4657 | } | |||
4658 | } | |||
4659 | ||||
4660 | cairo_surface_t * | |||
4661 | baul_file_get_icon_surface (BaulFile *file, | |||
4662 | int size, | |||
4663 | gboolean force_size, | |||
4664 | int scale, | |||
4665 | BaulFileIconFlags flags) | |||
4666 | { | |||
4667 | BaulIconInfo *info; | |||
4668 | cairo_surface_t *surface; | |||
4669 | ||||
4670 | info = baul_file_get_icon (file, size, scale, flags); | |||
4671 | if (force_size) { | |||
4672 | surface = baul_icon_info_get_surface_at_size (info, size); | |||
4673 | } else { | |||
4674 | surface = baul_icon_info_get_surface (info); | |||
4675 | } | |||
4676 | g_object_unref (info); | |||
4677 | ||||
4678 | return surface; | |||
4679 | } | |||
4680 | ||||
4681 | char * | |||
4682 | baul_file_get_custom_icon (BaulFile *file) | |||
4683 | { | |||
4684 | char *custom_icon; | |||
4685 | ||||
4686 | if (file == NULL((void*)0)) { | |||
4687 | return NULL((void*)0); | |||
4688 | } | |||
4689 | ||||
4690 | /* Metadata takes precedence */ | |||
4691 | custom_icon = get_custom_icon_metadata_uri (file); | |||
4692 | ||||
4693 | if (custom_icon == NULL((void*)0) && file->details->got_link_info) { | |||
4694 | custom_icon = g_strdup (file->details->custom_icon); | |||
4695 | } | |||
4696 | ||||
4697 | return custom_icon; | |||
4698 | } | |||
4699 | ||||
4700 | ||||
4701 | gboolean | |||
4702 | baul_file_get_date (BaulFile *file, | |||
4703 | BaulDateType date_type, | |||
4704 | time_t *date) | |||
4705 | { | |||
4706 | if (date != NULL((void*)0)) { | |||
4707 | *date = 0; | |||
4708 | } | |||
4709 | ||||
4710 | g_return_val_if_fail (date_type == BAUL_DATE_TYPE_CHANGEDdo { if ((date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED )) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED" ); return ((0)); } } while (0) | |||
4711 | || date_type == BAUL_DATE_TYPE_ACCESSEDdo { if ((date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED )) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED" ); return ((0)); } } while (0) | |||
4712 | || date_type == BAUL_DATE_TYPE_MODIFIEDdo { if ((date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED )) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED" ); return ((0)); } } while (0) | |||
4713 | || date_type == BAUL_DATE_TYPE_TRASHEDdo { if ((date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED )) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED" ); return ((0)); } } while (0) | |||
4714 | || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED, FALSE)do { if ((date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED )) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "date_type == BAUL_DATE_TYPE_CHANGED || date_type == BAUL_DATE_TYPE_ACCESSED || date_type == BAUL_DATE_TYPE_MODIFIED || date_type == BAUL_DATE_TYPE_TRASHED || date_type == BAUL_DATE_TYPE_PERMISSIONS_CHANGED" ); return ((0)); } } while (0); | |||
4715 | ||||
4716 | if (file == NULL((void*)0)) { | |||
4717 | return FALSE(0); | |||
4718 | } | |||
4719 | ||||
4720 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
4721 | ||||
4722 | return EEL_CALL_METHOD_WITH_RETURN_VALUE(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_date == ((void*)0) ) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_date ) (file, date_type, date)) | |||
4723 | (BAUL_FILE_CLASS, file,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_date == ((void*)0) ) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_date ) (file, date_type, date)) | |||
4724 | get_date, (file, date_type, date))(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_date == ((void*)0) ) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_date ) (file, date_type, date)); | |||
4725 | } | |||
4726 | ||||
4727 | static char * | |||
4728 | baul_file_get_where_string (BaulFile *file) | |||
4729 | { | |||
4730 | if (file == NULL((void*)0)) { | |||
4731 | return NULL((void*)0); | |||
4732 | } | |||
4733 | ||||
4734 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
4735 | ||||
4736 | return EEL_CALL_METHOD_WITH_RETURN_VALUE(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_where_string == (( void*)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_where_string ) (file)) | |||
4737 | (BAUL_FILE_CLASS, file,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_where_string == (( void*)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_where_string ) (file)) | |||
4738 | get_where_string, (file))(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_where_string == (( void*)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_where_string ) (file)); | |||
4739 | } | |||
4740 | ||||
4741 | static const char *TODAY_TIME_FORMATS [] = { | |||
4742 | /* Today, use special word. | |||
4743 | * strftime patterns preceeded with the widest | |||
4744 | * possible resulting string for that pattern. | |||
4745 | * | |||
4746 | * Note to localizers: You can look at man strftime | |||
4747 | * for details on the format, but you should only use | |||
4748 | * the specifiers from the C standard, not extensions. | |||
4749 | * These include "%" followed by one of | |||
4750 | * "aAbBcdHIjmMpSUwWxXyYZ". There are two extensions | |||
4751 | * in the Baul version of strftime that can be | |||
4752 | * used (and match GNU extensions). Putting a "-" | |||
4753 | * between the "%" and any numeric directive will turn | |||
4754 | * off zero padding, and putting a "_" there will use | |||
4755 | * space padding instead of zero padding. | |||
4756 | */ | |||
4757 | N_("today at 00:00:00 PM")("today at 00:00:00 PM"), | |||
4758 | N_("today at %-I:%M:%S %p")("today at %-I:%M:%S %p"), | |||
4759 | ||||
4760 | N_("today at 00:00 PM")("today at 00:00 PM"), | |||
4761 | N_("today at %-I:%M %p")("today at %-I:%M %p"), | |||
4762 | ||||
4763 | N_("today, 00:00 PM")("today, 00:00 PM"), | |||
4764 | N_("today, %-I:%M %p")("today, %-I:%M %p"), | |||
4765 | ||||
4766 | N_("today")("today"), | |||
4767 | N_("today")("today"), | |||
4768 | ||||
4769 | NULL((void*)0) | |||
4770 | }; | |||
4771 | ||||
4772 | static const char *YESTERDAY_TIME_FORMATS [] = { | |||
4773 | /* Yesterday, use special word. | |||
4774 | * Note to localizers: Same issues as "today" string. | |||
4775 | */ | |||
4776 | N_("yesterday at 00:00:00 PM")("yesterday at 00:00:00 PM"), | |||
4777 | N_("yesterday at %-I:%M:%S %p")("yesterday at %-I:%M:%S %p"), | |||
4778 | ||||
4779 | N_("yesterday at 00:00 PM")("yesterday at 00:00 PM"), | |||
4780 | N_("yesterday at %-I:%M %p")("yesterday at %-I:%M %p"), | |||
4781 | ||||
4782 | N_("yesterday, 00:00 PM")("yesterday, 00:00 PM"), | |||
4783 | N_("yesterday, %-I:%M %p")("yesterday, %-I:%M %p"), | |||
4784 | ||||
4785 | N_("yesterday")("yesterday"), | |||
4786 | N_("yesterday")("yesterday"), | |||
4787 | ||||
4788 | NULL((void*)0) | |||
4789 | }; | |||
4790 | ||||
4791 | static const char *CURRENT_WEEK_TIME_FORMATS [] = { | |||
4792 | /* Current week, include day of week. | |||
4793 | * Note to localizers: Same issues as "today" string. | |||
4794 | * The width measurement templates correspond to | |||
4795 | * the day/month name with the most letters. | |||
4796 | */ | |||
4797 | N_("Wednesday, September 00 0000 at 00:00:00 PM")("Wednesday, September 00 0000 at 00:00:00 PM"), | |||
4798 | N_("%A, %B %-d %Y at %-I:%M:%S %p")("%A, %B %-d %Y at %-I:%M:%S %p"), | |||
4799 | ||||
4800 | N_("Mon, Oct 00 0000 at 00:00:00 PM")("Mon, Oct 00 0000 at 00:00:00 PM"), | |||
4801 | N_("%a, %b %-d %Y at %-I:%M:%S %p")("%a, %b %-d %Y at %-I:%M:%S %p"), | |||
4802 | ||||
4803 | N_("Mon, Oct 00 0000 at 00:00 PM")("Mon, Oct 00 0000 at 00:00 PM"), | |||
4804 | N_("%a, %b %-d %Y at %-I:%M %p")("%a, %b %-d %Y at %-I:%M %p"), | |||
4805 | ||||
4806 | N_("Oct 00 0000 at 00:00 PM")("Oct 00 0000 at 00:00 PM"), | |||
4807 | N_("%b %-d %Y at %-I:%M %p")("%b %-d %Y at %-I:%M %p"), | |||
4808 | ||||
4809 | N_("Oct 00 0000, 00:00 PM")("Oct 00 0000, 00:00 PM"), | |||
4810 | N_("%b %-d %Y, %-I:%M %p")("%b %-d %Y, %-I:%M %p"), | |||
4811 | ||||
4812 | N_("00/00/00, 00:00 PM")("00/00/00, 00:00 PM"), | |||
4813 | N_("%m/%-d/%y, %-I:%M %p")("%m/%-d/%y, %-I:%M %p"), | |||
4814 | ||||
4815 | N_("00/00/00")("00/00/00"), | |||
4816 | N_("%m/%d/%y")("%m/%d/%y"), | |||
4817 | ||||
4818 | NULL((void*)0) | |||
4819 | }; | |||
4820 | ||||
4821 | static char * | |||
4822 | baul_file_fit_date_as_string (BaulFile *file, | |||
4823 | BaulDateType date_type, | |||
4824 | int width, | |||
4825 | BaulWidthMeasureCallback measure_callback, | |||
4826 | BaulTruncateCallback truncate_callback, | |||
4827 | void *measure_context) | |||
4828 | { | |||
4829 | time_t file_time_raw; | |||
4830 | const char **formats; | |||
4831 | const char *format; | |||
4832 | char *date_string; | |||
4833 | gchar *result = NULL((void*)0); | |||
4834 | int i; | |||
4835 | GDateTime *date_time, *today; | |||
4836 | GTimeSpan file_date_age; | |||
4837 | ||||
4838 | if (!baul_file_get_date (file, date_type, &file_time_raw)) { | |||
4839 | return NULL((void*)0); | |||
4840 | } | |||
4841 | ||||
4842 | date_time = g_date_time_new_from_unix_local (file_time_raw); | |||
4843 | ||||
4844 | if (date_format_pref == BAUL_DATE_FORMAT_LOCALE) { | |||
4845 | result = g_date_time_format (date_time, "%c"); | |||
4846 | goto out; | |||
4847 | } else if (date_format_pref == BAUL_DATE_FORMAT_ISO) { | |||
4848 | result = g_date_time_format (date_time, "%Y-%m-%d %H:%M:%S"); | |||
4849 | goto out; | |||
4850 | } | |||
4851 | ||||
4852 | today = g_date_time_new_now_local (); | |||
4853 | file_date_age = g_date_time_difference (today, date_time); | |||
4854 | g_date_time_unref (today); | |||
4855 | ||||
4856 | /* Format varies depending on how old the date is. This minimizes | |||
4857 | * the length (and thus clutter & complication) of typical dates | |||
4858 | * while providing sufficient detail for recent dates to make | |||
4859 | * them maximally understandable at a glance. Keep all format | |||
4860 | * strings separate rather than combining bits & pieces for | |||
4861 | * internationalization's sake. | |||
4862 | */ | |||
4863 | ||||
4864 | if (file_date_age < G_TIME_SPAN_DAY((86400000000L))) { | |||
4865 | formats = TODAY_TIME_FORMATS; | |||
4866 | } else if (file_date_age < 2 * G_TIME_SPAN_DAY((86400000000L))) { | |||
4867 | formats = YESTERDAY_TIME_FORMATS; | |||
4868 | } else { | |||
4869 | formats = CURRENT_WEEK_TIME_FORMATS; | |||
4870 | } | |||
4871 | ||||
4872 | /* Find the date format that just fits the required width. Instead of measuring | |||
4873 | * the resulting string width directly, measure the width of a template that represents | |||
4874 | * the widest possible version of a date in a given format. This is done by using M, m | |||
4875 | * and 0 for the variable letters/digits respectively. | |||
4876 | */ | |||
4877 | format = NULL((void*)0); | |||
4878 | ||||
4879 | for (i = 0; ; i += 2) { | |||
4880 | const char *width_template; | |||
4881 | ||||
4882 | width_template = (formats [i] ? _(formats [i])gettext (formats [i]) : NULL((void*)0)); | |||
4883 | if (width_template == NULL((void*)0)) { | |||
4884 | /* no more formats left */ | |||
4885 | g_assert (format != NULL)do { if (format != ((void*)0)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 4885, ((const char*) (__func__ )), "format != NULL"); } while (0); | |||
4886 | ||||
4887 | /* Can't fit even the shortest format -- return an ellipsized form in the | |||
4888 | * shortest format | |||
4889 | */ | |||
4890 | ||||
4891 | date_string = g_date_time_format (date_time, format); | |||
4892 | ||||
4893 | if (truncate_callback == NULL((void*)0)) { | |||
4894 | result = date_string; | |||
4895 | break; | |||
4896 | } | |||
4897 | ||||
4898 | result = (* truncate_callback) (date_string, width, measure_context); | |||
4899 | g_free (date_string); | |||
4900 | break; | |||
4901 | } | |||
4902 | ||||
4903 | format = _(formats [i + 1])gettext (formats [i + 1]); | |||
4904 | ||||
4905 | if (measure_callback == NULL((void*)0)) { | |||
4906 | /* don't care about fitting the width */ | |||
4907 | break; | |||
4908 | } | |||
4909 | ||||
4910 | if ((* measure_callback) (width_template, measure_context) <= width) { | |||
4911 | /* The template fits, this is the format we can fit. */ | |||
4912 | break; | |||
4913 | } | |||
4914 | } | |||
4915 | ||||
4916 | if (result == NULL((void*)0)) { | |||
4917 | result = g_date_time_format (date_time, format); | |||
4918 | } | |||
4919 | ||||
4920 | out: | |||
4921 | g_date_time_unref (date_time); | |||
4922 | return result; | |||
4923 | } | |||
4924 | ||||
4925 | /** | |||
4926 | * baul_file_fit_modified_date_as_string: | |||
4927 | * | |||
4928 | * Get a user-displayable string representing a file modification date, | |||
4929 | * truncated to @width using the measuring and truncating callbacks. | |||
4930 | * @file: BaulFile representing the file in question. | |||
4931 | * @width: The desired resulting string width. | |||
4932 | * @measure_callback: The callback used to measure the string width. | |||
4933 | * @truncate_callback: The callback used to truncate the string to a desired width. | |||
4934 | * @measure_context: Data neede when measuring and truncating. | |||
4935 | * | |||
4936 | * Returns: Newly allocated string ready to display to the user. | |||
4937 | * | |||
4938 | **/ | |||
4939 | char * | |||
4940 | baul_file_fit_modified_date_as_string (BaulFile *file, | |||
4941 | int width, | |||
4942 | BaulWidthMeasureCallback measure_callback, | |||
4943 | BaulTruncateCallback truncate_callback, | |||
4944 | void *measure_context) | |||
4945 | { | |||
4946 | return baul_file_fit_date_as_string (file, BAUL_DATE_TYPE_MODIFIED, | |||
4947 | width, measure_callback, truncate_callback, measure_context); | |||
4948 | } | |||
4949 | ||||
4950 | static char * | |||
4951 | baul_file_get_trash_original_file_parent_as_string (BaulFile *file) | |||
4952 | { | |||
4953 | if (file->details->trash_orig_path != NULL((void*)0)) { | |||
4954 | BaulFile *orig_file, *parent; | |||
4955 | GFile *location; | |||
4956 | char *filename; | |||
4957 | ||||
4958 | orig_file = baul_file_get_trash_original_file (file); | |||
4959 | parent = baul_file_get_parent (orig_file); | |||
4960 | location = baul_file_get_location (parent); | |||
4961 | ||||
4962 | filename = g_file_get_parse_name (location); | |||
4963 | ||||
4964 | g_object_unref (location); | |||
4965 | baul_file_unref (parent); | |||
4966 | baul_file_unref (orig_file); | |||
4967 | ||||
4968 | return filename; | |||
4969 | } | |||
4970 | ||||
4971 | return NULL((void*)0); | |||
4972 | } | |||
4973 | ||||
4974 | /** | |||
4975 | * baul_file_get_date_as_string: | |||
4976 | * | |||
4977 | * Get a user-displayable string representing a file modification date. | |||
4978 | * The caller is responsible for g_free-ing this string. | |||
4979 | * @file: BaulFile representing the file in question. | |||
4980 | * | |||
4981 | * Returns: Newly allocated string ready to display to the user. | |||
4982 | * | |||
4983 | **/ | |||
4984 | static char * | |||
4985 | baul_file_get_date_as_string (BaulFile *file, BaulDateType date_type) | |||
4986 | { | |||
4987 | return baul_file_fit_date_as_string (file, date_type, | |||
4988 | 0, NULL((void*)0), NULL((void*)0), NULL((void*)0)); | |||
4989 | } | |||
4990 | ||||
4991 | static BaulSpeedTradeoffValue show_directory_item_count; | |||
4992 | static BaulSpeedTradeoffValue show_text_in_icons; | |||
4993 | ||||
4994 | static void | |||
4995 | show_text_in_icons_changed_callback (gpointer callback_data) | |||
4996 | { | |||
4997 | show_text_in_icons = g_settings_get_enum (baul_preferences, BAUL_PREFERENCES_SHOW_TEXT_IN_ICONS"show-icon-text"); | |||
4998 | } | |||
4999 | ||||
5000 | static void | |||
5001 | show_directory_item_count_changed_callback (gpointer callback_data) | |||
5002 | { | |||
5003 | show_directory_item_count = g_settings_get_enum (baul_preferences, BAUL_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS"show-directory-item-counts"); | |||
5004 | } | |||
5005 | ||||
5006 | static gboolean | |||
5007 | get_speed_tradeoff_preference_for_file (BaulFile *file, BaulSpeedTradeoffValue value) | |||
5008 | { | |||
5009 | GFilesystemPreviewType use_preview; | |||
5010 | ||||
5011 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
5012 | ||||
5013 | use_preview = baul_file_get_filesystem_use_preview (file); | |||
5014 | ||||
5015 | if (value == BAUL_SPEED_TRADEOFF_ALWAYS) { | |||
5016 | if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) { | |||
5017 | return FALSE(0); | |||
5018 | } else { | |||
5019 | return TRUE(!(0)); | |||
5020 | } | |||
5021 | } | |||
5022 | ||||
5023 | if (value == BAUL_SPEED_TRADEOFF_NEVER) { | |||
5024 | return FALSE(0); | |||
5025 | } | |||
5026 | ||||
5027 | g_assert (value == BAUL_SPEED_TRADEOFF_LOCAL_ONLY)do { if (value == BAUL_SPEED_TRADEOFF_LOCAL_ONLY) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 5027, ((const char*) (__func__ )), "value == BAUL_SPEED_TRADEOFF_LOCAL_ONLY"); } while (0); | |||
5028 | ||||
5029 | if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) { | |||
5030 | /* file system says to never preview anything */ | |||
5031 | return FALSE(0); | |||
5032 | } else if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL) { | |||
5033 | /* file system says we should treat file as if it's local */ | |||
5034 | return TRUE(!(0)); | |||
5035 | } else { | |||
5036 | /* only local files */ | |||
5037 | return baul_file_is_local (file); | |||
5038 | } | |||
5039 | } | |||
5040 | ||||
5041 | gboolean | |||
5042 | baul_file_should_show_directory_item_count (BaulFile *file) | |||
5043 | { | |||
5044 | static gboolean show_directory_item_count_callback_added = FALSE(0); | |||
5045 | ||||
5046 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
5047 | ||||
5048 | if (file->details->mime_type && | |||
5049 | strcmp (file->details->mime_type, "x-directory/smb-share") == 0) { | |||
5050 | return FALSE(0); | |||
5051 | } | |||
5052 | ||||
5053 | /* Add the callback once for the life of our process */ | |||
5054 | if (!show_directory_item_count_callback_added) { | |||
5055 | g_signal_connect_swapped (baul_preferences,g_signal_connect_data ((baul_preferences), ("changed::" "show-directory-item-counts" ), (((GCallback) (show_directory_item_count_changed_callback) )), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
5056 | "changed::" BAUL_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS,g_signal_connect_data ((baul_preferences), ("changed::" "show-directory-item-counts" ), (((GCallback) (show_directory_item_count_changed_callback) )), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
5057 | G_CALLBACK(show_directory_item_count_changed_callback),g_signal_connect_data ((baul_preferences), ("changed::" "show-directory-item-counts" ), (((GCallback) (show_directory_item_count_changed_callback) )), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
5058 | NULL)g_signal_connect_data ((baul_preferences), ("changed::" "show-directory-item-counts" ), (((GCallback) (show_directory_item_count_changed_callback) )), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED); | |||
5059 | show_directory_item_count_callback_added = TRUE(!(0)); | |||
5060 | ||||
5061 | /* Peek for the first time */ | |||
5062 | show_directory_item_count_changed_callback (NULL((void*)0)); | |||
5063 | } | |||
5064 | ||||
5065 | return get_speed_tradeoff_preference_for_file (file, show_directory_item_count); | |||
5066 | } | |||
5067 | ||||
5068 | gboolean | |||
5069 | baul_file_should_show_type (BaulFile *file) | |||
5070 | { | |||
5071 | char *uri; | |||
5072 | gboolean ret; | |||
5073 | ||||
5074 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
5075 | ||||
5076 | uri = baul_file_get_uri (file); | |||
5077 | ret = ((strcmp (uri, "computer:///") != 0) && | |||
5078 | (strcmp (uri, "network:///") != 0) && | |||
5079 | (strcmp (uri, "smb:///") != 0)); | |||
5080 | g_free (uri); | |||
5081 | ||||
5082 | return ret; | |||
5083 | } | |||
5084 | ||||
5085 | gboolean | |||
5086 | baul_file_should_get_top_left_text (BaulFile *file) | |||
5087 | { | |||
5088 | static gboolean show_text_in_icons_callback_added = FALSE(0); | |||
5089 | ||||
5090 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
5091 | ||||
5092 | /* Add the callback once for the life of our process */ | |||
5093 | if (!show_text_in_icons_callback_added) { | |||
5094 | g_signal_connect_swapped (baul_preferences,g_signal_connect_data ((baul_preferences), ("changed::" "show-icon-text" ), (((GCallback) (show_text_in_icons_changed_callback))), ((( void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
5095 | "changed::" BAUL_PREFERENCES_SHOW_TEXT_IN_ICONS,g_signal_connect_data ((baul_preferences), ("changed::" "show-icon-text" ), (((GCallback) (show_text_in_icons_changed_callback))), ((( void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
5096 | G_CALLBACK (show_text_in_icons_changed_callback),g_signal_connect_data ((baul_preferences), ("changed::" "show-icon-text" ), (((GCallback) (show_text_in_icons_changed_callback))), ((( void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
5097 | NULL)g_signal_connect_data ((baul_preferences), ("changed::" "show-icon-text" ), (((GCallback) (show_text_in_icons_changed_callback))), ((( void*)0)), ((void*)0), G_CONNECT_SWAPPED); | |||
5098 | show_text_in_icons_callback_added = TRUE(!(0)); | |||
5099 | ||||
5100 | /* Peek for the first time */ | |||
5101 | show_text_in_icons_changed_callback (NULL((void*)0)); | |||
5102 | } | |||
5103 | ||||
5104 | if (show_text_in_icons == BAUL_SPEED_TRADEOFF_ALWAYS) { | |||
5105 | return TRUE(!(0)); | |||
5106 | } | |||
5107 | ||||
5108 | if (show_text_in_icons == BAUL_SPEED_TRADEOFF_NEVER) { | |||
5109 | return FALSE(0); | |||
5110 | } | |||
5111 | ||||
5112 | return get_speed_tradeoff_preference_for_file (file, show_text_in_icons); | |||
5113 | } | |||
5114 | ||||
5115 | /** | |||
5116 | * baul_file_get_directory_item_count | |||
5117 | * | |||
5118 | * Get the number of items in a directory. | |||
5119 | * @file: BaulFile representing a directory. | |||
5120 | * @count: Place to put count. | |||
5121 | * @count_unreadable: Set to TRUE (if non-NULL) if permissions prevent | |||
5122 | * the item count from being read on this directory. Otherwise set to FALSE. | |||
5123 | * | |||
5124 | * Returns: TRUE if count is available. | |||
5125 | * | |||
5126 | **/ | |||
5127 | gboolean | |||
5128 | baul_file_get_directory_item_count (BaulFile *file, | |||
5129 | guint *count, | |||
5130 | gboolean *count_unreadable) | |||
5131 | { | |||
5132 | if (count != NULL((void*)0)) { | |||
5133 | *count = 0; | |||
5134 | } | |||
5135 | if (count_unreadable != NULL((void*)0)) { | |||
5136 | *count_unreadable = FALSE(0); | |||
5137 | } | |||
5138 | ||||
5139 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
5140 | ||||
5141 | if (!baul_file_is_directory (file)) { | |||
5142 | return FALSE(0); | |||
5143 | } | |||
5144 | ||||
5145 | if (!baul_file_should_show_directory_item_count (file)) { | |||
5146 | return FALSE(0); | |||
5147 | } | |||
5148 | ||||
5149 | return EEL_CALL_METHOD_WITH_RETURN_VALUE(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_item_count == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_item_count ) (file, count, count_unreadable)) | |||
5150 | (BAUL_FILE_CLASS, file,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_item_count == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_item_count ) (file, count, count_unreadable)) | |||
5151 | get_item_count, (file, count, count_unreadable))(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_item_count == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_item_count ) (file, count, count_unreadable)); | |||
5152 | } | |||
5153 | ||||
5154 | /** | |||
5155 | * baul_file_get_deep_counts | |||
5156 | * | |||
5157 | * Get the statistics about items inside a directory. | |||
5158 | * @file: BaulFile representing a directory or file. | |||
5159 | * @directory_count: Place to put count of directories inside. | |||
5160 | * @files_count: Place to put count of files inside. | |||
5161 | * @unreadable_directory_count: Number of directories encountered | |||
5162 | * that were unreadable. | |||
5163 | * @total_size: Total size of all files and directories visited. | |||
5164 | * @total_size_on_disk: Total size on disk of all files and directories visited. | |||
5165 | * @force: Whether the deep counts should even be collected if | |||
5166 | * baul_file_should_show_directory_item_count returns FALSE | |||
5167 | * for this file. | |||
5168 | * | |||
5169 | * Returns: Status to indicate whether sizes are available. | |||
5170 | * | |||
5171 | **/ | |||
5172 | BaulRequestStatus | |||
5173 | baul_file_get_deep_counts (BaulFile *file, | |||
5174 | guint *directory_count, | |||
5175 | guint *file_count, | |||
5176 | guint *unreadable_directory_count, | |||
5177 | goffset *total_size, | |||
5178 | goffset *total_size_on_disk, | |||
5179 | gboolean force) | |||
5180 | { | |||
5181 | if (directory_count != NULL((void*)0)) { | |||
5182 | *directory_count = 0; | |||
5183 | } | |||
5184 | if (file_count != NULL((void*)0)) { | |||
5185 | *file_count = 0; | |||
5186 | } | |||
5187 | if (unreadable_directory_count != NULL((void*)0)) { | |||
5188 | *unreadable_directory_count = 0; | |||
5189 | } | |||
5190 | if (total_size != NULL((void*)0)) { | |||
5191 | *total_size = 0; | |||
5192 | } | |||
5193 | if (total_size_on_disk != NULL((void*)0)) { | |||
5194 | *total_size_on_disk = 0; | |||
5195 | } | |||
5196 | ||||
5197 | g_return_val_if_fail (BAUL_IS_FILE (file), BAUL_REQUEST_DONE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (BAUL_REQUEST_DONE ); } } while (0); | |||
5198 | ||||
5199 | if (!force && !baul_file_should_show_directory_item_count (file)) { | |||
5200 | /* Set field so an existing value isn't treated as up-to-date | |||
5201 | * when preference changes later. | |||
5202 | */ | |||
5203 | file->details->deep_counts_status = BAUL_REQUEST_NOT_STARTED; | |||
5204 | return file->details->deep_counts_status; | |||
5205 | } | |||
5206 | ||||
5207 | return EEL_CALL_METHOD_WITH_RETURN_VALUE(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)) | |||
5208 | (BAUL_FILE_CLASS, file,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)) | |||
5209 | get_deep_counts, (file,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)) | |||
5210 | directory_count,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)) | |||
5211 | file_count,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)) | |||
5212 | unreadable_directory_count,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)) | |||
5213 | total_size,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)) | |||
5214 | total_size_on_disk))(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->get_deep_counts == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->get_deep_counts ) (file, directory_count, file_count, unreadable_directory_count , total_size, total_size_on_disk)); | |||
5215 | } | |||
5216 | ||||
5217 | void | |||
5218 | baul_file_recompute_deep_counts (BaulFile *file) | |||
5219 | { | |||
5220 | if (file->details->deep_counts_status != BAUL_REQUEST_IN_PROGRESS) { | |||
5221 | file->details->deep_counts_status = BAUL_REQUEST_NOT_STARTED; | |||
5222 | if (file->details->directory != NULL((void*)0)) { | |||
5223 | baul_directory_add_file_to_work_queue (file->details->directory, file); | |||
5224 | baul_directory_async_state_changed (file->details->directory); | |||
5225 | } | |||
5226 | } | |||
5227 | } | |||
5228 | ||||
5229 | gboolean | |||
5230 | baul_file_can_get_size (BaulFile *file) | |||
5231 | { | |||
5232 | return file->details->size == -1; | |||
5233 | } | |||
5234 | ||||
5235 | ||||
5236 | /** | |||
5237 | * baul_file_get_size | |||
5238 | * | |||
5239 | * Get the file size. | |||
5240 | * @file: BaulFile representing the file in question. | |||
5241 | * | |||
5242 | * Returns: Size in bytes. | |||
5243 | * | |||
5244 | **/ | |||
5245 | goffset | |||
5246 | baul_file_get_size (BaulFile *file) | |||
5247 | { | |||
5248 | /* Before we have info on the file, we don't know the size. */ | |||
5249 | if (file->details->size == -1) | |||
5250 | return 0; | |||
5251 | return file->details->size; | |||
5252 | } | |||
5253 | ||||
5254 | /** | |||
5255 | * baul_file_get_size_on_disk | |||
5256 | * | |||
5257 | * Get the file size on disk (how many bytes is using on the filesystem). | |||
5258 | * e.g.: usually files with 1 byte will use a whole inode so it will return the | |||
5259 | * size of 1 inode. If the file is sparse the size on disk will be equal or less | |||
5260 | * than the size of the file. | |||
5261 | * @file: BaulFile representing the file in question. | |||
5262 | * | |||
5263 | * Returns: Size in bytes. | |||
5264 | * | |||
5265 | **/ | |||
5266 | goffset | |||
5267 | baul_file_get_size_on_disk (BaulFile *file) | |||
5268 | { | |||
5269 | /* Before we have info on the file, we don't know the size. */ | |||
5270 | if (file->details->size_on_disk == -1) | |||
5271 | return 0; | |||
5272 | return file->details->size_on_disk; | |||
5273 | } | |||
5274 | ||||
5275 | time_t | |||
5276 | baul_file_get_mtime (BaulFile *file) | |||
5277 | { | |||
5278 | return file->details->mtime; | |||
5279 | } | |||
5280 | ||||
5281 | ||||
5282 | static void | |||
5283 | set_attributes_get_info_callback (GObject *source_object, | |||
5284 | GAsyncResult *res, | |||
5285 | gpointer callback_data) | |||
5286 | { | |||
5287 | BaulFileOperation *op; | |||
5288 | GFileInfo *new_info; | |||
5289 | GError *error; | |||
5290 | ||||
5291 | op = callback_data; | |||
5292 | ||||
5293 | error = NULL((void*)0); | |||
5294 | new_info = g_file_query_info_finish (G_FILE (source_object)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_file_get_type ())))))), res, &error); | |||
5295 | if (new_info != NULL((void*)0)) { | |||
5296 | if (baul_file_update_info (op->file, new_info)) { | |||
5297 | baul_file_changed (op->file); | |||
5298 | } | |||
5299 | g_object_unref (new_info); | |||
5300 | } | |||
5301 | baul_file_operation_complete (op, NULL((void*)0), error); | |||
5302 | if (error) { | |||
5303 | g_error_free (error); | |||
5304 | } | |||
5305 | } | |||
5306 | ||||
5307 | ||||
5308 | static void | |||
5309 | set_attributes_callback (GObject *source_object, | |||
5310 | GAsyncResult *result, | |||
5311 | gpointer callback_data) | |||
5312 | { | |||
5313 | BaulFileOperation *op; | |||
5314 | GError *error; | |||
5315 | gboolean res; | |||
5316 | ||||
5317 | op = callback_data; | |||
5318 | ||||
5319 | error = NULL((void*)0); | |||
5320 | res = g_file_set_attributes_finish (G_FILE (source_object)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_file_get_type ())))))), | |||
5321 | result, | |||
5322 | NULL((void*)0), | |||
5323 | &error); | |||
5324 | ||||
5325 | if (res) { | |||
5326 | g_file_query_info_async (G_FILE (source_object)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_file_get_type ())))))), | |||
5327 | BAUL_FILE_DEFAULT_ATTRIBUTES"standard::*,access::*,mountable::*,time::*,unix::*,owner::*,selinux::*,thumbnail::*,id::filesystem,trash::orig-path,trash::deletion-date,metadata::*", | |||
5328 | 0, | |||
5329 | G_PRIORITY_DEFAULT0, | |||
5330 | op->cancellable, | |||
5331 | set_attributes_get_info_callback, op); | |||
5332 | } else { | |||
5333 | baul_file_operation_complete (op, NULL((void*)0), error); | |||
5334 | g_error_free (error); | |||
5335 | } | |||
5336 | } | |||
5337 | ||||
5338 | void | |||
5339 | baul_file_set_attributes (BaulFile *file, | |||
5340 | GFileInfo *attributes, | |||
5341 | BaulFileOperationCallback callback, | |||
5342 | gpointer callback_data) | |||
5343 | { | |||
5344 | BaulFileOperation *op; | |||
5345 | GFile *location; | |||
5346 | ||||
5347 | op = baul_file_operation_new (file, callback, callback_data); | |||
5348 | ||||
5349 | location = baul_file_get_location (file); | |||
5350 | g_file_set_attributes_async (location, | |||
5351 | attributes, | |||
5352 | 0, | |||
5353 | G_PRIORITY_DEFAULT0, | |||
5354 | op->cancellable, | |||
5355 | set_attributes_callback, | |||
5356 | op); | |||
5357 | g_object_unref (location); | |||
5358 | } | |||
5359 | ||||
5360 | ||||
5361 | /** | |||
5362 | * baul_file_can_get_permissions: | |||
5363 | * | |||
5364 | * Check whether the permissions for a file are determinable. | |||
5365 | * This might not be the case for files on non-UNIX file systems. | |||
5366 | * | |||
5367 | * @file: The file in question. | |||
5368 | * | |||
5369 | * Return value: TRUE if the permissions are valid. | |||
5370 | */ | |||
5371 | gboolean | |||
5372 | baul_file_can_get_permissions (BaulFile *file) | |||
5373 | { | |||
5374 | return file->details->has_permissions; | |||
5375 | } | |||
5376 | ||||
5377 | /** | |||
5378 | * baul_file_can_set_permissions: | |||
5379 | * | |||
5380 | * Check whether the current user is allowed to change | |||
5381 | * the permissions of a file. | |||
5382 | * | |||
5383 | * @file: The file in question. | |||
5384 | * | |||
5385 | * Return value: TRUE if the current user can change the | |||
5386 | * permissions of @file, FALSE otherwise. It's always possible | |||
5387 | * that when you actually try to do it, you will fail. | |||
5388 | */ | |||
5389 | gboolean | |||
5390 | baul_file_can_set_permissions (BaulFile *file) | |||
5391 | { | |||
5392 | uid_t user_id; | |||
5393 | ||||
5394 | if (file->details->uid != -1 && | |||
5395 | baul_file_is_local (file)) { | |||
5396 | /* Check the user. */ | |||
5397 | user_id = geteuid(); | |||
5398 | ||||
5399 | /* Owner is allowed to set permissions. */ | |||
5400 | if (user_id == (uid_t) file->details->uid) { | |||
5401 | return TRUE(!(0)); | |||
5402 | } | |||
5403 | ||||
5404 | /* Root is also allowed to set permissions. */ | |||
5405 | if (user_id == 0) { | |||
5406 | return TRUE(!(0)); | |||
5407 | } | |||
5408 | ||||
5409 | /* Nobody else is allowed. */ | |||
5410 | return FALSE(0); | |||
5411 | } | |||
5412 | ||||
5413 | /* pretend to have full chmod rights when no info is available, relevant when | |||
5414 | * the FS can't provide ownership info, for instance for FTP */ | |||
5415 | return TRUE(!(0)); | |||
5416 | } | |||
5417 | ||||
5418 | guint | |||
5419 | baul_file_get_permissions (BaulFile *file) | |||
5420 | { | |||
5421 | g_return_val_if_fail (baul_file_can_get_permissions (file), 0)do { if ((baul_file_can_get_permissions (file))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "baul_file_can_get_permissions (file)" ); return (0); } } while (0); | |||
5422 | ||||
5423 | return file->details->permissions; | |||
5424 | } | |||
5425 | ||||
5426 | /** | |||
5427 | * baul_file_set_permissions: | |||
5428 | * | |||
5429 | * Change a file's permissions. This should only be called if | |||
5430 | * baul_file_can_set_permissions returned TRUE. | |||
5431 | * | |||
5432 | * @file: BaulFile representing the file in question. | |||
5433 | * @new_permissions: New permissions value. This is the whole | |||
5434 | * set of permissions, not a delta. | |||
5435 | **/ | |||
5436 | void | |||
5437 | baul_file_set_permissions (BaulFile *file, | |||
5438 | guint32 new_permissions, | |||
5439 | BaulFileOperationCallback callback, | |||
5440 | gpointer callback_data) | |||
5441 | { | |||
5442 | GFileInfo *info; | |||
5443 | ||||
5444 | if (!baul_file_can_set_permissions (file)) { | |||
5445 | GError *error; | |||
5446 | ||||
5447 | /* Claim that something changed even if the permission change failed. | |||
5448 | * This makes it easier for some clients who see the "reverting" | |||
5449 | * to the old permissions as "changing back". | |||
5450 | */ | |||
5451 | baul_file_changed (file); | |||
5452 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_PERMISSION_DENIED, | |||
5453 | _("Not allowed to set permissions")gettext ("Not allowed to set permissions")); | |||
5454 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
5455 | g_error_free (error); | |||
5456 | return; | |||
5457 | } | |||
5458 | ||||
5459 | /* Test the permissions-haven't-changed case explicitly | |||
5460 | * because we don't want to send the file-changed signal if | |||
5461 | * nothing changed. | |||
5462 | */ | |||
5463 | if (new_permissions == file->details->permissions) { | |||
5464 | (* callback) (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
5465 | return; | |||
5466 | } | |||
5467 | ||||
5468 | // Start UNDO-REDO | |||
5469 | if (!baul_undostack_manager_is_undo_redo(baul_undostack_manager_instance())) { | |||
5470 | BaulUndoStackActionData* undo_redo_data = baul_undostack_manager_data_new (BAUL_UNDOSTACK_SETPERMISSIONS, 1); | |||
5471 | baul_undostack_manager_data_set_file_permissions(undo_redo_data, baul_file_get_uri(file), file->details->permissions, new_permissions); | |||
5472 | baul_undostack_manager_add_action (baul_undostack_manager_instance(), | |||
5473 | undo_redo_data); | |||
5474 | } | |||
5475 | // End UNDO-REDO | |||
5476 | ||||
5477 | info = g_file_info_new (); | |||
5478 | g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE"unix::mode", new_permissions); | |||
5479 | baul_file_set_attributes (file, info, callback, callback_data); | |||
5480 | g_object_unref (info); | |||
5481 | } | |||
5482 | ||||
5483 | /** | |||
5484 | * baul_file_can_get_selinux_context: | |||
5485 | * | |||
5486 | * Check whether the selinux context for a file are determinable. | |||
5487 | * This might not be the case for files on non-UNIX file systems, | |||
5488 | * files without a context or systems that don't support selinux. | |||
5489 | * | |||
5490 | * @file: The file in question. | |||
5491 | * | |||
5492 | * Return value: TRUE if the permissions are valid. | |||
5493 | */ | |||
5494 | gboolean | |||
5495 | baul_file_can_get_selinux_context (BaulFile *file) | |||
5496 | { | |||
5497 | return file->details->selinux_context != NULL((void*)0); | |||
5498 | } | |||
5499 | ||||
5500 | ||||
5501 | /** | |||
5502 | * baul_file_get_selinux_context: | |||
5503 | * | |||
5504 | * Get a user-displayable string representing a file's selinux | |||
5505 | * context | |||
5506 | * @file: BaulFile representing the file in question. | |||
5507 | * | |||
5508 | * Returns: Newly allocated string ready to display to the user. | |||
5509 | * | |||
5510 | **/ | |||
5511 | char * | |||
5512 | baul_file_get_selinux_context (BaulFile *file) | |||
5513 | { | |||
5514 | char *translated; | |||
5515 | char *raw; | |||
5516 | ||||
5517 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
5518 | ||||
5519 | if (!baul_file_can_get_selinux_context (file)) { | |||
5520 | return NULL((void*)0); | |||
5521 | } | |||
5522 | ||||
5523 | raw = file->details->selinux_context; | |||
5524 | ||||
5525 | #ifdef HAVE_SELINUX1 | |||
5526 | if (selinux_raw_to_trans_context (raw, &translated) == 0) { | |||
5527 | char *tmp; | |||
5528 | tmp = g_strdup (translated); | |||
5529 | freecon (translated); | |||
5530 | translated = tmp; | |||
5531 | } | |||
5532 | else | |||
5533 | #endif | |||
5534 | { | |||
5535 | translated = g_strdup (raw); | |||
5536 | } | |||
5537 | ||||
5538 | return translated; | |||
5539 | } | |||
5540 | ||||
5541 | static char * | |||
5542 | get_real_name (const char *name, const char *gecos) | |||
5543 | { | |||
5544 | char *locale_string, *part_before_comma, *capitalized_login_name, *real_name; | |||
5545 | ||||
5546 | if (gecos == NULL((void*)0)) { | |||
5547 | return NULL((void*)0); | |||
5548 | } | |||
5549 | ||||
5550 | locale_string = eel_str_strip_substring_and_after (gecos, ","); | |||
5551 | if (!g_utf8_validate (locale_string, -1, NULL((void*)0))) { | |||
5552 | part_before_comma = g_locale_to_utf8 (locale_string, -1, NULL((void*)0), NULL((void*)0), NULL((void*)0)); | |||
5553 | g_free (locale_string); | |||
5554 | } else { | |||
5555 | part_before_comma = locale_string; | |||
5556 | } | |||
5557 | ||||
5558 | if (!g_utf8_validate (name, -1, NULL((void*)0))) { | |||
5559 | locale_string = g_locale_to_utf8 (name, -1, NULL((void*)0), NULL((void*)0), NULL((void*)0)); | |||
5560 | } else { | |||
5561 | locale_string = g_strdup (name); | |||
5562 | } | |||
5563 | ||||
5564 | capitalized_login_name = eel_str_capitalize (locale_string); | |||
5565 | g_free (locale_string); | |||
5566 | ||||
5567 | if (capitalized_login_name == NULL((void*)0)) { | |||
5568 | real_name = part_before_comma; | |||
5569 | } else { | |||
5570 | real_name = eel_str_replace_substring | |||
5571 | (part_before_comma, "&", capitalized_login_name); | |||
5572 | g_free (part_before_comma); | |||
5573 | } | |||
5574 | ||||
5575 | ||||
5576 | if (eel_str_is_empty (real_name) | |||
5577 | || eel_strcmp (name, real_name) == 0 | |||
5578 | || eel_strcmp (capitalized_login_name, real_name) == 0) { | |||
5579 | g_free (real_name); | |||
5580 | real_name = NULL((void*)0); | |||
5581 | } | |||
5582 | ||||
5583 | g_free (capitalized_login_name); | |||
5584 | ||||
5585 | return real_name; | |||
5586 | } | |||
5587 | ||||
5588 | static gboolean | |||
5589 | get_group_id_from_group_name (const char *group_name, uid_t *gid) | |||
5590 | { | |||
5591 | struct group *group; | |||
5592 | ||||
5593 | g_assert (gid != NULL)do { if (gid != ((void*)0)) ; else g_assertion_message_expr ( ((gchar*) 0), "baul-file.c", 5593, ((const char*) (__func__)) , "gid != NULL"); } while (0); | |||
5594 | ||||
5595 | group = getgrnam (group_name); | |||
5596 | ||||
5597 | if (group == NULL((void*)0)) { | |||
5598 | return FALSE(0); | |||
5599 | } | |||
5600 | ||||
5601 | *gid = group->gr_gid; | |||
5602 | ||||
5603 | return TRUE(!(0)); | |||
5604 | } | |||
5605 | ||||
5606 | static gboolean | |||
5607 | get_ids_from_user_name (const char *user_name, uid_t *uid, uid_t *gid) | |||
5608 | { | |||
5609 | struct passwd *password_info; | |||
5610 | ||||
5611 | g_assert (uid != NULL || gid != NULL)do { if (uid != ((void*)0) || gid != ((void*)0)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 5611, ((const char*) (__func__ )), "uid != NULL || gid != NULL"); } while (0); | |||
5612 | ||||
5613 | password_info = getpwnam (user_name); | |||
5614 | ||||
5615 | if (password_info == NULL((void*)0)) { | |||
5616 | return FALSE(0); | |||
5617 | } | |||
5618 | ||||
5619 | if (uid != NULL((void*)0)) { | |||
5620 | *uid = password_info->pw_uid; | |||
5621 | } | |||
5622 | ||||
5623 | if (gid != NULL((void*)0)) { | |||
5624 | *gid = password_info->pw_gid; | |||
5625 | } | |||
5626 | ||||
5627 | return TRUE(!(0)); | |||
5628 | } | |||
5629 | ||||
5630 | static gboolean | |||
5631 | get_user_id_from_user_name (const char *user_name, uid_t *id) | |||
5632 | { | |||
5633 | return get_ids_from_user_name (user_name, id, NULL((void*)0)); | |||
5634 | } | |||
5635 | ||||
5636 | static gboolean | |||
5637 | get_id_from_digit_string (const char *digit_string, uid_t *id) | |||
5638 | { | |||
5639 | long scanned_id; | |||
5640 | char c; | |||
5641 | ||||
5642 | g_assert (id != NULL)do { if (id != ((void*)0)) ; else g_assertion_message_expr (( (gchar*) 0), "baul-file.c", 5642, ((const char*) (__func__)), "id != NULL"); } while (0); | |||
5643 | ||||
5644 | /* Only accept string if it has one integer with nothing | |||
5645 | * afterwards. | |||
5646 | */ | |||
5647 | if (sscanf (digit_string, "%ld%c", &scanned_id, &c) != 1) { | |||
5648 | return FALSE(0); | |||
5649 | } | |||
5650 | *id = scanned_id; | |||
5651 | return TRUE(!(0)); | |||
5652 | } | |||
5653 | ||||
5654 | /** | |||
5655 | * baul_file_can_get_owner: | |||
5656 | * | |||
5657 | * Check whether the owner a file is determinable. | |||
5658 | * This might not be the case for files on non-UNIX file systems. | |||
5659 | * | |||
5660 | * @file: The file in question. | |||
5661 | * | |||
5662 | * Return value: TRUE if the owner is valid. | |||
5663 | */ | |||
5664 | gboolean | |||
5665 | baul_file_can_get_owner (BaulFile *file) | |||
5666 | { | |||
5667 | /* Before we have info on a file, the owner is unknown. */ | |||
5668 | return file->details->uid != -1; | |||
5669 | } | |||
5670 | ||||
5671 | /** | |||
5672 | * baul_file_get_owner_name: | |||
5673 | * | |||
5674 | * Get the user name of the file's owner. If the owner has no | |||
5675 | * name, returns the userid as a string. The caller is responsible | |||
5676 | * for g_free-ing this string. | |||
5677 | * | |||
5678 | * @file: The file in question. | |||
5679 | * | |||
5680 | * Return value: A newly-allocated string. | |||
5681 | */ | |||
5682 | char * | |||
5683 | baul_file_get_owner_name (BaulFile *file) | |||
5684 | { | |||
5685 | return baul_file_get_owner_as_string (file, FALSE(0)); | |||
5686 | } | |||
5687 | ||||
5688 | /** | |||
5689 | * baul_file_can_set_owner: | |||
5690 | * | |||
5691 | * Check whether the current user is allowed to change | |||
5692 | * the owner of a file. | |||
5693 | * | |||
5694 | * @file: The file in question. | |||
5695 | * | |||
5696 | * Return value: TRUE if the current user can change the | |||
5697 | * owner of @file, FALSE otherwise. It's always possible | |||
5698 | * that when you actually try to do it, you will fail. | |||
5699 | */ | |||
5700 | gboolean | |||
5701 | baul_file_can_set_owner (BaulFile *file) | |||
5702 | { | |||
5703 | /* Not allowed to set the owner if we can't | |||
5704 | * even read it. This can happen on non-UNIX file | |||
5705 | * systems. | |||
5706 | */ | |||
5707 | if (!baul_file_can_get_owner (file)) { | |||
5708 | return FALSE(0); | |||
5709 | } | |||
5710 | ||||
5711 | /* Only root is also allowed to set the owner. */ | |||
5712 | return geteuid() == 0; | |||
5713 | } | |||
5714 | ||||
5715 | /** | |||
5716 | * baul_file_set_owner: | |||
5717 | * | |||
5718 | * Set the owner of a file. This will only have any effect if | |||
5719 | * baul_file_can_set_owner returns TRUE. | |||
5720 | * | |||
5721 | * @file: The file in question. | |||
5722 | * @user_name_or_id: The user name to set the owner to. | |||
5723 | * If the string does not match any user name, and the | |||
5724 | * string is an integer, the owner will be set to the | |||
5725 | * userid represented by that integer. | |||
5726 | * @callback: Function called when asynch owner change succeeds or fails. | |||
5727 | * @callback_data: Parameter passed back with callback function. | |||
5728 | */ | |||
5729 | void | |||
5730 | baul_file_set_owner (BaulFile *file, | |||
5731 | const char *user_name_or_id, | |||
5732 | BaulFileOperationCallback callback, | |||
5733 | gpointer callback_data) | |||
5734 | { | |||
5735 | GError *error; | |||
5736 | GFileInfo *info; | |||
5737 | uid_t new_id; | |||
5738 | ||||
5739 | if (!baul_file_can_set_owner (file)) { | |||
5740 | /* Claim that something changed even if the permission | |||
5741 | * change failed. This makes it easier for some | |||
5742 | * clients who see the "reverting" to the old owner as | |||
5743 | * "changing back". | |||
5744 | */ | |||
5745 | baul_file_changed (file); | |||
5746 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_PERMISSION_DENIED, | |||
5747 | _("Not allowed to set owner")gettext ("Not allowed to set owner")); | |||
5748 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
5749 | g_error_free (error); | |||
5750 | return; | |||
5751 | } | |||
5752 | ||||
5753 | /* If no match treating user_name_or_id as name, try treating | |||
5754 | * it as id. | |||
5755 | */ | |||
5756 | if (!get_user_id_from_user_name (user_name_or_id, &new_id) | |||
5757 | && !get_id_from_digit_string (user_name_or_id, &new_id)) { | |||
5758 | /* Claim that something changed even if the permission | |||
5759 | * change failed. This makes it easier for some | |||
5760 | * clients who see the "reverting" to the old owner as | |||
5761 | * "changing back". | |||
5762 | */ | |||
5763 | baul_file_changed (file); | |||
5764 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_INVALID_ARGUMENT, | |||
5765 | _("Specified owner '%s' doesn't exist")gettext ("Specified owner '%s' doesn't exist"), user_name_or_id); | |||
5766 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
5767 | g_error_free (error); | |||
5768 | return; | |||
5769 | } | |||
5770 | ||||
5771 | /* Test the owner-hasn't-changed case explicitly because we | |||
5772 | * don't want to send the file-changed signal if nothing | |||
5773 | * changed. | |||
5774 | */ | |||
5775 | if (new_id == (uid_t) file->details->uid) { | |||
5776 | (* callback) (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
5777 | return; | |||
5778 | } | |||
5779 | ||||
5780 | // Start UNDO-REDO | |||
5781 | if (!baul_undostack_manager_is_undo_redo(baul_undostack_manager_instance())) { | |||
5782 | char* current_owner = baul_file_get_owner_as_string (file, FALSE(0)); | |||
5783 | BaulUndoStackActionData* undo_redo_data = baul_undostack_manager_data_new (BAUL_UNDOSTACK_CHANGEOWNER, 1); | |||
5784 | baul_undostack_manager_data_set_owner_change_information(undo_redo_data, baul_file_get_uri(file), current_owner, user_name_or_id); | |||
5785 | baul_undostack_manager_add_action (baul_undostack_manager_instance(), | |||
5786 | undo_redo_data); | |||
5787 | g_free(current_owner); | |||
5788 | } | |||
5789 | // End UNDO-REDO | |||
5790 | ||||
5791 | info = g_file_info_new (); | |||
5792 | g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID"unix::uid", new_id); | |||
5793 | baul_file_set_attributes (file, info, callback, callback_data); | |||
5794 | g_object_unref (info); | |||
5795 | } | |||
5796 | ||||
5797 | /** | |||
5798 | * baul_get_user_names: | |||
5799 | * | |||
5800 | * Get a list of user names. For users with a different associated | |||
5801 | * "real name", the real name follows the standard user name, separated | |||
5802 | * by a carriage return. The caller is responsible for freeing this list | |||
5803 | * and its contents. | |||
5804 | */ | |||
5805 | GList * | |||
5806 | baul_get_user_names (void) | |||
5807 | { | |||
5808 | GList *list; | |||
5809 | char *name; | |||
5810 | struct passwd *user; | |||
5811 | ||||
5812 | list = NULL((void*)0); | |||
5813 | ||||
5814 | setpwent (); | |||
5815 | ||||
5816 | while ((user = getpwent ()) != NULL((void*)0)) { | |||
5817 | char *real_name; | |||
5818 | ||||
5819 | real_name = get_real_name (user->pw_name, user->pw_gecos); | |||
5820 | if (real_name != NULL((void*)0)) { | |||
5821 | name = g_strconcat (user->pw_name, "\n", real_name, NULL((void*)0)); | |||
5822 | } else { | |||
5823 | name = g_strdup (user->pw_name); | |||
5824 | } | |||
5825 | g_free (real_name); | |||
5826 | list = g_list_prepend (list, name); | |||
5827 | } | |||
5828 | ||||
5829 | endpwent (); | |||
5830 | ||||
5831 | return eel_g_str_list_alphabetize (list); | |||
5832 | } | |||
5833 | ||||
5834 | /** | |||
5835 | * baul_file_can_get_group: | |||
5836 | * | |||
5837 | * Check whether the group a file is determinable. | |||
5838 | * This might not be the case for files on non-UNIX file systems. | |||
5839 | * | |||
5840 | * @file: The file in question. | |||
5841 | * | |||
5842 | * Return value: TRUE if the group is valid. | |||
5843 | */ | |||
5844 | gboolean | |||
5845 | baul_file_can_get_group (BaulFile *file) | |||
5846 | { | |||
5847 | /* Before we have info on a file, the group is unknown. */ | |||
5848 | return file->details->gid != -1; | |||
5849 | } | |||
5850 | ||||
5851 | /** | |||
5852 | * baul_file_get_group_name: | |||
5853 | * | |||
5854 | * Get the name of the file's group. If the group has no | |||
5855 | * name, returns the groupid as a string. The caller is responsible | |||
5856 | * for g_free-ing this string. | |||
5857 | * | |||
5858 | * @file: The file in question. | |||
5859 | * | |||
5860 | * Return value: A newly-allocated string. | |||
5861 | **/ | |||
5862 | char * | |||
5863 | baul_file_get_group_name (BaulFile *file) | |||
5864 | { | |||
5865 | return g_strdup (file->details->group); | |||
5866 | } | |||
5867 | ||||
5868 | /** | |||
5869 | * baul_file_can_set_group: | |||
5870 | * | |||
5871 | * Check whether the current user is allowed to change | |||
5872 | * the group of a file. | |||
5873 | * | |||
5874 | * @file: The file in question. | |||
5875 | * | |||
5876 | * Return value: TRUE if the current user can change the | |||
5877 | * group of @file, FALSE otherwise. It's always possible | |||
5878 | * that when you actually try to do it, you will fail. | |||
5879 | */ | |||
5880 | gboolean | |||
5881 | baul_file_can_set_group (BaulFile *file) | |||
5882 | { | |||
5883 | uid_t user_id; | |||
5884 | ||||
5885 | /* Not allowed to set the permissions if we can't | |||
5886 | * even read them. This can happen on non-UNIX file | |||
5887 | * systems. | |||
5888 | */ | |||
5889 | if (!baul_file_can_get_group (file)) { | |||
5890 | return FALSE(0); | |||
5891 | } | |||
5892 | ||||
5893 | /* Check the user. */ | |||
5894 | user_id = geteuid(); | |||
5895 | ||||
5896 | /* Owner is allowed to set group (with restrictions). */ | |||
5897 | if (user_id == (uid_t) file->details->uid) { | |||
5898 | return TRUE(!(0)); | |||
5899 | } | |||
5900 | ||||
5901 | /* Root is also allowed to set group. */ | |||
5902 | if (user_id == 0) { | |||
5903 | return TRUE(!(0)); | |||
5904 | } | |||
5905 | ||||
5906 | /* Nobody else is allowed. */ | |||
5907 | return FALSE(0); | |||
5908 | } | |||
5909 | ||||
5910 | /* Get a list of group names, filtered to only the ones | |||
5911 | * that contain the given username. If the username is | |||
5912 | * NULL, returns a list of all group names. | |||
5913 | */ | |||
5914 | static GList * | |||
5915 | baul_get_group_names_for_user (void) | |||
5916 | { | |||
5917 | GList *list; | |||
5918 | int count, i; | |||
5919 | gid_t gid_list[NGROUPS_MAX65536 + 1]; | |||
5920 | struct group *group = NULL((void*)0); | |||
5921 | ||||
5922 | ||||
5923 | list = NULL((void*)0); | |||
5924 | ||||
5925 | count = getgroups (NGROUPS_MAX65536 + 1, gid_list); | |||
5926 | for (i = 0; i < count; i++) { | |||
5927 | group = getgrgid (gid_list[i]); | |||
5928 | if (group == NULL((void*)0)) | |||
5929 | break; | |||
5930 | ||||
5931 | list = g_list_prepend (list, g_strdup (group->gr_name)); | |||
5932 | } | |||
5933 | ||||
5934 | return eel_g_str_list_alphabetize (list); | |||
5935 | } | |||
5936 | ||||
5937 | /** | |||
5938 | * baul_get_group_names: | |||
5939 | * | |||
5940 | * Get a list of all group names. | |||
5941 | */ | |||
5942 | GList * | |||
5943 | baul_get_all_group_names (void) | |||
5944 | { | |||
5945 | GList *list; | |||
5946 | struct group *group; | |||
5947 | ||||
5948 | list = NULL((void*)0); | |||
5949 | ||||
5950 | setgrent (); | |||
5951 | ||||
5952 | while ((group = getgrent ()) != NULL((void*)0)) | |||
5953 | list = g_list_prepend (list, g_strdup (group->gr_name)); | |||
5954 | ||||
5955 | endgrent (); | |||
5956 | ||||
5957 | return eel_g_str_list_alphabetize (list); | |||
5958 | } | |||
5959 | ||||
5960 | /** | |||
5961 | * baul_file_get_settable_group_names: | |||
5962 | * | |||
5963 | * Get a list of all group names that the current user | |||
5964 | * can set the group of a specific file to. | |||
5965 | * | |||
5966 | * @file: The BaulFile in question. | |||
5967 | */ | |||
5968 | GList * | |||
5969 | baul_file_get_settable_group_names (BaulFile *file) | |||
5970 | { | |||
5971 | uid_t user_id; | |||
5972 | GList *result; | |||
5973 | ||||
5974 | if (!baul_file_can_set_group (file)) { | |||
5975 | return NULL((void*)0); | |||
5976 | } | |||
5977 | ||||
5978 | /* Check the user. */ | |||
5979 | user_id = geteuid(); | |||
5980 | ||||
5981 | if (user_id == 0) { | |||
5982 | /* Root is allowed to set group to anything. */ | |||
5983 | result = baul_get_all_group_names (); | |||
5984 | } else if (user_id == (uid_t) file->details->uid) { | |||
5985 | /* Owner is allowed to set group to any that owner is member of. */ | |||
5986 | result = baul_get_group_names_for_user (); | |||
5987 | } else { | |||
5988 | g_warning ("unhandled case in baul_get_settable_group_names"); | |||
5989 | result = NULL((void*)0); | |||
5990 | } | |||
5991 | ||||
5992 | return result; | |||
5993 | } | |||
5994 | ||||
5995 | /** | |||
5996 | * baul_file_set_group: | |||
5997 | * | |||
5998 | * Set the group of a file. This will only have any effect if | |||
5999 | * baul_file_can_set_group returns TRUE. | |||
6000 | * | |||
6001 | * @file: The file in question. | |||
6002 | * @group_name_or_id: The group name to set the owner to. | |||
6003 | * If the string does not match any group name, and the | |||
6004 | * string is an integer, the group will be set to the | |||
6005 | * group id represented by that integer. | |||
6006 | * @callback: Function called when asynch group change succeeds or fails. | |||
6007 | * @callback_data: Parameter passed back with callback function. | |||
6008 | */ | |||
6009 | void | |||
6010 | baul_file_set_group (BaulFile *file, | |||
6011 | const char *group_name_or_id, | |||
6012 | BaulFileOperationCallback callback, | |||
6013 | gpointer callback_data) | |||
6014 | { | |||
6015 | GError *error; | |||
6016 | GFileInfo *info; | |||
6017 | uid_t new_id; | |||
6018 | ||||
6019 | if (!baul_file_can_set_group (file)) { | |||
6020 | /* Claim that something changed even if the group | |||
6021 | * change failed. This makes it easier for some | |||
6022 | * clients who see the "reverting" to the old group as | |||
6023 | * "changing back". | |||
6024 | */ | |||
6025 | baul_file_changed (file); | |||
6026 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_PERMISSION_DENIED, | |||
6027 | _("Not allowed to set group")gettext ("Not allowed to set group")); | |||
6028 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
6029 | g_error_free (error); | |||
6030 | return; | |||
6031 | } | |||
6032 | ||||
6033 | /* If no match treating group_name_or_id as name, try treating | |||
6034 | * it as id. | |||
6035 | */ | |||
6036 | if (!get_group_id_from_group_name (group_name_or_id, &new_id) | |||
6037 | && !get_id_from_digit_string (group_name_or_id, &new_id)) { | |||
6038 | /* Claim that something changed even if the group | |||
6039 | * change failed. This makes it easier for some | |||
6040 | * clients who see the "reverting" to the old group as | |||
6041 | * "changing back". | |||
6042 | */ | |||
6043 | baul_file_changed (file); | |||
6044 | error = g_error_new (G_IO_ERRORg_io_error_quark(), G_IO_ERROR_INVALID_ARGUMENT, | |||
6045 | _("Specified group '%s' doesn't exist")gettext ("Specified group '%s' doesn't exist"), group_name_or_id); | |||
6046 | (* callback) (file, NULL((void*)0), error, callback_data); | |||
6047 | g_error_free (error); | |||
6048 | return; | |||
6049 | } | |||
6050 | ||||
6051 | if (new_id == (gid_t) file->details->gid) { | |||
6052 | (* callback) (file, NULL((void*)0), NULL((void*)0), callback_data); | |||
6053 | return; | |||
6054 | } | |||
6055 | ||||
6056 | // Start UNDO-REDO | |||
6057 | if (!baul_undostack_manager_is_undo_redo(baul_undostack_manager_instance())) { | |||
6058 | char* current_group = baul_file_get_group_name (file); | |||
6059 | BaulUndoStackActionData* undo_redo_data = baul_undostack_manager_data_new (BAUL_UNDOSTACK_CHANGEGROUP, 1); | |||
6060 | baul_undostack_manager_data_set_group_change_information(undo_redo_data, baul_file_get_uri(file), current_group, group_name_or_id); | |||
6061 | baul_undostack_manager_add_action (baul_undostack_manager_instance(), | |||
6062 | undo_redo_data); | |||
6063 | g_free(current_group); | |||
6064 | } | |||
6065 | // End UNDO-REDO | |||
6066 | ||||
6067 | info = g_file_info_new (); | |||
6068 | g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_GID"unix::gid", new_id); | |||
6069 | baul_file_set_attributes (file, info, callback, callback_data); | |||
6070 | g_object_unref (info); | |||
6071 | } | |||
6072 | ||||
6073 | /** | |||
6074 | * baul_file_get_octal_permissions_as_string: | |||
6075 | * | |||
6076 | * Get a user-displayable string representing a file's permissions | |||
6077 | * as an octal number. The caller | |||
6078 | * is responsible for g_free-ing this string. | |||
6079 | * @file: BaulFile representing the file in question. | |||
6080 | * | |||
6081 | * Returns: Newly allocated string ready to display to the user. | |||
6082 | * | |||
6083 | **/ | |||
6084 | static char * | |||
6085 | baul_file_get_octal_permissions_as_string (BaulFile *file) | |||
6086 | { | |||
6087 | guint32 permissions; | |||
6088 | ||||
6089 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6089, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
6090 | ||||
6091 | if (!baul_file_can_get_permissions (file)) { | |||
6092 | return NULL((void*)0); | |||
6093 | } | |||
6094 | ||||
6095 | permissions = file->details->permissions; | |||
6096 | return g_strdup_printf ("%03o", permissions); | |||
6097 | } | |||
6098 | ||||
6099 | /** | |||
6100 | * baul_file_get_permissions_as_string: | |||
6101 | * | |||
6102 | * Get a user-displayable string representing a file's permissions. The caller | |||
6103 | * is responsible for g_free-ing this string. | |||
6104 | * @file: BaulFile representing the file in question. | |||
6105 | * | |||
6106 | * Returns: Newly allocated string ready to display to the user. | |||
6107 | * | |||
6108 | **/ | |||
6109 | static char * | |||
6110 | baul_file_get_permissions_as_string (BaulFile *file) | |||
6111 | { | |||
6112 | guint32 permissions; | |||
6113 | gboolean is_directory; | |||
6114 | gboolean is_link; | |||
6115 | gboolean suid, sgid, sticky; | |||
6116 | ||||
6117 | if (!baul_file_can_get_permissions (file)) { | |||
6118 | return NULL((void*)0); | |||
6119 | } | |||
6120 | ||||
6121 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6121, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
6122 | ||||
6123 | permissions = file->details->permissions; | |||
6124 | is_directory = baul_file_is_directory (file); | |||
6125 | is_link = baul_file_is_symbolic_link (file); | |||
6126 | ||||
6127 | /* We use ls conventions for displaying these three obscure flags */ | |||
6128 | suid = permissions & S_ISUID04000; | |||
6129 | sgid = permissions & S_ISGID02000; | |||
6130 | sticky = permissions & S_ISVTX01000; | |||
6131 | ||||
6132 | return g_strdup_printf ("%c%c%c%c%c%c%c%c%c%c", | |||
6133 | is_link ? 'l' : is_directory ? 'd' : '-', | |||
6134 | permissions & S_IRUSR0400 ? 'r' : '-', | |||
6135 | permissions & S_IWUSR0200 ? 'w' : '-', | |||
6136 | permissions & S_IXUSR0100 | |||
6137 | ? (suid ? 's' : 'x') | |||
6138 | : (suid ? 'S' : '-'), | |||
6139 | permissions & S_IRGRP(0400 >> 3) ? 'r' : '-', | |||
6140 | permissions & S_IWGRP(0200 >> 3) ? 'w' : '-', | |||
6141 | permissions & S_IXGRP(0100 >> 3) | |||
6142 | ? (sgid ? 's' : 'x') | |||
6143 | : (sgid ? 'S' : '-'), | |||
6144 | permissions & S_IROTH((0400 >> 3) >> 3) ? 'r' : '-', | |||
6145 | permissions & S_IWOTH((0200 >> 3) >> 3) ? 'w' : '-', | |||
6146 | permissions & S_IXOTH((0100 >> 3) >> 3) | |||
6147 | ? (sticky ? 't' : 'x') | |||
6148 | : (sticky ? 'T' : '-')); | |||
6149 | } | |||
6150 | ||||
6151 | /** | |||
6152 | * baul_file_get_owner_as_string: | |||
6153 | * | |||
6154 | * Get a user-displayable string representing a file's owner. The caller | |||
6155 | * is responsible for g_free-ing this string. | |||
6156 | * @file: BaulFile representing the file in question. | |||
6157 | * @include_real_name: Whether or not to append the real name (if any) | |||
6158 | * for this user after the user name. | |||
6159 | * | |||
6160 | * Returns: Newly allocated string ready to display to the user. | |||
6161 | * | |||
6162 | **/ | |||
6163 | static char * | |||
6164 | baul_file_get_owner_as_string (BaulFile *file, gboolean include_real_name) | |||
6165 | { | |||
6166 | char *user_name; | |||
6167 | ||||
6168 | /* Before we have info on a file, the owner is unknown. */ | |||
6169 | if (file->details->owner == NULL((void*)0) && | |||
6170 | file->details->owner_real == NULL((void*)0)) { | |||
6171 | return NULL((void*)0); | |||
6172 | } | |||
6173 | ||||
6174 | if (file->details->owner_real == NULL((void*)0)) { | |||
6175 | user_name = g_strdup (file->details->owner); | |||
6176 | } else if (file->details->owner == NULL((void*)0)) { | |||
6177 | user_name = g_strdup (file->details->owner_real); | |||
6178 | } else if (include_real_name && | |||
6179 | strcmp (file->details->owner, file->details->owner_real) != 0) { | |||
6180 | user_name = g_strdup_printf ("%s - %s", | |||
6181 | file->details->owner, | |||
6182 | file->details->owner_real); | |||
6183 | } else { | |||
6184 | user_name = g_strdup (file->details->owner); | |||
6185 | } | |||
6186 | ||||
6187 | return user_name; | |||
6188 | } | |||
6189 | ||||
6190 | static char * | |||
6191 | format_item_count_for_display (guint item_count, | |||
6192 | gboolean includes_directories, | |||
6193 | gboolean includes_files) | |||
6194 | { | |||
6195 | g_assert (includes_directories || includes_files)do { if (includes_directories || includes_files) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6195, ((const char*) (__func__ )), "includes_directories || includes_files"); } while (0); | |||
6196 | ||||
6197 | return g_strdup_printf (includes_directories | |||
6198 | ? (includes_files | |||
6199 | ? ngettext ("%'u item", "%'u items", item_count) | |||
6200 | : ngettext ("%'u folder", "%'u folders", item_count)) | |||
6201 | : ngettext ("%'u file", "%'u files", item_count), item_count); | |||
6202 | } | |||
6203 | ||||
6204 | /** | |||
6205 | * baul_file_get_size_as_string: | |||
6206 | * | |||
6207 | * Get a user-displayable string representing a file size. The caller | |||
6208 | * is responsible for g_free-ing this string. The string is an item | |||
6209 | * count for directories. | |||
6210 | * @file: BaulFile representing the file in question. | |||
6211 | * @size_on_disk: If TRUE will return the size on disk. If FALSE return file size. | |||
6212 | * | |||
6213 | * Returns: Newly allocated string ready to display to the user. | |||
6214 | * | |||
6215 | **/ | |||
6216 | static char * | |||
6217 | baul_file_get_size_as_string (BaulFile *file, | |||
6218 | gboolean size_on_disk) | |||
6219 | { | |||
6220 | guint item_count; | |||
6221 | gboolean count_unreadable; | |||
6222 | goffset size; | |||
6223 | ||||
6224 | if (file == NULL((void*)0)) { | |||
6225 | return NULL((void*)0); | |||
6226 | } | |||
6227 | ||||
6228 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6228, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
6229 | ||||
6230 | if (baul_file_is_directory (file)) { | |||
6231 | if (!baul_file_get_directory_item_count (file, &item_count, &count_unreadable)) { | |||
6232 | return NULL((void*)0); | |||
6233 | } | |||
6234 | return format_item_count_for_display (item_count, TRUE(!(0)), TRUE(!(0))); | |||
6235 | } | |||
6236 | ||||
6237 | if (size_on_disk) { | |||
6238 | size = file->details->size_on_disk; | |||
6239 | } else { | |||
6240 | size = file->details->size; | |||
6241 | } | |||
6242 | ||||
6243 | if (size == -1) { | |||
6244 | return NULL((void*)0); | |||
6245 | } | |||
6246 | ||||
6247 | if (g_settings_get_boolean (baul_preferences, BAUL_PREFERENCES_USE_IEC_UNITS"use-iec-units")) | |||
6248 | return g_format_size_full (size, G_FORMAT_SIZE_IEC_UNITS); | |||
6249 | else | |||
6250 | return g_format_size (size); | |||
6251 | } | |||
6252 | ||||
6253 | /** | |||
6254 | * baul_file_get_size_as_string_with_real_size: | |||
6255 | * | |||
6256 | * Get a user-displayable string representing a file size. The caller | |||
6257 | * is responsible for g_free-ing this string. The string is an item | |||
6258 | * count for directories. | |||
6259 | * This function adds the real size in the string. | |||
6260 | * @file: BaulFile representing the file in question. | |||
6261 | * | |||
6262 | * Returns: Newly allocated string ready to display to the user. | |||
6263 | * | |||
6264 | **/ | |||
6265 | static char * | |||
6266 | baul_file_get_size_as_string_with_real_size (BaulFile *file, | |||
6267 | gboolean size_on_disk) | |||
6268 | { | |||
6269 | guint item_count; | |||
6270 | gboolean count_unreadable; | |||
6271 | goffset size; | |||
6272 | char * formatted; | |||
6273 | char * formatted_plus_real; | |||
6274 | char * real_size; | |||
6275 | ||||
6276 | if (file == NULL((void*)0)) { | |||
6277 | return NULL((void*)0); | |||
6278 | } | |||
6279 | ||||
6280 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6280, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
6281 | ||||
6282 | if (baul_file_is_directory (file)) { | |||
6283 | if (!baul_file_get_directory_item_count (file, &item_count, &count_unreadable)) { | |||
6284 | return NULL((void*)0); | |||
6285 | } | |||
6286 | return format_item_count_for_display (item_count, TRUE(!(0)), TRUE(!(0))); | |||
6287 | } | |||
6288 | ||||
6289 | if (size_on_disk) { | |||
6290 | size = file->details->size_on_disk; | |||
6291 | } else { | |||
6292 | size = file->details->size; | |||
6293 | } | |||
6294 | ||||
6295 | if (size == -1) { | |||
6296 | return NULL((void*)0); | |||
6297 | } | |||
6298 | ||||
6299 | if (g_settings_get_boolean (baul_preferences, BAUL_PREFERENCES_USE_IEC_UNITS"use-iec-units")) | |||
6300 | formatted = g_format_size_full (size, G_FORMAT_SIZE_IEC_UNITS); | |||
6301 | else | |||
6302 | formatted = g_format_size(size); | |||
6303 | ||||
6304 | /* Do this in a separate stage so that we don't have to put G_GUINT64_FORMAT in the translated string */ | |||
6305 | real_size = g_strdup_printf (_("%"G_GUINT64_FORMAT)gettext ("%""lu"), (guint64) size); | |||
6306 | formatted_plus_real = g_strdup_printf (_("%s (%s bytes)")gettext ("%s (%s bytes)"), formatted, real_size); | |||
6307 | g_free (real_size); | |||
6308 | g_free (formatted); | |||
6309 | return formatted_plus_real; | |||
6310 | } | |||
6311 | ||||
6312 | static char * | |||
6313 | baul_file_get_deep_count_as_string_internal (BaulFile *file, | |||
6314 | gboolean report_size, | |||
6315 | gboolean report_size_on_disk, | |||
6316 | gboolean report_directory_count, | |||
6317 | gboolean report_file_count) | |||
6318 | { | |||
6319 | BaulRequestStatus status; | |||
6320 | guint directory_count; | |||
6321 | guint file_count; | |||
6322 | guint unreadable_count; | |||
6323 | guint total_count; | |||
6324 | goffset total_size; | |||
6325 | goffset total_size_on_disk; | |||
6326 | ||||
6327 | /* Can't ask for more than one of those: size, size on disk or (directory and/or file count) */ | |||
6328 | g_assert (!(report_size && report_size_on_disk))do { if (!(report_size && report_size_on_disk)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6328, ((const char*) (__func__)), "!(report_size && report_size_on_disk)" ); } while (0); | |||
6329 | g_assert (!(report_size && (report_directory_count || report_file_count)))do { if (!(report_size && (report_directory_count || report_file_count ))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c" , 6329, ((const char*) (__func__)), "!(report_size && (report_directory_count || report_file_count))" ); } while (0); | |||
6330 | g_assert (!(report_size_on_disk && (report_directory_count || report_file_count)))do { if (!(report_size_on_disk && (report_directory_count || report_file_count))) ; else g_assertion_message_expr (((gchar *) 0), "baul-file.c", 6330, ((const char*) (__func__)), "!(report_size_on_disk && (report_directory_count || report_file_count))" ); } while (0); | |||
6331 | ||||
6332 | /* Must ask for something */ | |||
6333 | g_assert (report_size || report_size_on_disk || report_directory_count || report_file_count)do { if (report_size || report_size_on_disk || report_directory_count || report_file_count) ; else g_assertion_message_expr (((gchar *) 0), "baul-file.c", 6333, ((const char*) (__func__)), "report_size || report_size_on_disk || report_directory_count || report_file_count" ); } while (0); | |||
6334 | ||||
6335 | if (file == NULL((void*)0)) { | |||
6336 | return NULL((void*)0); | |||
6337 | } | |||
6338 | ||||
6339 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6339, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
6340 | g_assert (baul_file_is_directory (file))do { if (baul_file_is_directory (file)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6340, ((const char*) (__func__ )), "baul_file_is_directory (file)"); } while (0); | |||
6341 | ||||
6342 | status = baul_file_get_deep_counts (file, | |||
6343 | &directory_count, | |||
6344 | &file_count, | |||
6345 | &unreadable_count, | |||
6346 | &total_size, | |||
6347 | &total_size_on_disk, | |||
6348 | FALSE(0)); | |||
6349 | ||||
6350 | /* Check whether any info is available. */ | |||
6351 | if (status == BAUL_REQUEST_NOT_STARTED) { | |||
6352 | return NULL((void*)0); | |||
6353 | } | |||
6354 | ||||
6355 | total_count = file_count + directory_count; | |||
6356 | ||||
6357 | if (total_count == 0) { | |||
6358 | switch (status) { | |||
6359 | case BAUL_REQUEST_IN_PROGRESS: | |||
6360 | /* Don't return confident "zero" until we're finished looking, | |||
6361 | * because of next case. | |||
6362 | */ | |||
6363 | return NULL((void*)0); | |||
6364 | case BAUL_REQUEST_DONE: | |||
6365 | /* Don't return "zero" if we there were contents but we couldn't read them. */ | |||
6366 | if (unreadable_count != 0) { | |||
6367 | return NULL((void*)0); | |||
6368 | } | |||
6369 | default: break; | |||
6370 | } | |||
6371 | } | |||
6372 | ||||
6373 | /* Note that we don't distinguish the "everything was readable" case | |||
6374 | * from the "some things but not everything was readable" case here. | |||
6375 | * Callers can distinguish them using baul_file_get_deep_counts | |||
6376 | * directly if desired. | |||
6377 | */ | |||
6378 | if (report_size) | |||
6379 | { | |||
6380 | if (g_settings_get_boolean (baul_preferences, BAUL_PREFERENCES_USE_IEC_UNITS"use-iec-units")) | |||
6381 | return g_format_size_full (total_size, G_FORMAT_SIZE_IEC_UNITS); | |||
6382 | else | |||
6383 | return g_format_size(total_size); | |||
6384 | } | |||
6385 | ||||
6386 | if (report_size_on_disk) | |||
6387 | { | |||
6388 | if (g_settings_get_boolean (baul_preferences, BAUL_PREFERENCES_USE_IEC_UNITS"use-iec-units")) | |||
6389 | return g_format_size_full (total_size_on_disk, G_FORMAT_SIZE_IEC_UNITS); | |||
6390 | else | |||
6391 | return g_format_size (total_size_on_disk); | |||
6392 | } | |||
6393 | ||||
6394 | return format_item_count_for_display (report_directory_count | |||
6395 | ? (report_file_count ? total_count : directory_count) | |||
6396 | : file_count, | |||
6397 | report_directory_count, report_file_count); | |||
6398 | } | |||
6399 | ||||
6400 | /** | |||
6401 | * baul_file_get_deep_size_as_string: | |||
6402 | * | |||
6403 | * Get a user-displayable string representing the size of all contained | |||
6404 | * items (only makes sense for directories). The caller | |||
6405 | * is responsible for g_free-ing this string. | |||
6406 | * @file: BaulFile representing the file in question. | |||
6407 | * @size_on_disk: if TRUE will return the size on disk, else return size of file. | |||
6408 | * | |||
6409 | * Returns: Newly allocated string ready to display to the user. | |||
6410 | * | |||
6411 | **/ | |||
6412 | static char * | |||
6413 | baul_file_get_deep_size_as_string (BaulFile *file, gboolean size_on_disk) | |||
6414 | { | |||
6415 | if (size_on_disk) { | |||
6416 | return baul_file_get_deep_count_as_string_internal (file, FALSE(0), TRUE(!(0)), FALSE(0), FALSE(0)); | |||
6417 | } else { | |||
6418 | return baul_file_get_deep_count_as_string_internal (file, TRUE(!(0)), FALSE(0), FALSE(0), FALSE(0)); | |||
6419 | } | |||
6420 | } | |||
6421 | ||||
6422 | /** | |||
6423 | * baul_file_get_deep_total_count_as_string: | |||
6424 | * | |||
6425 | * Get a user-displayable string representing the count of all contained | |||
6426 | * items (only makes sense for directories). The caller | |||
6427 | * is responsible for g_free-ing this string. | |||
6428 | * @file: BaulFile representing the file in question. | |||
6429 | * | |||
6430 | * Returns: Newly allocated string ready to display to the user. | |||
6431 | * | |||
6432 | **/ | |||
6433 | static char * | |||
6434 | baul_file_get_deep_total_count_as_string (BaulFile *file) | |||
6435 | { | |||
6436 | return baul_file_get_deep_count_as_string_internal (file, FALSE(0), FALSE(0), TRUE(!(0)), TRUE(!(0))); | |||
6437 | } | |||
6438 | ||||
6439 | /** | |||
6440 | * baul_file_get_deep_file_count_as_string: | |||
6441 | * | |||
6442 | * Get a user-displayable string representing the count of all contained | |||
6443 | * items, not including directories. It only makes sense to call this | |||
6444 | * function on a directory. The caller | |||
6445 | * is responsible for g_free-ing this string. | |||
6446 | * @file: BaulFile representing the file in question. | |||
6447 | * | |||
6448 | * Returns: Newly allocated string ready to display to the user. | |||
6449 | * | |||
6450 | **/ | |||
6451 | static char * | |||
6452 | baul_file_get_deep_file_count_as_string (BaulFile *file) | |||
6453 | { | |||
6454 | return baul_file_get_deep_count_as_string_internal (file, FALSE(0), FALSE(0), FALSE(0), TRUE(!(0))); | |||
6455 | } | |||
6456 | ||||
6457 | /** | |||
6458 | * baul_file_get_deep_directory_count_as_string: | |||
6459 | * | |||
6460 | * Get a user-displayable string representing the count of all contained | |||
6461 | * directories. It only makes sense to call this | |||
6462 | * function on a directory. The caller | |||
6463 | * is responsible for g_free-ing this string. | |||
6464 | * @file: BaulFile representing the file in question. | |||
6465 | * | |||
6466 | * Returns: Newly allocated string ready to display to the user. | |||
6467 | * | |||
6468 | **/ | |||
6469 | static char * | |||
6470 | baul_file_get_deep_directory_count_as_string (BaulFile *file) | |||
6471 | { | |||
6472 | return baul_file_get_deep_count_as_string_internal (file, FALSE(0), FALSE(0), TRUE(!(0)), FALSE(0)); | |||
6473 | } | |||
6474 | ||||
6475 | /** | |||
6476 | * baul_file_get_string_attribute: | |||
6477 | * | |||
6478 | * Get a user-displayable string from a named attribute. Use g_free to | |||
6479 | * free this string. If the value is unknown, returns NULL. You can call | |||
6480 | * baul_file_get_string_attribute_with_default if you want a non-NULL | |||
6481 | * default. | |||
6482 | * | |||
6483 | * @file: BaulFile representing the file in question. | |||
6484 | * @attribute_name: The name of the desired attribute. The currently supported | |||
6485 | * set includes "name", "type", "mime_type", "size", "size_on_disk", "deep_size", "deep_size_on_disk", | |||
6486 | * "deep_directory_count", "deep_file_count", "deep_total_count", "date_modified", "date_changed", | |||
6487 | * "date_accessed", "date_permissions", "owner", "group", "permissions", "octal_permissions", "uri", "where", | |||
6488 | * "link_target", "volume", "free_space", "selinux_context", "trashed_on", "trashed_orig_path" | |||
6489 | * | |||
6490 | * Returns: Newly allocated string ready to display to the user, or NULL | |||
6491 | * if the value is unknown or @attribute_name is not supported. | |||
6492 | * | |||
6493 | **/ | |||
6494 | char * | |||
6495 | baul_file_get_string_attribute_q (BaulFile *file, GQuark attribute_q) | |||
6496 | { | |||
6497 | char *extension_attribute; | |||
6498 | ||||
6499 | if (attribute_q == attribute_name_q) { | |||
6500 | return baul_file_get_display_name (file); | |||
6501 | } | |||
6502 | if (attribute_q == attribute_type_q) { | |||
6503 | return baul_file_get_type_as_string (file); | |||
6504 | } | |||
6505 | if (attribute_q == attribute_mime_type_q) { | |||
6506 | return baul_file_get_mime_type (file); | |||
6507 | } | |||
6508 | if (attribute_q == attribute_size_q) { | |||
6509 | return baul_file_get_size_as_string (file, FALSE(0)); | |||
6510 | } | |||
6511 | if (attribute_q == attribute_size_on_disk_q) { | |||
6512 | return baul_file_get_size_as_string (file, TRUE(!(0))); | |||
6513 | } | |||
6514 | if (attribute_q == attribute_size_detail_q) { | |||
6515 | return baul_file_get_size_as_string_with_real_size (file, FALSE(0)); | |||
6516 | } | |||
6517 | if (attribute_q == attribute_size_on_disk_detail_q) { | |||
6518 | return baul_file_get_size_as_string_with_real_size (file, TRUE(!(0))); | |||
6519 | } | |||
6520 | if (attribute_q == attribute_deep_size_q) { | |||
6521 | return baul_file_get_deep_size_as_string (file, FALSE(0)); | |||
6522 | } | |||
6523 | if (attribute_q == attribute_deep_size_on_disk_q) { | |||
6524 | return baul_file_get_deep_size_as_string (file, TRUE(!(0))); | |||
6525 | } | |||
6526 | if (attribute_q == attribute_deep_file_count_q) { | |||
6527 | return baul_file_get_deep_file_count_as_string (file); | |||
6528 | } | |||
6529 | if (attribute_q == attribute_deep_directory_count_q) { | |||
6530 | return baul_file_get_deep_directory_count_as_string (file); | |||
6531 | } | |||
6532 | if (attribute_q == attribute_deep_total_count_q) { | |||
6533 | return baul_file_get_deep_total_count_as_string (file); | |||
6534 | } | |||
6535 | if (attribute_q == attribute_trash_orig_path_q) { | |||
6536 | return baul_file_get_trash_original_file_parent_as_string (file); | |||
6537 | } | |||
6538 | if (attribute_q == attribute_date_modified_q) { | |||
6539 | return baul_file_get_date_as_string (file, | |||
6540 | BAUL_DATE_TYPE_MODIFIED); | |||
6541 | } | |||
6542 | if (attribute_q == attribute_date_changed_q) { | |||
6543 | return baul_file_get_date_as_string (file, | |||
6544 | BAUL_DATE_TYPE_CHANGED); | |||
6545 | } | |||
6546 | if (attribute_q == attribute_date_accessed_q) { | |||
6547 | return baul_file_get_date_as_string (file, | |||
6548 | BAUL_DATE_TYPE_ACCESSED); | |||
6549 | } | |||
6550 | if (attribute_q == attribute_trashed_on_q) { | |||
6551 | return baul_file_get_date_as_string (file, | |||
6552 | BAUL_DATE_TYPE_TRASHED); | |||
6553 | } | |||
6554 | if (attribute_q == attribute_date_permissions_q) { | |||
6555 | return baul_file_get_date_as_string (file, | |||
6556 | BAUL_DATE_TYPE_PERMISSIONS_CHANGED); | |||
6557 | } | |||
6558 | if (attribute_q == attribute_extension_q) { | |||
6559 | return baul_file_get_extension_as_string (file); | |||
6560 | } | |||
6561 | if (attribute_q == attribute_permissions_q) { | |||
6562 | return baul_file_get_permissions_as_string (file); | |||
6563 | } | |||
6564 | if (attribute_q == attribute_selinux_context_q) { | |||
6565 | return baul_file_get_selinux_context (file); | |||
6566 | } | |||
6567 | if (attribute_q == attribute_octal_permissions_q) { | |||
6568 | return baul_file_get_octal_permissions_as_string (file); | |||
6569 | } | |||
6570 | if (attribute_q == attribute_owner_q) { | |||
6571 | return baul_file_get_owner_as_string (file, TRUE(!(0))); | |||
6572 | } | |||
6573 | if (attribute_q == attribute_group_q) { | |||
6574 | return baul_file_get_group_name (file); | |||
6575 | } | |||
6576 | if (attribute_q == attribute_uri_q) { | |||
6577 | return baul_file_get_uri (file); | |||
6578 | } | |||
6579 | if (attribute_q == attribute_where_q) { | |||
6580 | return baul_file_get_where_string (file); | |||
6581 | } | |||
6582 | if (attribute_q == attribute_link_target_q) { | |||
6583 | return baul_file_get_symbolic_link_target_path (file); | |||
6584 | } | |||
6585 | if (attribute_q == attribute_volume_q) { | |||
6586 | return baul_file_get_volume_name (file); | |||
6587 | } | |||
6588 | if (attribute_q == attribute_free_space_q) { | |||
6589 | return baul_file_get_volume_free_space (file); | |||
6590 | } | |||
6591 | ||||
6592 | extension_attribute = NULL((void*)0); | |||
6593 | ||||
6594 | if (file->details->pending_extension_attributes) { | |||
6595 | extension_attribute = g_hash_table_lookup (file->details->pending_extension_attributes, | |||
6596 | GINT_TO_POINTER (attribute_q)((gpointer) (glong) (attribute_q))); | |||
6597 | } | |||
6598 | ||||
6599 | if (extension_attribute == NULL((void*)0) && file->details->extension_attributes) { | |||
6600 | extension_attribute = g_hash_table_lookup (file->details->extension_attributes, | |||
6601 | GINT_TO_POINTER (attribute_q)((gpointer) (glong) (attribute_q))); | |||
6602 | } | |||
6603 | ||||
6604 | return g_strdup (extension_attribute); | |||
6605 | } | |||
6606 | ||||
6607 | char * | |||
6608 | baul_file_get_string_attribute (BaulFile *file, const char *attribute_name) | |||
6609 | { | |||
6610 | return baul_file_get_string_attribute_q (file, g_quark_from_string (attribute_name)); | |||
6611 | } | |||
6612 | ||||
6613 | ||||
6614 | /** | |||
6615 | * baul_file_get_string_attribute_with_default: | |||
6616 | * | |||
6617 | * Get a user-displayable string from a named attribute. Use g_free to | |||
6618 | * free this string. If the value is unknown, returns a string representing | |||
6619 | * the unknown value, which varies with attribute. You can call | |||
6620 | * baul_file_get_string_attribute if you want NULL instead of a default | |||
6621 | * result. | |||
6622 | * | |||
6623 | * @file: BaulFile representing the file in question. | |||
6624 | * @attribute_name: The name of the desired attribute. See the description of | |||
6625 | * baul_file_get_string for the set of available attributes. | |||
6626 | * | |||
6627 | * Returns: Newly allocated string ready to display to the user, or a string | |||
6628 | * such as "unknown" if the value is unknown or @attribute_name is not supported. | |||
6629 | * | |||
6630 | **/ | |||
6631 | char * | |||
6632 | baul_file_get_string_attribute_with_default_q (BaulFile *file, GQuark attribute_q) | |||
6633 | { | |||
6634 | char *result; | |||
6635 | guint item_count; | |||
6636 | gboolean count_unreadable; | |||
6637 | BaulRequestStatus status; | |||
6638 | ||||
6639 | result = baul_file_get_string_attribute_q (file, attribute_q); | |||
6640 | if (result != NULL((void*)0)) { | |||
6641 | return result; | |||
6642 | } | |||
6643 | ||||
6644 | /* Supply default values for the ones we know about. */ | |||
6645 | /* FIXME bugzilla.gnome.org 40646: | |||
6646 | * Use hash table and switch statement or function pointers for speed? | |||
6647 | */ | |||
6648 | if (attribute_q == attribute_size_q) { | |||
6649 | if (!baul_file_should_show_directory_item_count (file)) { | |||
6650 | return g_strdup ("--"); | |||
6651 | } | |||
6652 | count_unreadable = FALSE(0); | |||
6653 | if (baul_file_is_directory (file)) { | |||
6654 | baul_file_get_directory_item_count (file, &item_count, &count_unreadable); | |||
6655 | } | |||
6656 | return g_strdup (count_unreadable ? _("? items")gettext ("? items") : "..."); | |||
6657 | } | |||
6658 | if (attribute_q == attribute_deep_size_q) { | |||
6659 | status = baul_file_get_deep_counts (file, NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), FALSE(0)); | |||
6660 | if (status == BAUL_REQUEST_DONE) { | |||
6661 | /* This means no contents at all were readable */ | |||
6662 | return g_strdup (_("? bytes")gettext ("? bytes")); | |||
6663 | } | |||
6664 | return g_strdup ("..."); | |||
6665 | } | |||
6666 | if (attribute_q == attribute_deep_size_on_disk_q) { | |||
6667 | status = baul_file_get_deep_counts (file, NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), FALSE(0)); | |||
6668 | if (status == BAUL_REQUEST_DONE) { | |||
6669 | /* This means no contents at all were readable */ | |||
6670 | return g_strdup (_("? bytes")gettext ("? bytes")); | |||
6671 | } | |||
6672 | return g_strdup ("..."); | |||
6673 | } | |||
6674 | if (attribute_q == attribute_deep_file_count_q | |||
6675 | || attribute_q == attribute_deep_directory_count_q | |||
6676 | || attribute_q == attribute_deep_total_count_q) { | |||
6677 | status = baul_file_get_deep_counts (file, NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), FALSE(0)); | |||
6678 | if (status == BAUL_REQUEST_DONE) { | |||
6679 | /* This means no contents at all were readable */ | |||
6680 | return g_strdup (_("? items")gettext ("? items")); | |||
6681 | } | |||
6682 | return g_strdup ("..."); | |||
6683 | } | |||
6684 | if (attribute_q == attribute_type_q) { | |||
6685 | return g_strdup (_("unknown type")gettext ("unknown type")); | |||
6686 | } | |||
6687 | if (attribute_q == attribute_mime_type_q) { | |||
6688 | return g_strdup (_("unknown MIME type")gettext ("unknown MIME type")); | |||
6689 | } | |||
6690 | if (attribute_q == attribute_trashed_on_q) { | |||
6691 | /* If n/a */ | |||
6692 | return g_strdup (""); | |||
6693 | } | |||
6694 | if (attribute_q == attribute_trash_orig_path_q) { | |||
6695 | /* If n/a */ | |||
6696 | return g_strdup (""); | |||
6697 | } | |||
6698 | ||||
6699 | /* Fallback, use for both unknown attributes and attributes | |||
6700 | * for which we have no more appropriate default. | |||
6701 | */ | |||
6702 | return g_strdup (_("unknown")gettext ("unknown")); | |||
6703 | } | |||
6704 | ||||
6705 | char * | |||
6706 | baul_file_get_string_attribute_with_default (BaulFile *file, const char *attribute_name) | |||
6707 | { | |||
6708 | return baul_file_get_string_attribute_with_default_q (file, g_quark_from_string (attribute_name)); | |||
6709 | } | |||
6710 | ||||
6711 | gboolean | |||
6712 | baul_file_is_date_sort_attribute_q (GQuark attribute_q) | |||
6713 | { | |||
6714 | if (attribute_q == attribute_modification_date_q || | |||
6715 | attribute_q == attribute_date_modified_q || | |||
6716 | attribute_q == attribute_accessed_date_q || | |||
6717 | attribute_q == attribute_date_accessed_q || | |||
6718 | attribute_q == attribute_date_changed_q || | |||
6719 | attribute_q == attribute_trashed_on_q || | |||
6720 | attribute_q == attribute_date_permissions_q) { | |||
6721 | return TRUE(!(0)); | |||
6722 | } | |||
6723 | ||||
6724 | return FALSE(0); | |||
6725 | } | |||
6726 | ||||
6727 | /** | |||
6728 | * get_description: | |||
6729 | * | |||
6730 | * Get a user-displayable string representing a file type. The caller | |||
6731 | * is responsible for g_free-ing this string. | |||
6732 | * @file: BaulFile representing the file in question. | |||
6733 | * | |||
6734 | * Returns: Newly allocated string ready to display to the user. | |||
6735 | * | |||
6736 | **/ | |||
6737 | static char * | |||
6738 | get_description (BaulFile *file) | |||
6739 | { | |||
6740 | const char *mime_type; | |||
6741 | char *description; | |||
6742 | ||||
6743 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6743, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
6744 | ||||
6745 | mime_type = file->details->mime_type; | |||
6746 | if (eel_str_is_empty (mime_type)) { | |||
6747 | return NULL((void*)0); | |||
6748 | } | |||
6749 | ||||
6750 | if (g_content_type_is_unknown (mime_type) && | |||
6751 | baul_file_is_executable (file)) { | |||
6752 | return g_strdup (_("program")gettext ("program")); | |||
6753 | } | |||
6754 | ||||
6755 | description = g_content_type_get_description (mime_type); | |||
6756 | if (!eel_str_is_empty (description)) { | |||
6757 | return description; | |||
6758 | } | |||
6759 | ||||
6760 | return g_strdup (mime_type); | |||
6761 | } | |||
6762 | ||||
6763 | /* Takes ownership of string */ | |||
6764 | static char * | |||
6765 | update_description_for_link (BaulFile *file, char *string) | |||
6766 | { | |||
6767 | if (baul_file_is_symbolic_link (file)) { | |||
6768 | char *res; | |||
6769 | ||||
6770 | g_assert (!baul_file_is_broken_symbolic_link (file))do { if (!baul_file_is_broken_symbolic_link (file)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 6770, ((const char*) (__func__ )), "!baul_file_is_broken_symbolic_link (file)"); } while (0); | |||
6771 | if (string == NULL((void*)0)) { | |||
6772 | return g_strdup (_("link")gettext ("link")); | |||
6773 | } | |||
6774 | /* Note to localizers: convert file type string for file | |||
6775 | * (e.g. "folder", "plain text") to file type for symbolic link | |||
6776 | * to that kind of file (e.g. "link to folder"). | |||
6777 | */ | |||
6778 | res = g_strdup_printf (_("Link to %s")gettext ("Link to %s"), string); | |||
6779 | g_free (string); | |||
6780 | return res; | |||
6781 | } | |||
6782 | ||||
6783 | return string; | |||
6784 | } | |||
6785 | ||||
6786 | static char * | |||
6787 | baul_file_get_type_as_string (BaulFile *file) | |||
6788 | { | |||
6789 | if (file == NULL((void*)0)) { | |||
6790 | return NULL((void*)0); | |||
6791 | } | |||
6792 | ||||
6793 | if (baul_file_is_broken_symbolic_link (file)) { | |||
6794 | return g_strdup (_("link (broken)")gettext ("link (broken)")); | |||
6795 | } | |||
6796 | ||||
6797 | return update_description_for_link (file, get_description (file)); | |||
6798 | } | |||
6799 | ||||
6800 | /** | |||
6801 | * baul_file_get_file_type | |||
6802 | * | |||
6803 | * Return this file's type. | |||
6804 | * @file: BaulFile representing the file in question. | |||
6805 | * | |||
6806 | * Returns: The type. | |||
6807 | * | |||
6808 | **/ | |||
6809 | GFileType | |||
6810 | baul_file_get_file_type (BaulFile *file) | |||
6811 | { | |||
6812 | if (file == NULL((void*)0)) { | |||
6813 | return G_FILE_TYPE_UNKNOWN; | |||
6814 | } | |||
6815 | ||||
6816 | return file->details->type; | |||
6817 | } | |||
6818 | ||||
6819 | /** | |||
6820 | * baul_file_get_mime_type | |||
6821 | * | |||
6822 | * Return this file's default mime type. | |||
6823 | * @file: BaulFile representing the file in question. | |||
6824 | * | |||
6825 | * Returns: The mime type. | |||
6826 | * | |||
6827 | **/ | |||
6828 | char * | |||
6829 | baul_file_get_mime_type (BaulFile *file) | |||
6830 | { | |||
6831 | if (file != NULL((void*)0)) { | |||
6832 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
6833 | if (file->details->mime_type != NULL((void*)0)) { | |||
6834 | return g_strdup (file->details->mime_type); | |||
6835 | } | |||
6836 | } | |||
6837 | return g_strdup ("application/octet-stream"); | |||
6838 | } | |||
6839 | ||||
6840 | /** | |||
6841 | * baul_file_is_mime_type | |||
6842 | * | |||
6843 | * Check whether a file is of a particular MIME type, or inherited | |||
6844 | * from it. | |||
6845 | * @file: BaulFile representing the file in question. | |||
6846 | * @mime_type: The MIME-type string to test (e.g. "text/plain") | |||
6847 | * | |||
6848 | * Return value: TRUE if @mime_type exactly matches the | |||
6849 | * file's MIME type. | |||
6850 | * | |||
6851 | **/ | |||
6852 | gboolean | |||
6853 | baul_file_is_mime_type (BaulFile *file, const char *mime_type) | |||
6854 | { | |||
6855 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
6856 | g_return_val_if_fail (mime_type != NULL, FALSE)do { if ((mime_type != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "mime_type != NULL" ); return ((0)); } } while (0); | |||
6857 | ||||
6858 | if (file->details->mime_type == NULL((void*)0)) { | |||
6859 | return FALSE(0); | |||
6860 | } | |||
6861 | return g_content_type_is_a (file->details->mime_type, | |||
6862 | mime_type); | |||
6863 | } | |||
6864 | ||||
6865 | gboolean | |||
6866 | baul_file_is_launchable (BaulFile *file) | |||
6867 | { | |||
6868 | gboolean type_can_be_executable; | |||
6869 | ||||
6870 | type_can_be_executable = FALSE(0); | |||
6871 | if (file->details->mime_type != NULL((void*)0)) { | |||
6872 | type_can_be_executable = | |||
6873 | g_content_type_can_be_executable (file->details->mime_type); | |||
6874 | } | |||
6875 | ||||
6876 | return type_can_be_executable && | |||
6877 | baul_file_can_get_permissions (file) && | |||
6878 | baul_file_can_execute (file) && | |||
6879 | baul_file_is_executable (file) && | |||
6880 | !baul_file_is_directory (file); | |||
6881 | } | |||
6882 | ||||
6883 | ||||
6884 | /** | |||
6885 | * baul_file_get_emblem_icons | |||
6886 | * | |||
6887 | * Return the list of names of emblems that this file should display, | |||
6888 | * in canonical order. | |||
6889 | * @file: BaulFile representing the file in question. | |||
6890 | * | |||
6891 | * Returns: A list of emblem names. | |||
6892 | * | |||
6893 | **/ | |||
6894 | GList * | |||
6895 | baul_file_get_emblem_icons (BaulFile *file, | |||
6896 | char **exclude) | |||
6897 | { | |||
6898 | GList *keywords, *l; | |||
6899 | GList *icons; | |||
6900 | char *icon_names[2]; | |||
6901 | char *keyword; | |||
6902 | int i; | |||
6903 | GIcon *icon; | |||
6904 | ||||
6905 | if (file == NULL((void*)0)) { | |||
6906 | return NULL((void*)0); | |||
6907 | } | |||
6908 | ||||
6909 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
6910 | ||||
6911 | keywords = baul_file_get_keywords (file); | |||
6912 | keywords = prepend_automatic_keywords (file, keywords); | |||
6913 | ||||
6914 | icons = NULL((void*)0); | |||
6915 | for (l = keywords; l != NULL((void*)0); l = l->next) { | |||
6916 | keyword = l->data; | |||
6917 | ||||
6918 | #ifdef TRASH_IS_FAST_ENOUGH | |||
6919 | if (strcmp (keyword, BAUL_FILE_EMBLEM_NAME_TRASH"trash") == 0) { | |||
6920 | char *uri; | |||
6921 | gboolean file_is_trash; | |||
6922 | /* Leave out the trash emblem for the trash itself, since | |||
6923 | * putting a trash emblem on a trash icon is gilding the | |||
6924 | * lily. | |||
6925 | */ | |||
6926 | uri = baul_file_get_uri (file); | |||
6927 | file_is_trash = strcmp (uri, EEL_TRASH_URI"trash:") == 0; | |||
6928 | g_free (uri); | |||
6929 | if (file_is_trash) { | |||
6930 | continue; | |||
6931 | } | |||
6932 | } | |||
6933 | #endif | |||
6934 | if (exclude) { | |||
6935 | for (i = 0; exclude[i] != NULL((void*)0); i++) { | |||
6936 | if (strcmp (exclude[i], keyword) == 0) { | |||
6937 | continue; | |||
6938 | } | |||
6939 | } | |||
6940 | } | |||
6941 | ||||
6942 | ||||
6943 | icon_names[0] = g_strconcat ("emblem-", keyword, NULL((void*)0)); | |||
6944 | icon_names[1] = keyword; | |||
6945 | icon = g_themed_icon_new_from_names (icon_names, 2); | |||
6946 | g_free (icon_names[0]); | |||
6947 | ||||
6948 | icons = g_list_prepend (icons, icon); | |||
6949 | } | |||
6950 | ||||
6951 | g_list_free_full (keywords, g_free); | |||
6952 | ||||
6953 | return icons; | |||
6954 | } | |||
6955 | ||||
6956 | GList * | |||
6957 | baul_file_get_emblem_pixbufs (BaulFile *file, | |||
6958 | int size, | |||
6959 | gboolean force_size, | |||
6960 | char **exclude) | |||
6961 | { | |||
6962 | GList *icons, *l; | |||
6963 | GList *pixbufs; | |||
6964 | GdkPixbuf *pixbuf; | |||
6965 | GIcon *icon = NULL((void*)0); | |||
6966 | BaulIconInfo *icon_info = NULL((void*)0); | |||
6967 | ||||
6968 | icons = baul_file_get_emblem_icons (file, exclude); | |||
6969 | pixbufs = NULL((void*)0); | |||
6970 | ||||
6971 | for (l = icons; l != NULL((void*)0); l = l->next) { | |||
6972 | icon = l->data; | |||
6973 | ||||
6974 | icon_info = baul_icon_info_lookup (icon, size, 1); | |||
6975 | if (force_size) { | |||
6976 | pixbuf = baul_icon_info_get_pixbuf_nodefault_at_size (icon_info, size); | |||
6977 | } else { | |||
6978 | pixbuf = baul_icon_info_get_pixbuf_nodefault (icon_info); | |||
6979 | } | |||
6980 | ||||
6981 | if (pixbuf) { | |||
6982 | pixbufs = g_list_prepend (pixbufs, pixbuf); | |||
6983 | } | |||
6984 | ||||
6985 | ||||
6986 | g_object_unref (icon_info); | |||
6987 | g_object_unref (icon); | |||
6988 | } | |||
6989 | g_list_free (icons); | |||
6990 | ||||
6991 | return g_list_reverse (pixbufs); | |||
6992 | ||||
6993 | ||||
6994 | } | |||
6995 | ||||
6996 | static GList * | |||
6997 | sort_keyword_list_and_remove_duplicates (GList *keywords) | |||
6998 | { | |||
6999 | GList *p; | |||
7000 | ||||
7001 | if (keywords != NULL((void*)0)) { | |||
7002 | GList *duplicate_link = NULL((void*)0); | |||
7003 | ||||
7004 | keywords = eel_g_str_list_alphabetize (keywords); | |||
7005 | ||||
7006 | p = keywords; | |||
7007 | while (p->next != NULL((void*)0)) { | |||
7008 | if (strcmp ((const char *) p->data, (const char *) p->next->data) == 0) { | |||
7009 | duplicate_link = p->next; | |||
7010 | keywords = g_list_remove_link (keywords, duplicate_link); | |||
7011 | g_list_free_full (duplicate_link, g_free); | |||
7012 | } else { | |||
7013 | p = p->next; | |||
7014 | } | |||
7015 | } | |||
7016 | } | |||
7017 | ||||
7018 | return keywords; | |||
7019 | } | |||
7020 | ||||
7021 | /** | |||
7022 | * baul_file_get_keywords | |||
7023 | * | |||
7024 | * Return this file's keywords. | |||
7025 | * @file: BaulFile representing the file in question. | |||
7026 | * | |||
7027 | * Returns: A list of keywords. | |||
7028 | * | |||
7029 | **/ | |||
7030 | GList * | |||
7031 | baul_file_get_keywords (BaulFile *file) | |||
7032 | { | |||
7033 | GList *keywords; | |||
7034 | ||||
7035 | if (file == NULL((void*)0)) { | |||
7036 | return NULL((void*)0); | |||
7037 | } | |||
7038 | ||||
7039 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
7040 | ||||
7041 | /* Put all the keywords into a list. */ | |||
7042 | keywords = baul_file_get_metadata_list | |||
7043 | (file, BAUL_METADATA_KEY_EMBLEMS"emblems"); | |||
7044 | ||||
7045 | keywords = g_list_concat (keywords, g_list_copy_deep (file->details->extension_emblems, (GCopyFunc) g_strdup, NULL((void*)0))); | |||
7046 | keywords = g_list_concat (keywords, g_list_copy_deep (file->details->pending_extension_emblems, (GCopyFunc) g_strdup, NULL((void*)0))); | |||
7047 | ||||
7048 | return sort_keyword_list_and_remove_duplicates (keywords); | |||
7049 | } | |||
7050 | ||||
7051 | /** | |||
7052 | * baul_file_set_keywords | |||
7053 | * | |||
7054 | * Change this file's keywords. | |||
7055 | * @file: BaulFile representing the file in question. | |||
7056 | * @keywords: New set of keywords (a GList of strings). | |||
7057 | * | |||
7058 | **/ | |||
7059 | void | |||
7060 | baul_file_set_keywords (BaulFile *file, GList *keywords) | |||
7061 | { | |||
7062 | GList *canonical_keywords; | |||
7063 | ||||
7064 | /* Invalidate the emblem compare cache */ | |||
7065 | g_free (file->details->compare_by_emblem_cache); | |||
7066 | file->details->compare_by_emblem_cache = NULL((void*)0); | |||
7067 | ||||
7068 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
7069 | ||||
7070 | canonical_keywords = sort_keyword_list_and_remove_duplicates | |||
7071 | (g_list_copy (keywords)); | |||
7072 | baul_file_set_metadata_list | |||
7073 | (file, BAUL_METADATA_KEY_EMBLEMS"emblems", canonical_keywords); | |||
7074 | g_list_free (canonical_keywords); | |||
7075 | } | |||
7076 | ||||
7077 | /** | |||
7078 | * baul_file_is_symbolic_link | |||
7079 | * | |||
7080 | * Check if this file is a symbolic link. | |||
7081 | * @file: BaulFile representing the file in question. | |||
7082 | * | |||
7083 | * Returns: True if the file is a symbolic link. | |||
7084 | * | |||
7085 | **/ | |||
7086 | gboolean | |||
7087 | baul_file_is_symbolic_link (BaulFile *file) | |||
7088 | { | |||
7089 | return file->details->is_symlink; | |||
7090 | } | |||
7091 | ||||
7092 | gboolean | |||
7093 | baul_file_is_mountpoint (BaulFile *file) | |||
7094 | { | |||
7095 | return file->details->is_mountpoint; | |||
7096 | } | |||
7097 | ||||
7098 | GMount * | |||
7099 | baul_file_get_mount (BaulFile *file) | |||
7100 | { | |||
7101 | if (file->details->mount) { | |||
7102 | return g_object_ref (file->details->mount)((__typeof__ (file->details->mount)) (g_object_ref) (file ->details->mount)); | |||
7103 | } | |||
7104 | return NULL((void*)0); | |||
7105 | } | |||
7106 | ||||
7107 | static void | |||
7108 | file_mount_unmounted (GMount *mount, | |||
7109 | gpointer data) | |||
7110 | { | |||
7111 | BaulFile *file; | |||
7112 | ||||
7113 | file = BAUL_FILE (data)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((data)), (baul_file_get_type()))))); | |||
7114 | ||||
7115 | baul_file_invalidate_attributes (file, BAUL_FILE_ATTRIBUTE_MOUNT); | |||
7116 | } | |||
7117 | ||||
7118 | void | |||
7119 | baul_file_set_mount (BaulFile *file, | |||
7120 | GMount *mount) | |||
7121 | { | |||
7122 | if (file->details->mount) { | |||
7123 | g_signal_handlers_disconnect_by_func (file->details->mount, file_mount_unmounted, file)g_signal_handlers_disconnect_matched ((file->details->mount ), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA ), 0, 0, ((void*)0), (file_mount_unmounted), (file)); | |||
7124 | g_object_unref (file->details->mount); | |||
7125 | file->details->mount = NULL((void*)0); | |||
7126 | } | |||
7127 | ||||
7128 | if (mount) { | |||
7129 | file->details->mount = g_object_ref (mount)((__typeof__ (mount)) (g_object_ref) (mount)); | |||
7130 | g_signal_connect (mount, "unmounted",g_signal_connect_data ((mount), ("unmounted"), (((GCallback) ( file_mount_unmounted))), (file), ((void*)0), (GConnectFlags) 0 ) | |||
7131 | G_CALLBACK (file_mount_unmounted), file)g_signal_connect_data ((mount), ("unmounted"), (((GCallback) ( file_mount_unmounted))), (file), ((void*)0), (GConnectFlags) 0 ); | |||
7132 | } | |||
7133 | } | |||
7134 | ||||
7135 | /** | |||
7136 | * baul_file_is_broken_symbolic_link | |||
7137 | * | |||
7138 | * Check if this file is a symbolic link with a missing target. | |||
7139 | * @file: BaulFile representing the file in question. | |||
7140 | * | |||
7141 | * Returns: True if the file is a symbolic link with a missing target. | |||
7142 | * | |||
7143 | **/ | |||
7144 | gboolean | |||
7145 | baul_file_is_broken_symbolic_link (BaulFile *file) | |||
7146 | { | |||
7147 | if (file == NULL((void*)0)) { | |||
7148 | return FALSE(0); | |||
7149 | } | |||
7150 | ||||
7151 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
7152 | ||||
7153 | /* Non-broken symbolic links return the target's type for get_file_type. */ | |||
7154 | return baul_file_get_file_type (file) == G_FILE_TYPE_SYMBOLIC_LINK; | |||
7155 | } | |||
7156 | ||||
7157 | static void | |||
7158 | get_fs_free_cb (GObject *source_object, | |||
7159 | GAsyncResult *res, | |||
7160 | gpointer user_data) | |||
7161 | { | |||
7162 | BaulDirectory *directory; | |||
7163 | guint64 free_space; | |||
7164 | GFileInfo *info; | |||
7165 | ||||
7166 | directory = BAUL_DIRECTORY (user_data)((((BaulDirectory*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((user_data)), (baul_directory_get_type()))))); | |||
7167 | ||||
7168 | free_space = (guint64)-1; | |||
7169 | info = g_file_query_filesystem_info_finish (G_FILE (source_object)((((GFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((source_object)), ((g_file_get_type ())))))), | |||
7170 | res, NULL((void*)0)); | |||
7171 | if (info) { | |||
7172 | if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE"filesystem::free")) { | |||
7173 | free_space = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE"filesystem::free"); | |||
7174 | } | |||
7175 | g_object_unref (info); | |||
7176 | } | |||
7177 | ||||
7178 | if (directory->details->free_space != free_space) { | |||
7179 | BaulFile *file; | |||
7180 | ||||
7181 | directory->details->free_space = free_space; | |||
7182 | file = baul_directory_get_existing_corresponding_file (directory); | |||
7183 | if (file) { | |||
7184 | baul_file_emit_changed (file); | |||
7185 | baul_file_unref (file); | |||
7186 | } | |||
7187 | } | |||
7188 | baul_directory_unref (directory); | |||
7189 | } | |||
7190 | ||||
7191 | /** | |||
7192 | * baul_file_get_volume_free_space | |||
7193 | * Get a nicely formatted char with free space on the file's volume | |||
7194 | * @file: BaulFile representing the file in question. | |||
7195 | * | |||
7196 | * Returns: newly-allocated copy of file size in a formatted string | |||
7197 | */ | |||
7198 | char * | |||
7199 | baul_file_get_volume_free_space (BaulFile *file) | |||
7200 | { | |||
7201 | BaulDirectory *directory; | |||
7202 | char *res; | |||
7203 | time_t now; | |||
7204 | ||||
7205 | directory = baul_directory_get_for_file (file); | |||
7206 | ||||
7207 | now = time (NULL((void*)0)); | |||
7208 | /* Update first time and then every 2 seconds */ | |||
7209 | if (directory->details->free_space_read == 0 || | |||
7210 | (now - directory->details->free_space_read) > 2) { | |||
7211 | GFile *location; | |||
7212 | ||||
7213 | directory->details->free_space_read = now; | |||
7214 | location = baul_file_get_location (file); | |||
7215 | g_file_query_filesystem_info_async (location, | |||
7216 | G_FILE_ATTRIBUTE_FILESYSTEM_FREE"filesystem::free", | |||
7217 | 0, NULL((void*)0), | |||
7218 | get_fs_free_cb, | |||
7219 | directory); /* Inherits ref */ | |||
7220 | g_object_unref (location); | |||
7221 | } else { | |||
7222 | baul_directory_unref (directory); | |||
7223 | } | |||
7224 | ||||
7225 | ||||
7226 | res = NULL((void*)0); | |||
7227 | ||||
7228 | if (directory->details->free_space != (guint64) -1) | |||
7229 | { | |||
7230 | if (g_settings_get_boolean (baul_preferences, BAUL_PREFERENCES_USE_IEC_UNITS"use-iec-units")) | |||
7231 | res = g_format_size_full (directory->details->free_space, G_FORMAT_SIZE_IEC_UNITS); | |||
7232 | else | |||
7233 | res = g_format_size(directory->details->free_space); | |||
7234 | } | |||
7235 | ||||
7236 | return res; | |||
7237 | } | |||
7238 | ||||
7239 | /** | |||
7240 | * baul_file_get_volume_name | |||
7241 | * Get the path of the volume the file resides on | |||
7242 | * @file: BaulFile representing the file in question. | |||
7243 | * | |||
7244 | * Returns: newly-allocated copy of the volume name of the target file, | |||
7245 | * if the volume name isn't set, it returns the mount path of the volume | |||
7246 | */ | |||
7247 | char * | |||
7248 | baul_file_get_volume_name (BaulFile *file) | |||
7249 | { | |||
7250 | GFile *location; | |||
7251 | char *res; | |||
7252 | GMount *mount; | |||
7253 | ||||
7254 | res = NULL((void*)0); | |||
7255 | ||||
7256 | location = baul_file_get_location (file); | |||
7257 | mount = g_file_find_enclosing_mount (location, NULL((void*)0), NULL((void*)0)); | |||
7258 | if (mount) { | |||
7259 | res = g_strdup (g_mount_get_name (mount)); | |||
7260 | g_object_unref (mount); | |||
7261 | } | |||
7262 | g_object_unref (location); | |||
7263 | ||||
7264 | return res; | |||
7265 | } | |||
7266 | ||||
7267 | /** | |||
7268 | * baul_file_get_symbolic_link_target_path | |||
7269 | * | |||
7270 | * Get the file path of the target of a symbolic link. It is an error | |||
7271 | * to call this function on a file that isn't a symbolic link. | |||
7272 | * @file: BaulFile representing the symbolic link in question. | |||
7273 | * | |||
7274 | * Returns: newly-allocated copy of the file path of the target of the symbolic link. | |||
7275 | */ | |||
7276 | char * | |||
7277 | baul_file_get_symbolic_link_target_path (BaulFile *file) | |||
7278 | { | |||
7279 | if (!baul_file_is_symbolic_link (file)) { | |||
7280 | g_warning ("File has symlink target, but is not marked as symlink"); | |||
7281 | } | |||
7282 | ||||
7283 | return g_strdup (file->details->symlink_name); | |||
7284 | } | |||
7285 | ||||
7286 | /** | |||
7287 | * baul_file_get_symbolic_link_target_uri | |||
7288 | * | |||
7289 | * Get the uri of the target of a symbolic link. It is an error | |||
7290 | * to call this function on a file that isn't a symbolic link. | |||
7291 | * @file: BaulFile representing the symbolic link in question. | |||
7292 | * | |||
7293 | * Returns: newly-allocated copy of the uri of the target of the symbolic link. | |||
7294 | */ | |||
7295 | char * | |||
7296 | baul_file_get_symbolic_link_target_uri (BaulFile *file) | |||
7297 | { | |||
7298 | if (!baul_file_is_symbolic_link (file)) { | |||
7299 | g_warning ("File has symlink target, but is not marked as symlink"); | |||
7300 | } | |||
7301 | ||||
7302 | if (file->details->symlink_name == NULL((void*)0)) { | |||
7303 | return NULL((void*)0); | |||
7304 | } else { | |||
7305 | GFile *location, *parent, *target; | |||
7306 | char *target_uri; | |||
7307 | ||||
7308 | target = NULL((void*)0); | |||
7309 | ||||
7310 | location = baul_file_get_location (file); | |||
7311 | parent = g_file_get_parent (location); | |||
7312 | g_object_unref (location); | |||
7313 | if (parent) { | |||
7314 | target = g_file_resolve_relative_path (parent, file->details->symlink_name); | |||
7315 | g_object_unref (parent); | |||
7316 | } | |||
7317 | ||||
7318 | target_uri = NULL((void*)0); | |||
7319 | if (target) { | |||
7320 | target_uri = g_file_get_uri (target); | |||
7321 | g_object_unref (target); | |||
7322 | } | |||
7323 | return target_uri; | |||
7324 | } | |||
7325 | } | |||
7326 | ||||
7327 | /** | |||
7328 | * baul_file_is_baul_link | |||
7329 | * | |||
7330 | * Check if this file is a "baul link", meaning a historical | |||
7331 | * baul xml link file or a desktop file. | |||
7332 | * @file: BaulFile representing the file in question. | |||
7333 | * | |||
7334 | * Returns: True if the file is a baul link. | |||
7335 | * | |||
7336 | **/ | |||
7337 | gboolean | |||
7338 | baul_file_is_baul_link (BaulFile *file) | |||
7339 | { | |||
7340 | if (file->details->mime_type == NULL((void*)0)) | |||
7341 | { | |||
7342 | return FALSE(0); | |||
7343 | } | |||
7344 | return g_content_type_equals (file->details->mime_type, | |||
7345 | "application/x-desktop"); | |||
7346 | } | |||
7347 | ||||
7348 | /** | |||
7349 | * baul_file_is_directory | |||
7350 | * | |||
7351 | * Check if this file is a directory. | |||
7352 | * @file: BaulFile representing the file in question. | |||
7353 | * | |||
7354 | * Returns: TRUE if @file is a directory. | |||
7355 | * | |||
7356 | **/ | |||
7357 | gboolean | |||
7358 | baul_file_is_directory (BaulFile *file) | |||
7359 | { | |||
7360 | return baul_file_get_file_type (file) == G_FILE_TYPE_DIRECTORY; | |||
7361 | } | |||
7362 | ||||
7363 | /** | |||
7364 | * baul_file_is_user_special_directory | |||
7365 | * | |||
7366 | * Check if this file is a special platform directory. | |||
7367 | * @file: BaulFile representing the file in question. | |||
7368 | * @special_directory: GUserDirectory representing the type to test for | |||
7369 | * | |||
7370 | * Returns: TRUE if @file is a special directory of the given kind. | |||
7371 | */ | |||
7372 | gboolean | |||
7373 | baul_file_is_user_special_directory (BaulFile *file, | |||
7374 | GUserDirectory special_directory) | |||
7375 | { | |||
7376 | gboolean is_special_dir; | |||
7377 | const gchar *special_dir; | |||
7378 | ||||
7379 | special_dir = g_get_user_special_dir (special_directory); | |||
7380 | is_special_dir = FALSE(0); | |||
7381 | ||||
7382 | if (special_dir) { | |||
7383 | GFile *loc; | |||
7384 | GFile *special_gfile; | |||
7385 | ||||
7386 | loc = baul_file_get_location (file); | |||
7387 | special_gfile = g_file_new_for_path (special_dir); | |||
7388 | is_special_dir = g_file_equal (loc, special_gfile); | |||
7389 | g_object_unref (special_gfile); | |||
7390 | g_object_unref (loc); | |||
7391 | } | |||
7392 | ||||
7393 | return is_special_dir; | |||
7394 | } | |||
7395 | ||||
7396 | gboolean | |||
7397 | baul_file_is_archive (BaulFile *file) | |||
7398 | { | |||
7399 | char *mime_type; | |||
7400 | int i; | |||
7401 | static const char * archive_mime_types[] = { "application/x-gtar", | |||
7402 | "application/x-zip", | |||
7403 | "application/x-zip-compressed", | |||
7404 | "application/zip", | |||
7405 | "application/x-zip", | |||
7406 | "application/x-tar", | |||
7407 | "application/x-7z-compressed", | |||
7408 | "application/x-rar", | |||
7409 | "application/x-rar-compressed", | |||
7410 | "application/x-jar", | |||
7411 | "application/x-java-archive", | |||
7412 | "application/x-war", | |||
7413 | "application/x-ear", | |||
7414 | "application/x-arj", | |||
7415 | "application/x-gzip", | |||
7416 | "application/x-bzip-compressed-tar", | |||
7417 | "application/x-compressed-tar" }; | |||
7418 | ||||
7419 | g_return_val_if_fail (file != NULL, FALSE)do { if ((file != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "file != NULL"); return ((0)); } } while (0); | |||
7420 | ||||
7421 | mime_type = baul_file_get_mime_type (file); | |||
7422 | for (i = 0; i < G_N_ELEMENTS (archive_mime_types)(sizeof (archive_mime_types) / sizeof ((archive_mime_types)[0 ])); i++) { | |||
7423 | if (!strcmp (mime_type, archive_mime_types[i])) { | |||
7424 | g_free (mime_type); | |||
7425 | return TRUE(!(0)); | |||
7426 | } | |||
7427 | } | |||
7428 | g_free (mime_type); | |||
7429 | ||||
7430 | return FALSE(0); | |||
7431 | } | |||
7432 | ||||
7433 | ||||
7434 | /** | |||
7435 | * baul_file_is_in_trash | |||
7436 | * | |||
7437 | * Check if this file is a file in trash. | |||
7438 | * @file: BaulFile representing the file in question. | |||
7439 | * | |||
7440 | * Returns: TRUE if @file is in a trash. | |||
7441 | * | |||
7442 | **/ | |||
7443 | gboolean | |||
7444 | baul_file_is_in_trash (BaulFile *file) | |||
7445 | { | |||
7446 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 7446, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
7447 | ||||
7448 | return baul_directory_is_in_trash (file->details->directory); | |||
7449 | } | |||
7450 | ||||
7451 | GError * | |||
7452 | baul_file_get_file_info_error (BaulFile *file) | |||
7453 | { | |||
7454 | if (!file->details->get_info_failed) { | |||
7455 | return NULL((void*)0); | |||
7456 | } | |||
7457 | ||||
7458 | return file->details->get_info_error; | |||
7459 | } | |||
7460 | ||||
7461 | /** | |||
7462 | * baul_file_contains_text | |||
7463 | * | |||
7464 | * Check if this file contains text. | |||
7465 | * This is private and is used to decide whether or not to read the top left text. | |||
7466 | * @file: BaulFile representing the file in question. | |||
7467 | * | |||
7468 | * Returns: TRUE if @file has a text MIME type. | |||
7469 | * | |||
7470 | **/ | |||
7471 | gboolean | |||
7472 | baul_file_contains_text (BaulFile *file) | |||
7473 | { | |||
7474 | if (file == NULL((void*)0)) { | |||
7475 | return FALSE(0); | |||
7476 | } | |||
7477 | ||||
7478 | /* All text files inherit from text/plain */ | |||
7479 | return baul_file_is_mime_type (file, "text/plain"); | |||
7480 | } | |||
7481 | ||||
7482 | /** | |||
7483 | * baul_file_is_binary | |||
7484 | * | |||
7485 | * Check if this file is a binary file. | |||
7486 | * This is private and is used to decide whether or not to show the diff | |||
7487 | * button in the file conflict dialog. | |||
7488 | * @file: BaulFile representing the file in question. | |||
7489 | * | |||
7490 | * Returns: TRUE if @file is a binary file. | |||
7491 | * | |||
7492 | **/ | |||
7493 | gboolean | |||
7494 | baul_file_is_binary (BaulFile *file) | |||
7495 | { | |||
7496 | if (!baul_file_can_read(file)) | |||
7497 | { | |||
7498 | return FALSE(0); | |||
7499 | } | |||
7500 | ||||
7501 | gboolean is_binary = FALSE(0); | |||
7502 | int i = 0; | |||
7503 | FILE *fp; | |||
7504 | ||||
7505 | /* Check the first 4096 bytes of the files. If these contains a 0, | |||
7506 | * we can assume the file is binary. | |||
7507 | * This idea is taken from python code of meld. | |||
7508 | */ | |||
7509 | ||||
7510 | fp = g_fopenfopen (g_file_get_path (baul_file_get_location (file)), "r"); | |||
7511 | if (fp == NULL((void*)0)) | |||
7512 | { | |||
7513 | return FALSE(0); | |||
7514 | } | |||
7515 | ||||
7516 | while (!feof (fp)) { | |||
7517 | int c; | |||
7518 | ||||
7519 | if (i > 4096) { | |||
7520 | break; | |||
7521 | } | |||
7522 | c = fgetc(fp); | |||
7523 | if (c == 0) { | |||
7524 | is_binary = TRUE(!(0)); | |||
7525 | break; | |||
7526 | } | |||
7527 | i++; | |||
7528 | } | |||
7529 | fclose(fp); | |||
7530 | ||||
7531 | return is_binary; | |||
7532 | } | |||
7533 | ||||
7534 | /** | |||
7535 | * baul_file_is_executable | |||
7536 | * | |||
7537 | * Check if this file is executable at all. | |||
7538 | * @file: BaulFile representing the file in question. | |||
7539 | * | |||
7540 | * Returns: TRUE if any of the execute bits are set. FALSE if | |||
7541 | * not, or if the permissions are unknown. | |||
7542 | * | |||
7543 | **/ | |||
7544 | gboolean | |||
7545 | baul_file_is_executable (BaulFile *file) | |||
7546 | { | |||
7547 | if (!file->details->has_permissions) { | |||
7548 | /* File's permissions field is not valid. | |||
7549 | * Can't access specific permissions, so return FALSE. | |||
7550 | */ | |||
7551 | return FALSE(0); | |||
7552 | } | |||
7553 | ||||
7554 | return file->details->can_execute; | |||
7555 | } | |||
7556 | ||||
7557 | /** | |||
7558 | * baul_file_peek_top_left_text | |||
7559 | * | |||
7560 | * Peek at the text from the top left of the file. | |||
7561 | * @file: BaulFile representing the file in question. | |||
7562 | * | |||
7563 | * Returns: NULL if there is no text readable, otherwise, the text. | |||
7564 | * This string is owned by the file object and should not | |||
7565 | * be kept around or freed. | |||
7566 | * | |||
7567 | **/ | |||
7568 | char * | |||
7569 | baul_file_peek_top_left_text (BaulFile *file, | |||
7570 | gboolean need_large_text, | |||
7571 | gboolean *needs_loading) | |||
7572 | { | |||
7573 | g_return_val_if_fail (BAUL_IS_FILE (file), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return (((void*)0)); } } while (0); | |||
7574 | ||||
7575 | if (!baul_file_should_get_top_left_text (file)) { | |||
7576 | if (needs_loading) { | |||
7577 | *needs_loading = FALSE(0); | |||
7578 | } | |||
7579 | return NULL((void*)0); | |||
7580 | } | |||
7581 | ||||
7582 | if (needs_loading) { | |||
7583 | *needs_loading = !file->details->top_left_text_is_up_to_date; | |||
7584 | if (need_large_text) { | |||
7585 | *needs_loading |= file->details->got_top_left_text != file->details->got_large_top_left_text; | |||
7586 | } | |||
7587 | } | |||
7588 | ||||
7589 | /* Show " ..." in the file until we read the contents in. */ | |||
7590 | if (!file->details->got_top_left_text) { | |||
7591 | ||||
7592 | if (baul_file_contains_text (file)) { | |||
7593 | return " ..."; | |||
7594 | } | |||
7595 | return NULL((void*)0); | |||
7596 | } | |||
7597 | ||||
7598 | /* Show what we read in. */ | |||
7599 | return file->details->top_left_text; | |||
7600 | } | |||
7601 | ||||
7602 | /** | |||
7603 | * baul_file_get_top_left_text | |||
7604 | * | |||
7605 | * Get the text from the top left of the file. | |||
7606 | * @file: BaulFile representing the file in question. | |||
7607 | * | |||
7608 | * Returns: NULL if there is no text readable, otherwise, the text. | |||
7609 | * | |||
7610 | **/ | |||
7611 | char * | |||
7612 | baul_file_get_top_left_text (BaulFile *file) | |||
7613 | { | |||
7614 | return g_strdup (baul_file_peek_top_left_text (file, FALSE(0), NULL((void*)0))); | |||
7615 | } | |||
7616 | ||||
7617 | char * | |||
7618 | baul_file_get_filesystem_id (BaulFile *file) | |||
7619 | { | |||
7620 | return g_strdup (file->details->filesystem_id); | |||
7621 | } | |||
7622 | ||||
7623 | BaulFile * | |||
7624 | baul_file_get_trash_original_file (BaulFile *file) | |||
7625 | { | |||
7626 | BaulFile *original_file; | |||
7627 | ||||
7628 | original_file = NULL((void*)0); | |||
7629 | ||||
7630 | if (file->details->trash_orig_path != NULL((void*)0)) { | |||
7631 | GFile *location; | |||
7632 | ||||
7633 | location = g_file_new_for_path (file->details->trash_orig_path); | |||
7634 | original_file = baul_file_get (location); | |||
7635 | g_object_unref (location); | |||
7636 | } | |||
7637 | ||||
7638 | return original_file; | |||
7639 | ||||
7640 | } | |||
7641 | ||||
7642 | void | |||
7643 | baul_file_mark_gone (BaulFile *file) | |||
7644 | { | |||
7645 | BaulDirectory *directory; | |||
7646 | ||||
7647 | if (file->details->is_gone) | |||
7648 | return; | |||
7649 | ||||
7650 | file->details->is_gone = TRUE(!(0)); | |||
7651 | ||||
7652 | update_links_if_target (file); | |||
7653 | ||||
7654 | /* Drop it from the symlink hash ! */ | |||
7655 | remove_from_link_hash_table (file); | |||
7656 | ||||
7657 | /* Let the directory know it's gone. */ | |||
7658 | directory = file->details->directory; | |||
7659 | if (!baul_file_is_self_owned (file)) { | |||
7660 | baul_directory_remove_file (directory, file); | |||
7661 | } | |||
7662 | ||||
7663 | baul_file_clear_info (file); | |||
7664 | ||||
7665 | /* FIXME bugzilla.gnome.org 42429: | |||
7666 | * Maybe we can get rid of the name too eventually, but | |||
7667 | * for now that would probably require too many if statements | |||
7668 | * everywhere anyone deals with the name. Maybe we can give it | |||
7669 | * a hard-coded "<deleted>" name or something. | |||
7670 | */ | |||
7671 | } | |||
7672 | ||||
7673 | /** | |||
7674 | * baul_file_changed | |||
7675 | * | |||
7676 | * Notify the user that this file has changed. | |||
7677 | * @file: BaulFile representing the file in question. | |||
7678 | **/ | |||
7679 | void | |||
7680 | baul_file_changed (BaulFile *file) | |||
7681 | { | |||
7682 | GList fake_list; | |||
7683 | ||||
7684 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
7685 | ||||
7686 | if (baul_file_is_self_owned (file)) { | |||
7687 | baul_file_emit_changed (file); | |||
7688 | } else { | |||
7689 | fake_list.data = file; | |||
7690 | fake_list.next = NULL((void*)0); | |||
7691 | fake_list.prev = NULL((void*)0); | |||
7692 | baul_directory_emit_change_signals | |||
7693 | (file->details->directory, &fake_list); | |||
7694 | } | |||
7695 | } | |||
7696 | ||||
7697 | /** | |||
7698 | * baul_file_updated_deep_count_in_progress | |||
7699 | * | |||
7700 | * Notify clients that a newer deep count is available for | |||
7701 | * the directory in question. | |||
7702 | */ | |||
7703 | void | |||
7704 | baul_file_updated_deep_count_in_progress (BaulFile *file) { | |||
7705 | GList *link_files, *node; | |||
7706 | ||||
7707 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 7707, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
7708 | g_assert (baul_file_is_directory (file))do { if (baul_file_is_directory (file)) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 7708, ((const char*) (__func__ )), "baul_file_is_directory (file)"); } while (0); | |||
7709 | ||||
7710 | /* Send out a signal. */ | |||
7711 | g_signal_emit (file, signals[UPDATED_DEEP_COUNT_IN_PROGRESS], 0, file); | |||
7712 | ||||
7713 | /* Tell link files pointing to this object about the change. */ | |||
7714 | link_files = get_link_files (file); | |||
7715 | for (node = link_files; node != NULL((void*)0); node = node->next) { | |||
7716 | baul_file_updated_deep_count_in_progress (BAUL_FILE (node->data)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((node->data)), (baul_file_get_type())))))); | |||
7717 | } | |||
7718 | baul_file_list_free (link_files); | |||
7719 | } | |||
7720 | ||||
7721 | /** | |||
7722 | * baul_file_emit_changed | |||
7723 | * | |||
7724 | * Emit a file changed signal. | |||
7725 | * This can only be called by the directory, since the directory | |||
7726 | * also has to emit a files_changed signal. | |||
7727 | * | |||
7728 | * @file: BaulFile representing the file in question. | |||
7729 | **/ | |||
7730 | void | |||
7731 | baul_file_emit_changed (BaulFile *file) | |||
7732 | { | |||
7733 | GList *link_files, *p; | |||
7734 | ||||
7735 | g_assert (BAUL_IS_FILE (file))do { if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) ; else g_assertion_message_expr (((gchar*) 0), "baul-file.c", 7735, ((const char*) (__func__)), "BAUL_IS_FILE (file)"); } while ( 0); | |||
7736 | ||||
7737 | ||||
7738 | /* Invalidate the emblem compare cache. -- This is not the cleanest | |||
7739 | * place to do it but it is the one guaranteed bottleneck through | |||
7740 | * which all change notifications pass. | |||
7741 | */ | |||
7742 | g_free (file->details->compare_by_emblem_cache); | |||
7743 | file->details->compare_by_emblem_cache = NULL((void*)0); | |||
7744 | ||||
7745 | /* Send out a signal. */ | |||
7746 | g_signal_emit (file, signals[CHANGED], 0, file); | |||
7747 | ||||
7748 | /* Tell link files pointing to this object about the change. */ | |||
7749 | link_files = get_link_files (file); | |||
7750 | for (p = link_files; p != NULL((void*)0); p = p->next) { | |||
7751 | if (p->data != file) { | |||
7752 | baul_file_changed (BAUL_FILE (p->data)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((p->data)), (baul_file_get_type())))))); | |||
7753 | } | |||
7754 | } | |||
7755 | baul_file_list_free (link_files); | |||
7756 | } | |||
7757 | ||||
7758 | /** | |||
7759 | * baul_file_is_gone | |||
7760 | * | |||
7761 | * Check if a file has already been deleted. | |||
7762 | * @file: BaulFile representing the file in question. | |||
7763 | * | |||
7764 | * Returns: TRUE if the file is already gone. | |||
7765 | **/ | |||
7766 | gboolean | |||
7767 | baul_file_is_gone (BaulFile *file) | |||
7768 | { | |||
7769 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
7770 | ||||
7771 | return file->details->is_gone; | |||
7772 | } | |||
7773 | ||||
7774 | /** | |||
7775 | * baul_file_is_not_yet_confirmed | |||
7776 | * | |||
7777 | * Check if we're in a state where we don't know if a file really | |||
7778 | * exists or not, before the initial I/O is complete. | |||
7779 | * @file: BaulFile representing the file in question. | |||
7780 | * | |||
7781 | * Returns: TRUE if the file is already gone. | |||
7782 | **/ | |||
7783 | gboolean | |||
7784 | baul_file_is_not_yet_confirmed (BaulFile *file) | |||
7785 | { | |||
7786 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
7787 | ||||
7788 | return !file->details->got_file_info; | |||
7789 | } | |||
7790 | ||||
7791 | /** | |||
7792 | * baul_file_check_if_ready | |||
7793 | * | |||
7794 | * Check whether the values for a set of file attributes are | |||
7795 | * currently available, without doing any additional work. This | |||
7796 | * is useful for callers that want to reflect updated information | |||
7797 | * when it is ready but don't want to force the work required to | |||
7798 | * obtain the information, which might be slow network calls, e.g. | |||
7799 | * | |||
7800 | * @file: The file being queried. | |||
7801 | * @file_attributes: A bit-mask with the desired information. | |||
7802 | * | |||
7803 | * Return value: TRUE if all of the specified attributes are currently readable. | |||
7804 | */ | |||
7805 | gboolean | |||
7806 | baul_file_check_if_ready (BaulFile *file, | |||
7807 | BaulFileAttributes file_attributes) | |||
7808 | { | |||
7809 | /* To be parallel with call_when_ready, return | |||
7810 | * TRUE for NULL file. | |||
7811 | */ | |||
7812 | if (file == NULL((void*)0)) { | |||
7813 | return TRUE(!(0)); | |||
7814 | } | |||
7815 | ||||
7816 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
7817 | ||||
7818 | return EEL_CALL_METHOD_WITH_RETURN_VALUE(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->check_if_ready == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->check_if_ready ) (file, file_attributes)) | |||
7819 | (BAUL_FILE_CLASS, file,(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->check_if_ready == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->check_if_ready ) (file, file_attributes)) | |||
7820 | check_if_ready, (file, file_attributes))(((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((((((GObjectClass*) (((GTypeInstance*) ((file)))->g_class )))))), (baul_file_get_type())))))->check_if_ready == ((void *)0)) ? 0 : ((* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->check_if_ready ) (file, file_attributes)); | |||
7821 | } | |||
7822 | ||||
7823 | void | |||
7824 | baul_file_call_when_ready (BaulFile *file, | |||
7825 | BaulFileAttributes file_attributes, | |||
7826 | BaulFileCallback callback, | |||
7827 | gpointer callback_data) | |||
7828 | ||||
7829 | { | |||
7830 | if (file == NULL((void*)0)) { | |||
7831 | (* callback) (file, callback_data); | |||
7832 | return; | |||
7833 | } | |||
7834 | ||||
7835 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
7836 | ||||
7837 | EEL_CALL_METHODdo { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready ) (file, file_attributes, callback, callback_data); } } while (0) | |||
7838 | (BAUL_FILE_CLASS, file,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready ) (file, file_attributes, callback, callback_data); } } while (0) | |||
7839 | call_when_ready, (file, file_attributes,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready ) (file, file_attributes, callback, callback_data); } } while (0) | |||
7840 | callback, callback_data))do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->call_when_ready ) (file, file_attributes, callback, callback_data); } } while (0); | |||
7841 | } | |||
7842 | ||||
7843 | void | |||
7844 | baul_file_cancel_call_when_ready (BaulFile *file, | |||
7845 | BaulFileCallback callback, | |||
7846 | gpointer callback_data) | |||
7847 | { | |||
7848 | g_return_if_fail (callback != NULL)do { if ((callback != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "callback != NULL" ); return; } } while (0); | |||
7849 | ||||
7850 | if (file == NULL((void*)0)) { | |||
7851 | return; | |||
7852 | } | |||
7853 | ||||
7854 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
7855 | ||||
7856 | EEL_CALL_METHODdo { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready ) (file, callback, callback_data); } } while (0) | |||
7857 | (BAUL_FILE_CLASS, file,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready ) (file, callback, callback_data); } } while (0) | |||
7858 | cancel_call_when_ready, (file, callback, callback_data))do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready ) (file, callback, callback_data); } } while (0); | |||
7859 | } | |||
7860 | ||||
7861 | static void | |||
7862 | invalidate_directory_count (BaulFile *file) | |||
7863 | { | |||
7864 | file->details->directory_count_is_up_to_date = FALSE(0); | |||
7865 | } | |||
7866 | ||||
7867 | static void | |||
7868 | invalidate_deep_counts (BaulFile *file) | |||
7869 | { | |||
7870 | file->details->deep_counts_status = BAUL_REQUEST_NOT_STARTED; | |||
7871 | } | |||
7872 | ||||
7873 | static void | |||
7874 | invalidate_mime_list (BaulFile *file) | |||
7875 | { | |||
7876 | file->details->mime_list_is_up_to_date = FALSE(0); | |||
7877 | } | |||
7878 | ||||
7879 | static void | |||
7880 | invalidate_top_left_text (BaulFile *file) | |||
7881 | { | |||
7882 | file->details->top_left_text_is_up_to_date = FALSE(0); | |||
7883 | } | |||
7884 | ||||
7885 | static void | |||
7886 | invalidate_file_info (BaulFile *file) | |||
7887 | { | |||
7888 | file->details->file_info_is_up_to_date = FALSE(0); | |||
7889 | } | |||
7890 | ||||
7891 | static void | |||
7892 | invalidate_link_info (BaulFile *file) | |||
7893 | { | |||
7894 | file->details->link_info_is_up_to_date = FALSE(0); | |||
7895 | } | |||
7896 | ||||
7897 | static void | |||
7898 | invalidate_thumbnail (BaulFile *file) | |||
7899 | { | |||
7900 | file->details->thumbnail_is_up_to_date = FALSE(0); | |||
7901 | } | |||
7902 | ||||
7903 | static void | |||
7904 | invalidate_mount (BaulFile *file) | |||
7905 | { | |||
7906 | file->details->mount_is_up_to_date = FALSE(0); | |||
7907 | } | |||
7908 | ||||
7909 | void | |||
7910 | baul_file_invalidate_extension_info_internal (BaulFile *file) | |||
7911 | { | |||
7912 | if (file->details->pending_info_providers) | |||
7913 | g_list_free_full (file->details->pending_info_providers, g_object_unref); | |||
7914 | ||||
7915 | file->details->pending_info_providers = | |||
7916 | baul_extensions_get_for_type (BAUL_TYPE_INFO_PROVIDER(baul_info_provider_get_type ())); | |||
7917 | } | |||
7918 | ||||
7919 | void | |||
7920 | baul_file_invalidate_attributes_internal (BaulFile *file, | |||
7921 | BaulFileAttributes file_attributes) | |||
7922 | { | |||
7923 | Request request; | |||
7924 | ||||
7925 | if (file == NULL((void*)0)) { | |||
7926 | return; | |||
7927 | } | |||
7928 | ||||
7929 | if (BAUL_IS_DESKTOP_ICON_FILE (file)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) ( (file)); GType __t = (baul_desktop_icon_file_get_type()); gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; }))))) { | |||
7930 | /* Desktop icon files are always up to date. | |||
7931 | * If we invalidate their attributes they | |||
7932 | * will lose data, so we just ignore them. | |||
7933 | */ | |||
7934 | return; | |||
7935 | } | |||
7936 | ||||
7937 | request = baul_directory_set_up_request (file_attributes); | |||
7938 | ||||
7939 | if (REQUEST_WANTS_TYPE (request, REQUEST_DIRECTORY_COUNT)((request) & (1<<(REQUEST_DIRECTORY_COUNT)))) { | |||
7940 | invalidate_directory_count (file); | |||
7941 | } | |||
7942 | if (REQUEST_WANTS_TYPE (request, REQUEST_DEEP_COUNT)((request) & (1<<(REQUEST_DEEP_COUNT)))) { | |||
7943 | invalidate_deep_counts (file); | |||
7944 | } | |||
7945 | if (REQUEST_WANTS_TYPE (request, REQUEST_MIME_LIST)((request) & (1<<(REQUEST_MIME_LIST)))) { | |||
7946 | invalidate_mime_list (file); | |||
7947 | } | |||
7948 | if (REQUEST_WANTS_TYPE (request, REQUEST_FILE_INFO)((request) & (1<<(REQUEST_FILE_INFO)))) { | |||
7949 | invalidate_file_info (file); | |||
7950 | } | |||
7951 | if (REQUEST_WANTS_TYPE (request, REQUEST_TOP_LEFT_TEXT)((request) & (1<<(REQUEST_TOP_LEFT_TEXT)))) { | |||
7952 | invalidate_top_left_text (file); | |||
7953 | } | |||
7954 | if (REQUEST_WANTS_TYPE (request, REQUEST_LINK_INFO)((request) & (1<<(REQUEST_LINK_INFO)))) { | |||
7955 | invalidate_link_info (file); | |||
7956 | } | |||
7957 | if (REQUEST_WANTS_TYPE (request, REQUEST_EXTENSION_INFO)((request) & (1<<(REQUEST_EXTENSION_INFO)))) { | |||
7958 | baul_file_invalidate_extension_info_internal (file); | |||
7959 | } | |||
7960 | if (REQUEST_WANTS_TYPE (request, REQUEST_THUMBNAIL)((request) & (1<<(REQUEST_THUMBNAIL)))) { | |||
7961 | invalidate_thumbnail (file); | |||
7962 | } | |||
7963 | if (REQUEST_WANTS_TYPE (request, REQUEST_MOUNT)((request) & (1<<(REQUEST_MOUNT)))) { | |||
7964 | invalidate_mount (file); | |||
7965 | } | |||
7966 | ||||
7967 | /* FIXME bugzilla.gnome.org 45075: implement invalidating metadata */ | |||
7968 | } | |||
7969 | ||||
7970 | gboolean | |||
7971 | baul_file_has_open_window (BaulFile *file) | |||
7972 | { | |||
7973 | return file->details->has_open_window; | |||
7974 | } | |||
7975 | ||||
7976 | void | |||
7977 | baul_file_set_has_open_window (BaulFile *file, | |||
7978 | gboolean has_open_window) | |||
7979 | { | |||
7980 | has_open_window = (has_open_window != FALSE(0)); | |||
7981 | ||||
7982 | if (file->details->has_open_window != has_open_window) { | |||
7983 | file->details->has_open_window = has_open_window; | |||
7984 | baul_file_changed (file); | |||
7985 | } | |||
7986 | } | |||
7987 | ||||
7988 | ||||
7989 | gboolean | |||
7990 | baul_file_is_thumbnailing (BaulFile *file) | |||
7991 | { | |||
7992 | g_return_val_if_fail (BAUL_IS_FILE (file), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return ((0)); } } while (0); | |||
7993 | ||||
7994 | return file->details->is_thumbnailing; | |||
7995 | } | |||
7996 | ||||
7997 | void | |||
7998 | baul_file_set_is_thumbnailing (BaulFile *file, | |||
7999 | gboolean is_thumbnailing) | |||
8000 | { | |||
8001 | g_return_if_fail (BAUL_IS_FILE (file))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance *) ((file)); GType __t = (baul_file_get_type()); gboolean __r ; if (!__inst) __r = (0); else if (__inst->g_class && __inst->g_class->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a (__inst, __t); __r; })))))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char* ) (__func__)), "BAUL_IS_FILE (file)"); return; } } while (0); | |||
8002 | ||||
8003 | file->details->is_thumbnailing = is_thumbnailing; | |||
8004 | } | |||
8005 | ||||
8006 | ||||
8007 | /** | |||
8008 | * baul_file_invalidate_attributes | |||
8009 | * | |||
8010 | * Invalidate the specified attributes and force a reload. | |||
8011 | * @file: BaulFile representing the file in question. | |||
8012 | * @file_attributes: attributes to froget. | |||
8013 | **/ | |||
8014 | ||||
8015 | void | |||
8016 | baul_file_invalidate_attributes (BaulFile *file, | |||
8017 | BaulFileAttributes file_attributes) | |||
8018 | { | |||
8019 | /* Cancel possible in-progress loads of any of these attributes */ | |||
8020 | baul_directory_cancel_loading_file_attributes (file->details->directory, | |||
8021 | file, | |||
8022 | file_attributes); | |||
8023 | ||||
8024 | /* Actually invalidate the values */ | |||
8025 | baul_file_invalidate_attributes_internal (file, file_attributes); | |||
8026 | ||||
8027 | baul_directory_add_file_to_work_queue (file->details->directory, file); | |||
8028 | ||||
8029 | /* Kick off I/O if necessary */ | |||
8030 | baul_directory_async_state_changed (file->details->directory); | |||
8031 | } | |||
8032 | ||||
8033 | BaulFileAttributes | |||
8034 | baul_file_get_all_attributes (void) | |||
8035 | { | |||
8036 | return BAUL_FILE_ATTRIBUTE_INFO | | |||
8037 | BAUL_FILE_ATTRIBUTE_LINK_INFO | | |||
8038 | BAUL_FILE_ATTRIBUTE_DEEP_COUNTS | | |||
8039 | BAUL_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT | | |||
8040 | BAUL_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES | | |||
8041 | BAUL_FILE_ATTRIBUTE_TOP_LEFT_TEXT | | |||
8042 | BAUL_FILE_ATTRIBUTE_LARGE_TOP_LEFT_TEXT | | |||
8043 | BAUL_FILE_ATTRIBUTE_EXTENSION_INFO | | |||
8044 | BAUL_FILE_ATTRIBUTE_THUMBNAIL | | |||
8045 | BAUL_FILE_ATTRIBUTE_MOUNT; | |||
8046 | } | |||
8047 | ||||
8048 | void | |||
8049 | baul_file_invalidate_all_attributes (BaulFile *file) | |||
8050 | { | |||
8051 | BaulFileAttributes all_attributes; | |||
8052 | ||||
8053 | all_attributes = baul_file_get_all_attributes (); | |||
8054 | baul_file_invalidate_attributes (file, all_attributes); | |||
8055 | } | |||
8056 | ||||
8057 | ||||
8058 | /** | |||
8059 | * baul_file_dump | |||
8060 | * | |||
8061 | * Debugging call, prints out the contents of the file | |||
8062 | * fields. | |||
8063 | * | |||
8064 | * @file: file to dump. | |||
8065 | **/ | |||
8066 | void | |||
8067 | baul_file_dump (BaulFile *file) | |||
8068 | { | |||
8069 | long size = file->details->deep_size; | |||
8070 | long size_on_disk = file->details->deep_size_on_disk; | |||
8071 | char *uri; | |||
8072 | const char *file_kind; | |||
8073 | ||||
8074 | uri = baul_file_get_uri (file); | |||
8075 | g_print ("uri: %s \n", uri); | |||
8076 | if (!file->details->got_file_info) { | |||
8077 | g_print ("no file info \n"); | |||
8078 | } else if (file->details->get_info_failed) { | |||
8079 | g_print ("failed to get file info \n"); | |||
8080 | } else { | |||
8081 | g_print ("size: %ld \n", size); | |||
8082 | g_print ("disk size: %ld \n", size_on_disk); | |||
8083 | switch (file->details->type) { | |||
8084 | case G_FILE_TYPE_REGULAR: | |||
8085 | file_kind = "regular file"; | |||
8086 | break; | |||
8087 | case G_FILE_TYPE_DIRECTORY: | |||
8088 | file_kind = "folder"; | |||
8089 | break; | |||
8090 | case G_FILE_TYPE_SPECIAL: | |||
8091 | file_kind = "special"; | |||
8092 | break; | |||
8093 | case G_FILE_TYPE_SYMBOLIC_LINK: | |||
8094 | file_kind = "symbolic link"; | |||
8095 | break; | |||
8096 | case G_FILE_TYPE_UNKNOWN: | |||
8097 | default: | |||
8098 | file_kind = "unknown"; | |||
8099 | break; | |||
8100 | } | |||
8101 | g_print ("kind: %s \n", file_kind); | |||
8102 | if (file->details->type == G_FILE_TYPE_SYMBOLIC_LINK) { | |||
8103 | g_print ("link to %s \n", file->details->symlink_name); | |||
8104 | /* FIXME bugzilla.gnome.org 42430: add following of symlinks here */ | |||
8105 | } | |||
8106 | /* FIXME bugzilla.gnome.org 42431: add permissions and other useful stuff here */ | |||
8107 | } | |||
8108 | g_free (uri); | |||
8109 | } | |||
8110 | ||||
8111 | /** | |||
8112 | * baul_file_list_ref | |||
8113 | * | |||
8114 | * Ref all the files in a list. | |||
8115 | * @list: GList of files. | |||
8116 | **/ | |||
8117 | GList * | |||
8118 | baul_file_list_ref (GList *list) | |||
8119 | { | |||
8120 | g_list_foreach (list, (GFunc) baul_file_ref, NULL((void*)0)); | |||
8121 | return list; | |||
8122 | } | |||
8123 | ||||
8124 | /** | |||
8125 | * baul_file_list_unref | |||
8126 | * | |||
8127 | * Unref all the files in a list. | |||
8128 | * @list: GList of files. | |||
8129 | **/ | |||
8130 | void | |||
8131 | baul_file_list_unref (GList *list) | |||
8132 | { | |||
8133 | g_list_foreach (list, (GFunc) baul_file_unref, NULL((void*)0)); | |||
8134 | } | |||
8135 | ||||
8136 | /** | |||
8137 | * baul_file_list_free | |||
8138 | * | |||
8139 | * Free a list of files after unrefing them. | |||
8140 | * @list: GList of files. | |||
8141 | **/ | |||
8142 | void | |||
8143 | baul_file_list_free (GList *list) | |||
8144 | { | |||
8145 | baul_file_list_unref (list); | |||
8146 | g_list_free (list); | |||
8147 | } | |||
8148 | ||||
8149 | /** | |||
8150 | * baul_file_list_copy | |||
8151 | * | |||
8152 | * Copy the list of files, making a new ref of each, | |||
8153 | * @list: GList of files. | |||
8154 | **/ | |||
8155 | GList * | |||
8156 | baul_file_list_copy (GList *list) | |||
8157 | { | |||
8158 | return g_list_copy (baul_file_list_ref (list)); | |||
8159 | } | |||
8160 | ||||
8161 | static gboolean | |||
8162 | get_attributes_for_default_sort_type (BaulFile *file, | |||
8163 | gboolean *is_download, | |||
8164 | gboolean *is_trash) | |||
8165 | { | |||
8166 | gboolean is_download_dir, is_desktop_dir, is_trash_dir, retval; | |||
8167 | ||||
8168 | *is_download = FALSE(0); | |||
8169 | *is_trash = FALSE(0); | |||
8170 | retval = FALSE(0); | |||
8171 | ||||
8172 | /* special handling for certain directories */ | |||
8173 | if (file && baul_file_is_directory (file)) { | |||
8174 | is_download_dir = | |||
8175 | baul_file_is_user_special_directory (file, G_USER_DIRECTORY_DOWNLOAD); | |||
8176 | is_desktop_dir = | |||
8177 | baul_file_is_user_special_directory (file, G_USER_DIRECTORY_DESKTOP); | |||
8178 | is_trash_dir = | |||
8179 | baul_file_is_in_trash (file); | |||
8180 | ||||
8181 | if (is_download_dir && !is_desktop_dir) { | |||
8182 | *is_download = TRUE(!(0)); | |||
8183 | retval = TRUE(!(0)); | |||
8184 | } else if (is_trash_dir) { | |||
8185 | *is_trash = TRUE(!(0)); | |||
8186 | retval = TRUE(!(0)); | |||
8187 | } | |||
8188 | } | |||
8189 | ||||
8190 | return retval; | |||
8191 | } | |||
8192 | ||||
8193 | BaulFileSortType | |||
8194 | baul_file_get_default_sort_type (BaulFile *file, | |||
8195 | gboolean *reversed) | |||
8196 | { | |||
8197 | BaulFileSortType retval; | |||
8198 | gboolean is_download, is_trash, res; | |||
8199 | ||||
8200 | retval = BAUL_FILE_SORT_NONE; | |||
8201 | is_download = is_trash = FALSE(0); | |||
8202 | res = get_attributes_for_default_sort_type (file, &is_download, &is_trash); | |||
8203 | ||||
8204 | if (res) { | |||
8205 | if (is_download) { | |||
8206 | retval = BAUL_FILE_SORT_BY_MTIME; | |||
8207 | } else if (is_trash) { | |||
8208 | retval = BAUL_FILE_SORT_BY_TRASHED_TIME; | |||
8209 | } | |||
8210 | ||||
8211 | if (reversed != NULL((void*)0)) { | |||
8212 | *reversed = res; | |||
8213 | } | |||
8214 | } | |||
8215 | ||||
8216 | return retval; | |||
8217 | } | |||
8218 | ||||
8219 | const gchar * | |||
8220 | baul_file_get_default_sort_attribute (BaulFile *file, | |||
8221 | gboolean *reversed) | |||
8222 | { | |||
8223 | const gchar *retval; | |||
8224 | gboolean is_download, is_trash, res; | |||
8225 | ||||
8226 | retval = NULL((void*)0); | |||
8227 | is_download = is_trash = FALSE(0); | |||
8228 | res = get_attributes_for_default_sort_type (file, &is_download, &is_trash); | |||
8229 | ||||
8230 | if (res) { | |||
8231 | if (is_download) { | |||
8232 | retval = g_quark_to_string (attribute_date_modified_q); | |||
8233 | } else if (is_trash) { | |||
8234 | retval = g_quark_to_string (attribute_trashed_on_q); | |||
8235 | } | |||
8236 | ||||
8237 | if (reversed != NULL((void*)0)) { | |||
8238 | *reversed = res; | |||
8239 | } | |||
8240 | } | |||
8241 | ||||
8242 | return retval; | |||
8243 | } | |||
8244 | ||||
8245 | static int | |||
8246 | compare_by_display_name_cover (gconstpointer a, gconstpointer b) | |||
8247 | { | |||
8248 | return compare_by_display_name (BAUL_FILE (a)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((a)), (baul_file_get_type()))))), BAUL_FILE (b)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((b)), (baul_file_get_type())))))); | |||
8249 | } | |||
8250 | ||||
8251 | /** | |||
8252 | * baul_file_list_sort_by_display_name | |||
8253 | * | |||
8254 | * Sort the list of files by file name. | |||
8255 | * @list: GList of files. | |||
8256 | **/ | |||
8257 | GList * | |||
8258 | baul_file_list_sort_by_display_name (GList *list) | |||
8259 | { | |||
8260 | return g_list_sort (list, compare_by_display_name_cover); | |||
8261 | } | |||
8262 | ||||
8263 | static GList *ready_data_list = NULL((void*)0); | |||
8264 | ||||
8265 | typedef struct | |||
8266 | { | |||
8267 | GList *file_list; | |||
8268 | GList *remaining_files; | |||
8269 | BaulFileListCallback callback; | |||
8270 | gpointer callback_data; | |||
8271 | } FileListReadyData; | |||
8272 | ||||
8273 | static void | |||
8274 | file_list_ready_data_free (FileListReadyData *data) | |||
8275 | { | |||
8276 | GList *l; | |||
8277 | ||||
8278 | l = g_list_find (ready_data_list, data); | |||
8279 | if (l != NULL((void*)0)) { | |||
8280 | ready_data_list = g_list_delete_link (ready_data_list, l); | |||
8281 | ||||
8282 | baul_file_list_free (data->file_list); | |||
8283 | g_list_free (data->remaining_files); | |||
8284 | g_free (data); | |||
8285 | } | |||
8286 | } | |||
8287 | ||||
8288 | static FileListReadyData * | |||
8289 | file_list_ready_data_new (GList *file_list, | |||
8290 | BaulFileListCallback callback, | |||
8291 | gpointer callback_data) | |||
8292 | { | |||
8293 | FileListReadyData *data; | |||
8294 | ||||
8295 | data = g_new0 (FileListReadyData, 1)((FileListReadyData *) g_malloc0_n ((1), sizeof (FileListReadyData ))); | |||
8296 | data->file_list = baul_file_list_copy (file_list); | |||
8297 | data->remaining_files = g_list_copy (file_list); | |||
8298 | data->callback = callback; | |||
8299 | data->callback_data = callback_data; | |||
8300 | ||||
8301 | ready_data_list = g_list_prepend (ready_data_list, data); | |||
8302 | ||||
8303 | return data; | |||
8304 | } | |||
8305 | ||||
8306 | static void | |||
8307 | file_list_file_ready_callback (BaulFile *file, | |||
8308 | gpointer user_data) | |||
8309 | { | |||
8310 | FileListReadyData *data; | |||
8311 | ||||
8312 | data = user_data; | |||
8313 | data->remaining_files = g_list_remove (data->remaining_files, file); | |||
8314 | ||||
8315 | if (data->remaining_files == NULL((void*)0)) { | |||
8316 | if (data->callback) { | |||
8317 | (*data->callback) (data->file_list, data->callback_data); | |||
8318 | } | |||
8319 | ||||
8320 | file_list_ready_data_free (data); | |||
8321 | } | |||
8322 | } | |||
8323 | ||||
8324 | void | |||
8325 | baul_file_list_call_when_ready (GList *file_list, | |||
8326 | BaulFileAttributes attributes, | |||
8327 | BaulFileListHandle **handle, | |||
8328 | BaulFileListCallback callback, | |||
8329 | gpointer callback_data) | |||
8330 | { | |||
8331 | GList *l; | |||
8332 | FileListReadyData *data; | |||
8333 | BaulFile *file = NULL((void*)0); | |||
8334 | ||||
8335 | g_return_if_fail (file_list != NULL)do { if ((file_list != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "file_list != NULL" ); return; } } while (0); | |||
8336 | ||||
8337 | data = file_list_ready_data_new | |||
8338 | (file_list, callback, callback_data); | |||
8339 | ||||
8340 | if (handle) { | |||
8341 | *handle = (BaulFileListHandle *) data; | |||
8342 | } | |||
8343 | ||||
8344 | ||||
8345 | l = file_list; | |||
8346 | while (l != NULL((void*)0)) { | |||
8347 | file = BAUL_FILE (l->data)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((l->data)), (baul_file_get_type()))))); | |||
8348 | /* Need to do this here, as the list can be modified by this call */ | |||
8349 | l = l->next; | |||
8350 | ||||
8351 | if (file) | |||
8352 | baul_file_call_when_ready (file, | |||
8353 | attributes, | |||
8354 | file_list_file_ready_callback, | |||
8355 | data); | |||
8356 | } | |||
8357 | } | |||
8358 | ||||
8359 | void | |||
8360 | baul_file_list_cancel_call_when_ready (BaulFileListHandle *handle) | |||
8361 | { | |||
8362 | GList *l; | |||
8363 | FileListReadyData *data; | |||
8364 | ||||
8365 | g_return_if_fail (handle != NULL)do { if ((handle != ((void*)0))) { } else { g_return_if_fail_warning (((gchar*) 0), ((const char*) (__func__)), "handle != NULL") ; return; } } while (0); | |||
8366 | ||||
8367 | data = (FileListReadyData *) handle; | |||
8368 | ||||
8369 | l = g_list_find (ready_data_list, data); | |||
8370 | if (l != NULL((void*)0)) { | |||
8371 | BaulFile *file = NULL((void*)0); | |||
8372 | ||||
8373 | for (l = data->remaining_files; l != NULL((void*)0); l = l->next) { | |||
8374 | file = BAUL_FILE (l->data)((((BaulFile*) (void *) g_type_check_instance_cast ((GTypeInstance *) ((l->data)), (baul_file_get_type()))))); | |||
8375 | ||||
8376 | EEL_CALL_METHODdo { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready ) (file, file_list_file_ready_callback, data); } } while (0) | |||
8377 | (BAUL_FILE_CLASS, file,do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready ) (file, file_list_file_ready_callback, data); } } while (0) | |||
8378 | cancel_call_when_ready, (file, file_list_file_ready_callback, data))do { if (((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready != ((void*)0)) { (* ((((BaulFileClass*) (void *) g_type_check_class_cast ((GTypeClass*) ((((((GObjectClass*) (((GTypeInstance*) ((file )))->g_class)))))), (baul_file_get_type())))))->cancel_call_when_ready ) (file, file_list_file_ready_callback, data); } } while (0); | |||
8379 | } | |||
8380 | ||||
8381 | file_list_ready_data_free (data); | |||
8382 | } | |||
8383 | } | |||
8384 | ||||
8385 | static char * | |||
8386 | try_to_make_utf8 (const char *text, int *length) | |||
8387 | { | |||
8388 | static const char *encodings_to_try[2]; | |||
8389 | static int n_encodings_to_try = 0; | |||
8390 | gsize converted_length; | |||
8391 | GError *conversion_error; | |||
8392 | char *utf8_text; | |||
8393 | int i; | |||
8394 | ||||
8395 | if (n_encodings_to_try == 0) { | |||
8396 | const char *charset; | |||
8397 | gboolean charset_is_utf8; | |||
8398 | ||||
8399 | charset_is_utf8 = g_get_charset (&charset); | |||
8400 | if (!charset_is_utf8) { | |||
8401 | encodings_to_try[n_encodings_to_try++] = charset; | |||
8402 | } | |||
8403 | ||||
8404 | if (g_ascii_strcasecmp (charset, "ISO-8859-1") != 0) { | |||
8405 | encodings_to_try[n_encodings_to_try++] = "ISO-8859-1"; | |||
8406 | } | |||
8407 | } | |||
8408 | ||||
8409 | utf8_text = NULL((void*)0); | |||
8410 | for (i = 0; i < n_encodings_to_try; i++) { | |||
8411 | conversion_error = NULL((void*)0); | |||
8412 | utf8_text = g_convert (text, *length, | |||
8413 | "UTF-8", encodings_to_try[i], | |||
8414 | NULL((void*)0), &converted_length, &conversion_error); | |||
8415 | if (utf8_text != NULL((void*)0)) { | |||
8416 | *length = converted_length; | |||
8417 | break; | |||
8418 | } | |||
8419 | g_error_free (conversion_error); | |||
8420 | } | |||
8421 | ||||
8422 | return utf8_text; | |||
8423 | } | |||
8424 | ||||
8425 | ||||
8426 | ||||
8427 | /* Extract the top left part of the read-in text. */ | |||
8428 | char * | |||
8429 | baul_extract_top_left_text (const char *text, | |||
8430 | gboolean large, | |||
8431 | int length) | |||
8432 | { | |||
8433 | GString* buffer; | |||
8434 | const gchar *in; | |||
8435 | const gchar *end; | |||
8436 | int line, i; | |||
8437 | gunichar c; | |||
8438 | char *text_copy; | |||
8439 | const char *utf8_end; | |||
8440 | gboolean validated; | |||
8441 | int max_bytes, max_lines, max_cols; | |||
8442 | ||||
8443 | if (large) { | |||
8444 | max_bytes = BAUL_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_BYTES10000; | |||
8445 | max_lines = BAUL_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_LINES24; | |||
8446 | max_cols = BAUL_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_CHARACTERS_PER_LINE80; | |||
8447 | } else { | |||
8448 | max_bytes = BAUL_FILE_TOP_LEFT_TEXT_MAXIMUM_BYTES1024; | |||
8449 | max_lines = BAUL_FILE_TOP_LEFT_TEXT_MAXIMUM_LINES5; | |||
8450 | max_cols = BAUL_FILE_TOP_LEFT_TEXT_MAXIMUM_CHARACTERS_PER_LINE10; | |||
8451 | } | |||
8452 | ||||
8453 | ||||
8454 | ||||
8455 | text_copy = NULL((void*)0); | |||
8456 | if (text != NULL((void*)0)) { | |||
8457 | /* Might be a partial utf8 character at the end if we didn't read whole file */ | |||
8458 | validated = g_utf8_validate (text, length, &utf8_end); | |||
8459 | if (!validated && | |||
8460 | !(length >= max_bytes && | |||
8461 | text + length - utf8_end < 6)) { | |||
8462 | text_copy = try_to_make_utf8 (text, &length); | |||
8463 | text = text_copy; | |||
8464 | } else if (!validated) { | |||
8465 | length = utf8_end - text; | |||
8466 | } | |||
8467 | } | |||
8468 | ||||
8469 | if (text == NULL((void*)0) || length == 0) { | |||
8470 | return NULL((void*)0); | |||
8471 | } | |||
8472 | ||||
8473 | buffer = g_string_new (""); | |||
8474 | end = text + length; in = text; | |||
8475 | ||||
8476 | for (line = 0; line < max_lines; line++) { | |||
8477 | /* Extract one line. */ | |||
8478 | for (i = 0; i < max_cols; ) { | |||
8479 | if (*in == '\n') { | |||
8480 | break; | |||
8481 | } | |||
8482 | ||||
8483 | c = g_utf8_get_char (in); | |||
8484 | ||||
8485 | if (g_unichar_isprint (c)) { | |||
8486 | g_string_append_unichar (buffer, c); | |||
8487 | i++; | |||
8488 | } | |||
8489 | ||||
8490 | in = g_utf8_next_char (in)(char *)((in) + g_utf8_skip[*(const guchar *)(in)]); | |||
8491 | if (in == end) { | |||
8492 | goto done; | |||
8493 | } | |||
8494 | } | |||
8495 | ||||
8496 | /* Skip the rest of the line. */ | |||
8497 | while (*in != '\n') { | |||
8498 | if (++in == end) { | |||
8499 | goto done; | |||
8500 | } | |||
8501 | } | |||
8502 | if (++in == end) { | |||
8503 | goto done; | |||
8504 | } | |||
8505 | ||||
8506 | /* Put a new-line separator in. */ | |||
8507 | g_string_append_c(buffer, '\n')g_string_append_c_inline (buffer, '\n'); | |||
8508 | } | |||
8509 | done: | |||
8510 | g_free (text_copy); | |||
8511 | ||||
8512 | return g_string_free(buffer, FALSE(0)); | |||
8513 | } | |||
8514 | ||||
8515 | static void | |||
8516 | thumbnail_limit_changed_callback (gpointer user_data) | |||
8517 | { | |||
8518 | g_settings_get (baul_preferences, | |||
8519 | BAUL_PREFERENCES_IMAGE_FILE_THUMBNAIL_LIMIT"thumbnail-limit", | |||
8520 | "t", &cached_thumbnail_limit); | |||
8521 | ||||
8522 | /* Tell the world that icons might have changed. We could invent a narrower-scope | |||
8523 | * signal to mean only "thumbnails might have changed" if this ends up being slow | |||
8524 | * for some reason. | |||
8525 | */ | |||
8526 | emit_change_signals_for_all_files_in_all_directories (); | |||
8527 | } | |||
8528 | ||||
8529 | static void | |||
8530 | thumbnail_size_changed_callback (gpointer user_data) | |||
8531 | { | |||
8532 | cached_thumbnail_size = g_settings_get_int (baul_icon_view_preferences, BAUL_PREFERENCES_ICON_VIEW_THUMBNAIL_SIZE"thumbnail-size"); | |||
8533 | ||||
8534 | /* Tell the world that icons might have changed. We could invent a narrower-scope | |||
8535 | * signal to mean only "thumbnails might have changed" if this ends up being slow | |||
8536 | * for some reason. | |||
8537 | */ | |||
8538 | emit_change_signals_for_all_files_in_all_directories (); | |||
8539 | } | |||
8540 | ||||
8541 | static void | |||
8542 | show_thumbnails_changed_callback (gpointer user_data) | |||
8543 | { | |||
8544 | show_image_thumbs = g_settings_get_enum (baul_preferences, BAUL_PREFERENCES_SHOW_IMAGE_FILE_THUMBNAILS"show-image-thumbnails"); | |||
8545 | ||||
8546 | /* Tell the world that icons might have changed. We could invent a narrower-scope | |||
8547 | * signal to mean only "thumbnails might have changed" if this ends up being slow | |||
8548 | * for some reason. | |||
8549 | */ | |||
8550 | emit_change_signals_for_all_files_in_all_directories (); | |||
8551 | } | |||
8552 | ||||
8553 | static void | |||
8554 | mime_type_data_changed_callback (GObject *signaller, gpointer user_data) | |||
8555 | { | |||
8556 | /* Tell the world that icons might have changed. We could invent a narrower-scope | |||
8557 | * signal to mean only "thumbnails might have changed" if this ends up being slow | |||
8558 | * for some reason. | |||
8559 | */ | |||
8560 | emit_change_signals_for_all_files_in_all_directories (); | |||
8561 | } | |||
8562 | ||||
8563 | static void | |||
8564 | icon_theme_changed_callback (CtkIconTheme *icon_theme, | |||
8565 | gpointer user_data) | |||
8566 | { | |||
8567 | /* Clear all pixmap caches as the icon => pixmap lookup changed */ | |||
8568 | baul_icon_info_clear_caches (); | |||
8569 | ||||
8570 | /* Tell the world that icons might have changed. We could invent a narrower-scope | |||
8571 | * signal to mean only "thumbnails might have changed" if this ends up being slow | |||
8572 | * for some reason. | |||
8573 | */ | |||
8574 | emit_change_signals_for_all_files_in_all_directories (); | |||
8575 | } | |||
8576 | ||||
8577 | static void | |||
8578 | baul_file_class_init (BaulFileClass *class) | |||
8579 | { | |||
8580 | CtkIconTheme *icon_theme; | |||
8581 | ||||
8582 | baul_file_info_getter = baul_file_get_internal; | |||
8583 | ||||
8584 | attribute_name_q = g_quark_from_static_string ("name"); | |||
8585 | attribute_size_q = g_quark_from_static_string ("size"); | |||
8586 | attribute_size_on_disk_q = g_quark_from_static_string ("size_on_disk"); | |||
8587 | attribute_type_q = g_quark_from_static_string ("type"); | |||
8588 | attribute_modification_date_q = g_quark_from_static_string ("modification_date"); | |||
8589 | attribute_date_modified_q = g_quark_from_static_string ("date_modified"); | |||
8590 | attribute_accessed_date_q = g_quark_from_static_string ("accessed_date"); | |||
8591 | attribute_date_accessed_q = g_quark_from_static_string ("date_accessed"); | |||
8592 | attribute_emblems_q = g_quark_from_static_string ("emblems"); | |||
8593 | attribute_extension_q = g_quark_from_static_string ("extension"); | |||
8594 | attribute_mime_type_q = g_quark_from_static_string ("mime_type"); | |||
8595 | attribute_size_detail_q = g_quark_from_static_string ("size_detail"); | |||
8596 | attribute_size_on_disk_detail_q = g_quark_from_static_string ("size_on_disk_detail"); | |||
8597 | attribute_deep_size_q = g_quark_from_static_string ("deep_size"); | |||
8598 | attribute_deep_size_on_disk_q = g_quark_from_static_string ("deep_size_on_disk"); | |||
8599 | attribute_deep_file_count_q = g_quark_from_static_string ("deep_file_count"); | |||
8600 | attribute_deep_directory_count_q = g_quark_from_static_string ("deep_directory_count"); | |||
8601 | attribute_deep_total_count_q = g_quark_from_static_string ("deep_total_count"); | |||
8602 | attribute_date_changed_q = g_quark_from_static_string ("date_changed"); | |||
8603 | attribute_trashed_on_q = g_quark_from_static_string ("trashed_on"); | |||
8604 | attribute_trash_orig_path_q = g_quark_from_static_string ("trash_orig_path"); | |||
8605 | attribute_date_permissions_q = g_quark_from_static_string ("date_permissions"); | |||
8606 | attribute_permissions_q = g_quark_from_static_string ("permissions"); | |||
8607 | attribute_selinux_context_q = g_quark_from_static_string ("selinux_context"); | |||
8608 | attribute_octal_permissions_q = g_quark_from_static_string ("octal_permissions"); | |||
8609 | attribute_owner_q = g_quark_from_static_string ("owner"); | |||
8610 | attribute_group_q = g_quark_from_static_string ("group"); | |||
8611 | attribute_uri_q = g_quark_from_static_string ("uri"); | |||
8612 | attribute_where_q = g_quark_from_static_string ("where"); | |||
8613 | attribute_link_target_q = g_quark_from_static_string ("link_target"); | |||
8614 | attribute_volume_q = g_quark_from_static_string ("volume"); | |||
8615 | attribute_free_space_q = g_quark_from_static_string ("free_space"); | |||
8616 | ||||
8617 | G_OBJECT_CLASS (class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((class)), (((GType) ((20) << (2))))))))->finalize = finalize; | |||
8618 | G_OBJECT_CLASS (class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass *) ((class)), (((GType) ((20) << (2))))))))->constructor = baul_file_constructor; | |||
8619 | ||||
8620 | signals[CHANGED] = | |||
8621 | g_signal_new ("changed", | |||
8622 | G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type), | |||
8623 | G_SIGNAL_RUN_LAST, | |||
8624 | G_STRUCT_OFFSET (BaulFileClass, changed)((glong) __builtin_offsetof(BaulFileClass, changed)), | |||
8625 | NULL((void*)0), NULL((void*)0), | |||
8626 | g_cclosure_marshal_VOID__VOID, | |||
8627 | G_TYPE_NONE((GType) ((1) << (2))), 0); | |||
8628 | ||||
8629 | signals[UPDATED_DEEP_COUNT_IN_PROGRESS] = | |||
8630 | g_signal_new ("updated_deep_count_in_progress", | |||
8631 | G_TYPE_FROM_CLASS (class)(((GTypeClass*) (class))->g_type), | |||
8632 | G_SIGNAL_RUN_LAST, | |||
8633 | G_STRUCT_OFFSET (BaulFileClass, updated_deep_count_in_progress)((glong) __builtin_offsetof(BaulFileClass, updated_deep_count_in_progress )), | |||
8634 | NULL((void*)0), NULL((void*)0), | |||
8635 | g_cclosure_marshal_VOID__VOID, | |||
8636 | G_TYPE_NONE((GType) ((1) << (2))), 0); | |||
8637 | ||||
8638 | eel_g_settings_add_auto_enum (baul_preferences, | |||
8639 | BAUL_PREFERENCES_DATE_FORMAT"date-format", | |||
8640 | &date_format_pref); | |||
8641 | ||||
8642 | thumbnail_limit_changed_callback (NULL((void*)0)); | |||
8643 | g_signal_connect_swapped (baul_preferences,g_signal_connect_data ((baul_preferences), ("changed::" "thumbnail-limit" ), (((GCallback) (thumbnail_limit_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8644 | "changed::" BAUL_PREFERENCES_IMAGE_FILE_THUMBNAIL_LIMIT,g_signal_connect_data ((baul_preferences), ("changed::" "thumbnail-limit" ), (((GCallback) (thumbnail_limit_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8645 | G_CALLBACK (thumbnail_limit_changed_callback),g_signal_connect_data ((baul_preferences), ("changed::" "thumbnail-limit" ), (((GCallback) (thumbnail_limit_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8646 | NULL)g_signal_connect_data ((baul_preferences), ("changed::" "thumbnail-limit" ), (((GCallback) (thumbnail_limit_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED); | |||
8647 | thumbnail_size_changed_callback (NULL((void*)0)); | |||
8648 | g_signal_connect_swapped (baul_icon_view_preferences,g_signal_connect_data ((baul_icon_view_preferences), ("changed::" "thumbnail-size"), (((GCallback) (thumbnail_size_changed_callback ))), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8649 | "changed::" BAUL_PREFERENCES_ICON_VIEW_THUMBNAIL_SIZE,g_signal_connect_data ((baul_icon_view_preferences), ("changed::" "thumbnail-size"), (((GCallback) (thumbnail_size_changed_callback ))), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8650 | G_CALLBACK (thumbnail_size_changed_callback),g_signal_connect_data ((baul_icon_view_preferences), ("changed::" "thumbnail-size"), (((GCallback) (thumbnail_size_changed_callback ))), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8651 | NULL)g_signal_connect_data ((baul_icon_view_preferences), ("changed::" "thumbnail-size"), (((GCallback) (thumbnail_size_changed_callback ))), (((void*)0)), ((void*)0), G_CONNECT_SWAPPED); | |||
8652 | show_thumbnails_changed_callback (NULL((void*)0)); | |||
8653 | g_signal_connect_swapped (baul_preferences,g_signal_connect_data ((baul_preferences), ("changed::" "show-image-thumbnails" ), (((GCallback) (show_thumbnails_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8654 | "changed::" BAUL_PREFERENCES_SHOW_IMAGE_FILE_THUMBNAILS,g_signal_connect_data ((baul_preferences), ("changed::" "show-image-thumbnails" ), (((GCallback) (show_thumbnails_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8655 | G_CALLBACK (show_thumbnails_changed_callback),g_signal_connect_data ((baul_preferences), ("changed::" "show-image-thumbnails" ), (((GCallback) (show_thumbnails_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED) | |||
8656 | NULL)g_signal_connect_data ((baul_preferences), ("changed::" "show-image-thumbnails" ), (((GCallback) (show_thumbnails_changed_callback))), (((void *)0)), ((void*)0), G_CONNECT_SWAPPED); | |||
8657 | ||||
8658 | icon_theme = ctk_icon_theme_get_default (); | |||
8659 | g_signal_connect_object (icon_theme, | |||
8660 | "changed", | |||
8661 | G_CALLBACK (icon_theme_changed_callback)((GCallback) (icon_theme_changed_callback)), | |||
8662 | NULL((void*)0), 0); | |||
8663 | ||||
8664 | g_signal_connect (baul_signaller_get_current (),g_signal_connect_data ((baul_signaller_get_current ()), ("mime_data_changed" ), (((GCallback) (mime_type_data_changed_callback))), (((void *)0)), ((void*)0), (GConnectFlags) 0) | |||
8665 | "mime_data_changed",g_signal_connect_data ((baul_signaller_get_current ()), ("mime_data_changed" ), (((GCallback) (mime_type_data_changed_callback))), (((void *)0)), ((void*)0), (GConnectFlags) 0) | |||
8666 | G_CALLBACK (mime_type_data_changed_callback),g_signal_connect_data ((baul_signaller_get_current ()), ("mime_data_changed" ), (((GCallback) (mime_type_data_changed_callback))), (((void *)0)), ((void*)0), (GConnectFlags) 0) | |||
8667 | NULL)g_signal_connect_data ((baul_signaller_get_current ()), ("mime_data_changed" ), (((GCallback) (mime_type_data_changed_callback))), (((void *)0)), ((void*)0), (GConnectFlags) 0); | |||
8668 | } | |||
8669 | ||||
8670 | static void | |||
8671 | baul_file_add_emblem (BaulFile *file, | |||
8672 | const char *emblem_name) | |||
8673 | { | |||
8674 | if (file->details->pending_info_providers) { | |||
8675 | file->details->pending_extension_emblems = g_list_prepend (file->details->pending_extension_emblems, | |||
8676 | g_strdup (emblem_name)); | |||
8677 | } else { | |||
8678 | file->details->extension_emblems = g_list_prepend (file->details->extension_emblems, | |||
8679 | g_strdup (emblem_name)); | |||
8680 | } | |||
8681 | ||||
8682 | baul_file_changed (file); | |||
8683 | } | |||
8684 | ||||
8685 | static void | |||
8686 | baul_file_add_string_attribute (BaulFile *file, | |||
8687 | const char *attribute_name, | |||
8688 | const char *value) | |||
8689 | { | |||
8690 | if (file->details->pending_info_providers) { | |||
8691 | /* Lazily create hashtable */ | |||
8692 | if (!file->details->pending_extension_attributes) { | |||
8693 | file->details->pending_extension_attributes = | |||
8694 | g_hash_table_new_full (g_direct_hash, g_direct_equal, | |||
8695 | NULL((void*)0), | |||
8696 | (GDestroyNotify)g_free); | |||
8697 | } | |||
8698 | g_hash_table_insert (file->details->pending_extension_attributes, | |||
8699 | GINT_TO_POINTER (g_quark_from_string (attribute_name))((gpointer) (glong) (g_quark_from_string (attribute_name))), | |||
8700 | g_strdup (value)); | |||
8701 | } else { | |||
8702 | if (!file->details->extension_attributes) { | |||
8703 | file->details->extension_attributes = | |||
8704 | g_hash_table_new_full (g_direct_hash, g_direct_equal, | |||
8705 | NULL((void*)0), | |||
8706 | (GDestroyNotify)g_free); | |||
8707 | } | |||
8708 | g_hash_table_insert (file->details->extension_attributes, | |||
8709 | GINT_TO_POINTER (g_quark_from_string (attribute_name))((gpointer) (glong) (g_quark_from_string (attribute_name))), | |||
8710 | g_strdup (value)); | |||
8711 | } | |||
8712 | ||||
8713 | baul_file_changed (file); | |||
8714 | } | |||
8715 | ||||
8716 | static void | |||
8717 | baul_file_invalidate_extension_info (BaulFile *file) | |||
8718 | { | |||
8719 | baul_file_invalidate_attributes (file, BAUL_FILE_ATTRIBUTE_EXTENSION_INFO); | |||
8720 | } | |||
8721 | ||||
8722 | void | |||
8723 | baul_file_info_providers_done (BaulFile *file) | |||
8724 | { | |||
8725 | g_list_free_full (file->details->extension_emblems, g_free); | |||
8726 | file->details->extension_emblems = file->details->pending_extension_emblems; | |||
8727 | file->details->pending_extension_emblems = NULL((void*)0); | |||
8728 | ||||
8729 | if (file->details->extension_attributes) { | |||
8730 | g_hash_table_destroy (file->details->extension_attributes); | |||
8731 | } | |||
8732 | ||||
8733 | file->details->extension_attributes = file->details->pending_extension_attributes; | |||
8734 | file->details->pending_extension_attributes = NULL((void*)0); | |||
8735 | ||||
8736 | baul_file_changed (file); | |||
8737 | } | |||
8738 | ||||
8739 | static void | |||
8740 | baul_file_info_iface_init (BaulFileInfoIface *iface) | |||
8741 | { | |||
8742 | iface->is_gone = baul_file_is_gone; | |||
8743 | iface->get_name = baul_file_get_name; | |||
8744 | iface->get_file_type = baul_file_get_file_type; | |||
8745 | iface->get_location = baul_file_get_location; | |||
8746 | iface->get_uri = baul_file_get_uri; | |||
8747 | iface->get_parent_location = baul_file_get_parent_location; | |||
8748 | iface->get_parent_uri = baul_file_get_parent_uri; | |||
8749 | iface->get_parent_info = baul_file_get_parent; | |||
8750 | iface->get_mount = baul_file_get_mount; | |||
8751 | iface->get_uri_scheme = baul_file_get_uri_scheme; | |||
8752 | iface->get_activation_uri = baul_file_get_activation_uri; | |||
8753 | iface->get_mime_type = baul_file_get_mime_type; | |||
8754 | iface->is_mime_type = baul_file_is_mime_type; | |||
8755 | iface->is_directory = baul_file_is_directory; | |||
8756 | iface->can_write = baul_file_can_write; | |||
8757 | iface->add_emblem = baul_file_add_emblem; | |||
8758 | iface->get_string_attribute = baul_file_get_string_attribute; | |||
8759 | iface->add_string_attribute = baul_file_add_string_attribute; | |||
8760 | iface->invalidate_extension_info = baul_file_invalidate_extension_info; | |||
8761 | } | |||
8762 | ||||
8763 | #if !defined (BAUL_OMIT_SELF_CHECK) | |||
8764 | ||||
8765 | void | |||
8766 | baul_self_check_file (void) | |||
8767 | { | |||
8768 | BaulFile *file_1; | |||
8769 | BaulFile *file_2; | |||
8770 | GList *list; | |||
8771 | ||||
8772 | /* refcount checks */ | |||
8773 | ||||
8774 | EEL_CHECK_INTEGER_RESULT (baul_directory_number_outstanding (), 0)do { eel_before_check ("baul_directory_number_outstanding ()" , "baul-file.c", 8774); eel_check_integer_result (baul_directory_number_outstanding (), 0); } while (0); | |||
8775 | ||||
8776 | file_1 = baul_file_get_by_uri ("file:///home/"); | |||
8777 | ||||
8778 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8778); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1 )), (((GType) ((20) << (2))))))))->ref_count, 1); } while (0); | |||
8779 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1->details->directory)->ref_count, 1)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1->details->directory)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8779); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1 ->details->directory)), (((GType) ((20) << (2)))) ))))->ref_count, 1); } while (0); | |||
8780 | EEL_CHECK_INTEGER_RESULT (baul_directory_number_outstanding (), 1)do { eel_before_check ("baul_directory_number_outstanding ()" , "baul-file.c", 8780); eel_check_integer_result (baul_directory_number_outstanding (), 1); } while (0); | |||
8781 | ||||
8782 | baul_file_unref (file_1); | |||
8783 | ||||
8784 | EEL_CHECK_INTEGER_RESULT (baul_directory_number_outstanding (), 0)do { eel_before_check ("baul_directory_number_outstanding ()" , "baul-file.c", 8784); eel_check_integer_result (baul_directory_number_outstanding (), 0); } while (0); | |||
8785 | ||||
8786 | file_1 = baul_file_get_by_uri ("file:///etc"); | |||
8787 | file_2 = baul_file_get_by_uri ("file:///usr"); | |||
8788 | ||||
8789 | list = NULL((void*)0); | |||
8790 | list = g_list_prepend (list, file_1); | |||
8791 | list = g_list_prepend (list, file_2); | |||
8792 | ||||
8793 | baul_file_list_ref (list); | |||
8794 | ||||
8795 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 2)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8795); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1 )), (((GType) ((20) << (2))))))))->ref_count, 2); } while (0); | |||
8796 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 2)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_2)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8796); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_2 )), (((GType) ((20) << (2))))))))->ref_count, 2); } while (0); | |||
8797 | ||||
8798 | baul_file_list_unref (list); | |||
8799 | ||||
8800 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8800); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1 )), (((GType) ((20) << (2))))))))->ref_count, 1); } while (0); | |||
8801 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 1)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_2)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8801); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_2 )), (((GType) ((20) << (2))))))))->ref_count, 1); } while (0); | |||
8802 | ||||
8803 | baul_file_list_free (list); | |||
8804 | ||||
8805 | EEL_CHECK_INTEGER_RESULT (baul_directory_number_outstanding (), 0)do { eel_before_check ("baul_directory_number_outstanding ()" , "baul-file.c", 8805); eel_check_integer_result (baul_directory_number_outstanding (), 0); } while (0); | |||
8806 | ||||
8807 | ||||
8808 | /* name checks */ | |||
8809 | file_1 = baul_file_get_by_uri ("file:///home/"); | |||
8810 | ||||
8811 | EEL_CHECK_STRING_RESULT (baul_file_get_name (file_1), "home")do { eel_before_check ("baul_file_get_name (file_1)", "baul-file.c" , 8811); eel_check_string_result (baul_file_get_name (file_1) , "home"); } while (0); | |||
8812 | ||||
8813 | EEL_CHECK_BOOLEAN_RESULT (baul_file_get_by_uri ("file:///home/") == file_1, TRUE)do { eel_before_check ("baul_file_get_by_uri (\"file:///home/\") == file_1" , "baul-file.c", 8813); eel_check_boolean_result (baul_file_get_by_uri ("file:///home/") == file_1, (!(0))); } while (0); | |||
8814 | baul_file_unref (file_1); | |||
8815 | ||||
8816 | EEL_CHECK_BOOLEAN_RESULT (baul_file_get_by_uri ("file:///home") == file_1, TRUE)do { eel_before_check ("baul_file_get_by_uri (\"file:///home\") == file_1" , "baul-file.c", 8816); eel_check_boolean_result (baul_file_get_by_uri ("file:///home") == file_1, (!(0))); } while (0); | |||
8817 | baul_file_unref (file_1); | |||
8818 | ||||
8819 | baul_file_unref (file_1); | |||
8820 | ||||
8821 | file_1 = baul_file_get_by_uri ("file:///home"); | |||
8822 | EEL_CHECK_STRING_RESULT (baul_file_get_name (file_1), "home")do { eel_before_check ("baul_file_get_name (file_1)", "baul-file.c" , 8822); eel_check_string_result (baul_file_get_name (file_1) , "home"); } while (0); | |||
8823 | baul_file_unref (file_1); | |||
8824 | ||||
8825 | #if 0 | |||
8826 | /* ALEX: I removed this, because it was breaking distchecks. | |||
8827 | * It used to work, but when canonical uris changed from | |||
8828 | * foo: to foo:/// it broke. I don't expect it to matter | |||
8829 | * in real life */ | |||
8830 | file_1 = baul_file_get_by_uri (":"); | |||
8831 | EEL_CHECK_STRING_RESULT (baul_file_get_name (file_1), ":")do { eel_before_check ("baul_file_get_name (file_1)", "baul-file.c" , 8831); eel_check_string_result (baul_file_get_name (file_1) , ":"); } while (0); | |||
8832 | baul_file_unref (file_1); | |||
8833 | #endif | |||
8834 | ||||
8835 | file_1 = baul_file_get_by_uri ("eazel:"); | |||
8836 | EEL_CHECK_STRING_RESULT (baul_file_get_name (file_1), "eazel")do { eel_before_check ("baul_file_get_name (file_1)", "baul-file.c" , 8836); eel_check_string_result (baul_file_get_name (file_1) , "eazel"); } while (0); | |||
8837 | baul_file_unref (file_1); | |||
8838 | ||||
8839 | /* sorting */ | |||
8840 | file_1 = baul_file_get_by_uri ("file:///etc"); | |||
8841 | file_2 = baul_file_get_by_uri ("file:///usr"); | |||
8842 | ||||
8843 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8843); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_1 )), (((GType) ((20) << (2))))))))->ref_count, 1); } while (0); | |||
8844 | EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 1)do { eel_before_check ("((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_2)), (((GType) ((20) << (2))))))))->ref_count" , "baul-file.c", 8844); eel_check_integer_result (((((GObject *) (void *) g_type_check_instance_cast ((GTypeInstance*) ((file_2 )), (((GType) ((20) << (2))))))))->ref_count, 1); } while (0); | |||
8845 | ||||
8846 | EEL_CHECK_BOOLEAN_RESULT (baul_file_compare_for_sort (file_1, file_2, BAUL_FILE_SORT_BY_DISPLAY_NAME, FALSE, FALSE) < 0, TRUE)do { eel_before_check ("baul_file_compare_for_sort (file_1, file_2, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (0)) < 0" , "baul-file.c", 8846); eel_check_boolean_result (baul_file_compare_for_sort (file_1, file_2, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (0)) < 0, (!(0))); } while (0); | |||
8847 | EEL_CHECK_BOOLEAN_RESULT (baul_file_compare_for_sort (file_1, file_2, BAUL_FILE_SORT_BY_DISPLAY_NAME, FALSE, TRUE) > 0, TRUE)do { eel_before_check ("baul_file_compare_for_sort (file_1, file_2, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (!(0))) > 0" , "baul-file.c", 8847); eel_check_boolean_result (baul_file_compare_for_sort (file_1, file_2, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (!(0)) ) > 0, (!(0))); } while (0); | |||
8848 | EEL_CHECK_BOOLEAN_RESULT (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, FALSE, FALSE) == 0, TRUE)do { eel_before_check ("baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (0)) == 0" , "baul-file.c", 8848); eel_check_boolean_result (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (0)) == 0, (!(0))); } while (0); | |||
8849 | EEL_CHECK_BOOLEAN_RESULT (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, TRUE, FALSE) == 0, TRUE)do { eel_before_check ("baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (!(0)), (0)) == 0" , "baul-file.c", 8849); eel_check_boolean_result (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (!(0)), (0) ) == 0, (!(0))); } while (0); | |||
8850 | EEL_CHECK_BOOLEAN_RESULT (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, FALSE, TRUE) == 0, TRUE)do { eel_before_check ("baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (!(0))) == 0" , "baul-file.c", 8850); eel_check_boolean_result (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (0), (!(0)) ) == 0, (!(0))); } while (0); | |||
8851 | EEL_CHECK_BOOLEAN_RESULT (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, TRUE, TRUE) == 0, TRUE)do { eel_before_check ("baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (!(0)), (!(0))) == 0" , "baul-file.c", 8851); eel_check_boolean_result (baul_file_compare_for_sort (file_1, file_1, BAUL_FILE_SORT_BY_DISPLAY_NAME, (!(0)), (!( 0))) == 0, (!(0))); } while (0); | |||
8852 | ||||
8853 | baul_file_unref (file_1); | |||
8854 | baul_file_unref (file_2); | |||
8855 | } | |||
8856 | ||||
8857 | #endif /* !BAUL_OMIT_SELF_CHECK */ |