← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/cairo-dock-plug-ins/oneiric

« back to all changes in this revision

Viewing changes to kde-integration/src/applet-vfs.c

Tags: upstream-2.1.3-6
Import upstream version 2.1.3-6

Show diffs side-by-side

added added

removed removed

Lines of Context:
kde-integration/src/applet-vfs.c
 
1
/**
 
2
* This file is a part of the Cairo-Dock project
 
3
*
 
4
* Copyright : (C) see the 'copyright' file.
 
5
* E-mail    : see the 'copyright' file.
 
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
 
9
* as published by the Free Software Foundation; either version 3
 
10
* of the 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
 
15
* GNU General Public License for more details.
 
16
* You should have received a copy of the GNU General Public License
 
17
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
18
*/
 
19
 
 
20
#include <string.h>
 
21
 
 
22
#include <glib.h>
 
23
#include <gio/gio.h>
 
24
 
 
25
#include "applet-vfs.h"
 
26
 
 
27
static GHashTable *s_hMonitorHandleTable = NULL;
 
28
 
 
29
 
 
30
static void _vfs_backend_free_monitor_data (gpointer *data)
 
31
{
 
32
        if (data != NULL)
 
33
        {
 
34
                GFileMonitor *pHandle = data[2];
 
35
                g_file_monitor_cancel (pHandle);  // le GFileMonitor est-il libere lors du g_file_monitor_cancel () ?
 
36
                g_free (data);
 
37
        }
 
38
}
 
39
 
 
40
gboolean init_vfs_backend (void)
 
41
{
 
42
        if (s_hMonitorHandleTable != NULL)
 
43
                g_hash_table_destroy (s_hMonitorHandleTable);
 
44
        
 
45
        s_hMonitorHandleTable = g_hash_table_new_full (g_str_hash,
 
46
                g_str_equal,
 
47
                g_free,
 
48
                (GDestroyNotify) _vfs_backend_free_monitor_data);
 
49
        
 
50
        GVfs *vfs = g_vfs_get_default ();
 
51
        //return (vfs != NULL && g_vfs_is_active (vfs));
 
52
        return TRUE;
 
53
}
 
54
 
 
55
void stop_vfs_backend (void)
 
56
{
 
57
        if (s_hMonitorHandleTable != NULL)
 
58
        {
 
59
                g_hash_table_destroy (s_hMonitorHandleTable);
 
60
                s_hMonitorHandleTable = NULL;
 
61
        }
 
62
}
 
63
 
 
64
 
 
65
static gchar *_cd_get_icon_path (GIcon *pIcon)
 
66
{
 
67
        gchar *cIconPath = NULL;
 
68
        if (G_IS_THEMED_ICON (pIcon))
 
69
        {
 
70
                const gchar * const *cFileNames = g_themed_icon_get_names (G_THEMED_ICON (pIcon));
 
71
                //cd_message ("icones possibles : %s\n", g_strjoinv (":", (gchar **) cFileNames));
 
72
                int i;
 
73
                for (i = 0; cFileNames[i] != NULL && cIconPath == NULL; i ++)
 
74
                {
 
75
                        //cd_message (" une icone possible est : %s\n", cFileNames[i]);
 
76
                        cIconPath = cairo_dock_search_icon_s_path (cFileNames[i]);
 
77
                        //cd_message ("  chemin trouve : %s\n", cIconPath);
 
78
                }
 
79
        }
 
80
        else if (G_IS_FILE_ICON (pIcon))
 
81
        {
 
82
                GFile *pFile = g_file_icon_get_file (G_FILE_ICON (pIcon));
 
83
                cIconPath = g_file_get_basename (pFile);
 
84
                //cd_message (" file_icon => %s\n", cIconPath);
 
85
        }
 
86
        return cIconPath;
 
87
}
 
88
 
 
89
 
 
90
static void _cd_find_mount_from_volume_name (const gchar *cVolumeName, GMount **pFoundMount, gchar **cURI, gchar **cIconName)
 
91
{
 
92
        g_return_if_fail (cVolumeName != NULL);
 
93
        cd_message ("%s (%s)", __func__, cVolumeName);
 
94
        GFile *pFile = g_file_new_for_uri ("computer://");
 
95
        GError *erreur = NULL;
 
96
        const gchar *cAttributes = G_FILE_ATTRIBUTE_STANDARD_TYPE","
 
97
                G_FILE_ATTRIBUTE_STANDARD_NAME","
 
98
                G_FILE_ATTRIBUTE_STANDARD_ICON","
 
99
                G_FILE_ATTRIBUTE_STANDARD_TARGET_URI","
 
100
                G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE;
 
101
        GFileEnumerator *pFileEnum = g_file_enumerate_children (pFile,
 
102
                cAttributes,
 
103
                G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 
104
                NULL,
 
105
                &erreur);
 
106
        //g_object_unref (pFile);
 
107
        if (erreur != NULL)
 
108
        {
 
109
                cd_warning ("gnome_integration : %s", erreur->message);
 
110
                g_error_free (erreur);
 
111
                return ;
 
112
        }
 
113
        
 
114
        GList *pIconList = NULL;
 
115
        Icon *icon;
 
116
        GFileInfo *pFileInfo;
 
117
        do
 
118
        {
 
119
                pFileInfo = g_file_enumerator_next_file (pFileEnum, NULL, &erreur);
 
120
                if (erreur != NULL)
 
121
                {
 
122
                        cd_warning ("gnome_integration : %s", erreur->message);
 
123
                        g_error_free (erreur);
 
124
                        erreur = NULL;
 
125
                }
 
126
                else
 
127
                {
 
128
                        if (pFileInfo == NULL)
 
129
                                break ;
 
130
                        GFileType iFileType = g_file_info_get_file_type (pFileInfo);
 
131
                        if (iFileType == G_FILE_TYPE_MOUNTABLE)
 
132
                        {
 
133
                                const gchar *cFileName = g_file_info_get_name (pFileInfo);
 
134
                                cd_message ("  test de  %s...", cFileName);
 
135
                                const gchar *cTargetURI = g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
 
136
                                
 
137
                                GMount *pMount = NULL;
 
138
                                if (cTargetURI != NULL)
 
139
                                {
 
140
                                        GFile *file = g_file_new_for_uri (cTargetURI);
 
141
                                        pMount = g_file_find_enclosing_mount (file, NULL, NULL);
 
142
                                        //g_object_unref (file);
 
143
                                }
 
144
                                if (pMount != NULL)
 
145
                                {
 
146
                                        gchar *cName = g_mount_get_name (pMount);
 
147
                                        cd_message ("    mount : %s", cName);
 
148
                                        if (cName != NULL && strcmp (cName, cVolumeName) == 0)
 
149
                                        {
 
150
                                                cd_message ("TROUVE");
 
151
                                                *pFoundMount = pMount;
 
152
                                                *cURI = g_strconcat ("computer:///", cFileName, NULL);
 
153
                                                GIcon *pSystemIcon = g_mount_get_icon (pMount);
 
154
                                                *cIconName = _cd_get_icon_path (pSystemIcon);
 
155
                                                g_free (cName);
 
156
                                                break ;
 
157
                                        }
 
158
                                        g_free (cName);
 
159
                                }
 
160
                        }
 
161
                }
 
162
        } while (TRUE);
 
163
        //g_object_unref (pFileEnum);
 
164
}
 
165
 
 
166
static GDrive *_cd_find_drive_from_name (const gchar *cName)
 
167
{
 
168
        g_return_val_if_fail (cName != NULL, NULL);
 
169
        cd_message ("%s (%s)", __func__, cName);
 
170
        GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get ();
 
171
        GDrive *pFoundDrive = NULL;
 
172
        
 
173
        //\___________________ On chope les disques connectes (lecteur de CD/disquette/etc) et on liste leurs volumes.
 
174
        GList *pDrivesList = g_volume_monitor_get_connected_drives (pVolumeMonitor);
 
175
        GList *dl;
 
176
        GDrive *pDrive;
 
177
        gchar *cDriveName;
 
178
        for (dl = pDrivesList; dl != NULL; dl = dl->next)
 
179
        {
 
180
                pDrive = dl->data;
 
181
                if (pFoundDrive == NULL)
 
182
                {
 
183
                        cDriveName = g_drive_get_name  (pDrive);
 
184
                        cd_message ("  drive '%s'", cDriveName);
 
185
                        if (cDriveName != NULL && strcmp (cDriveName, cName) == 0)
 
186
                                pFoundDrive = pDrive;
 
187
                        else
 
188
                                g_object_unref (pDrive);
 
189
                        //g_free (cDriveName);
 
190
                }
 
191
                else
 
192
                        g_object_unref (pDrive);
 
193
        }
 
194
        g_list_free (pDrivesList);
 
195
        return pFoundDrive;
 
196
}
 
197
static gchar *_cd_find_volume_name_from_drive_name (const gchar *cName)
 
198
{
 
199
        g_return_val_if_fail (cName != NULL, NULL);
 
200
        cd_message ("%s (%s)", __func__, cName);
 
201
        GDrive *pDrive = _cd_find_drive_from_name (cName);
 
202
        g_return_val_if_fail (pDrive != NULL, NULL);
 
203
        
 
204
        gchar *cVolumeName = NULL;
 
205
        GList *pAssociatedVolumes = g_drive_get_volumes (pDrive);
 
206
        if (pAssociatedVolumes != NULL)
 
207
        {
 
208
                GVolume *pVolume;
 
209
                GList *av;
 
210
                if (pAssociatedVolumes->next != NULL)
 
211
                {
 
212
                        cd_message ("ce disque contient plus d'un volume, on garde le nom du disque plutot que de selectionner le nom d'un volume");
 
213
                        cd_message ("Pour info, la liste des volumes disponibles sur ce disque est :");
 
214
                        for (av = pAssociatedVolumes; av != NULL; av = av->next)
 
215
                        {
 
216
                                pVolume = av->data;
 
217
                                cd_message ("  - %s", g_volume_get_name  (pVolume));
 
218
                                /*if (cVolumeName == NULL)
 
219
                                        cVolumeName = g_volume_get_name  (pVolume);
 
220
                                else
 
221
                                        cd_warning ("gnome-integration : this drive (%s) has more than 1 volume but we only consider the first one (%s), ignoring %s", cName, cVolumeName, g_volume_get_name  (pVolume));*/
 
222
                                g_object_unref (pVolume);
 
223
                        }
 
224
                }
 
225
                else
 
226
                {
 
227
                        return g_strdup ("discard");
 
228
                        pVolume = pAssociatedVolumes->data;
 
229
                        cVolumeName = g_volume_get_name  (pVolume);
 
230
                        g_object_unref (pVolume);
 
231
                        cd_message ("ce disque contient 1 seul volume (%s), on prend son nom", cVolumeName);
 
232
                }
 
233
                g_list_free (pAssociatedVolumes);
 
234
        }
 
235
        //g_object_unref (pDrive);
 
236
        return cVolumeName;
 
237
}
 
238
static gboolean _cd_find_can_eject_from_drive_name (const gchar *cName)
 
239
{
 
240
        cd_debug ("%s (%s)", __func__, cName);
 
241
        GDrive *pDrive = _cd_find_drive_from_name (cName);
 
242
        g_return_val_if_fail (pDrive != NULL, FALSE);
 
243
        
 
244
        gboolean bCanEject = g_drive_can_eject (pDrive);
 
245
        //g_object_unref (pDrive);
 
246
        return bCanEject;
 
247
}
 
248
 
 
249
void vfs_backend_get_file_info (const gchar *cBaseURI, gchar **cName, gchar **cURI, gchar **cIconName, gboolean *bIsDirectory, int *iVolumeID, double *fOrder, CairoDockFMSortType iSortType)
 
250
{
 
251
        g_return_if_fail (cBaseURI != NULL);
 
252
        cd_message ("%s (%s)", __func__, cBaseURI);
 
253
        
 
254
        /// gerer cas d'une URL d'une icone du bureau (x-nautilus-desktop://blablabla sous Gnome)...
 
255
        
 
256
        gchar *cFullURI;
 
257
        if (*cBaseURI == '/')
 
258
                cFullURI = g_filename_to_uri (cBaseURI, NULL, NULL);
 
259
        else
 
260
                cFullURI = g_strdup (cBaseURI);
 
261
        cd_message (" -> cFullURI : %s", cFullURI);
 
262
        
 
263
        *cURI = cFullURI;
 
264
        
 
265
        *cName = g_path_get_basename (cFullURI);
 
266
        
 
267
        /*KURL url(cFullURI);
 
268
        QString icon = KMimeType::iconForURL(url);
 
269
        **cIconName = g_strdup (icon.toUtf8().constData());
 
270
        
 
271
        gchar *cFileName = g_filename_from_uri (cBaseURI, NULL, NULL);
 
272
        *bIsDirectory = g_file_test (cFileName);
 
273
        g_free (cFileName);
 
274
        
 
275
        *iVolumeID = 0;
 
276
        
 
277
        *fOrder = 0.;*/
 
278
        
 
279
        
 
280
        
 
281
        GError *erreur = NULL;
 
282
        GFile *pFile = g_file_new_for_uri (cFullURI);
 
283
        
 
284
        const gchar *cQuery = G_FILE_ATTRIBUTE_STANDARD_TYPE","
 
285
                G_FILE_ATTRIBUTE_STANDARD_SIZE","
 
286
                G_FILE_ATTRIBUTE_TIME_MODIFIED","
 
287
                G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE","
 
288
                G_FILE_ATTRIBUTE_STANDARD_NAME","
 
289
                G_FILE_ATTRIBUTE_STANDARD_ICON","
 
290
                G_FILE_ATTRIBUTE_STANDARD_TARGET_URI","
 
291
                G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE;
 
292
        GFileInfo *pFileInfo = g_file_query_info (pFile,
 
293
                cQuery,
 
294
                G_FILE_QUERY_INFO_NONE,  /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
 
295
                NULL,
 
296
                &erreur);
 
297
        //g_object_unref (pFile);
 
298
        if (erreur != NULL)
 
299
        {
 
300
                cd_warning ("gnome_integration : %s", erreur->message);
 
301
                g_error_free (erreur);
 
302
                return ;
 
303
        }
 
304
        
 
305
        *cURI = cFullURI;
 
306
        const gchar *cFileName = g_file_info_get_name (pFileInfo);
 
307
        const gchar *cMimeType = g_file_info_get_content_type (pFileInfo);
 
308
        GFileType iFileType = g_file_info_get_file_type (pFileInfo);
 
309
        
 
310
        if (iSortType == CAIRO_DOCK_FM_SORT_BY_DATE)
 
311
        {
 
312
                GTimeVal t;
 
313
                g_file_info_get_modification_time (pFileInfo, &t);
 
314
                *fOrder = t.tv_sec;
 
315
        }
 
316
        else if (iSortType == CAIRO_DOCK_FM_SORT_BY_SIZE)
 
317
                *fOrder = g_file_info_get_size (pFileInfo);
 
318
        else if (iSortType == CAIRO_DOCK_FM_SORT_BY_TYPE)
 
319
                *fOrder = (cMimeType != NULL ? *((int *) cMimeType) : 0);
 
320
        else
 
321
                *fOrder = 0;
 
322
        
 
323
        *bIsDirectory = (iFileType == G_FILE_TYPE_DIRECTORY);
 
324
        cd_message (" => '%s' (mime:%s ; bIsDirectory:%d)", cFileName, cMimeType, *bIsDirectory);
 
325
        
 
326
        if (iFileType == G_FILE_TYPE_MOUNTABLE)
 
327
        {
 
328
                *cName = NULL;
 
329
                *iVolumeID = 1;
 
330
                
 
331
                const gchar *cTargetURI = g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
 
332
                cd_message ("  cTargetURI:%s", cTargetURI);
 
333
                GMount *pMount = NULL;
 
334
                if (cTargetURI != NULL)
 
335
                {
 
336
                        GFile *file = g_file_new_for_uri (cTargetURI);
 
337
                        pMount = g_file_find_enclosing_mount (file, NULL, NULL);
 
338
                        //g_object_unref (file);
 
339
                }
 
340
                if (pMount != NULL)
 
341
                {
 
342
                        *cName = g_mount_get_name (pMount);
 
343
                        cd_message ("un GMount existe (%s)",* cName);
 
344
                }
 
345
                else
 
346
                {
 
347
                        gchar *cMountName = g_strdup (cFileName);
 
348
                        gchar *str = strrchr (cMountName, '.');  // on vire l'extension ".volume" ou ".drive".
 
349
                        if (str != NULL)
 
350
                        {
 
351
                                *str = '\0';
 
352
                                if (strcmp (str+1, "link") == 0)  // pour les liens, on prend le nom du lien.
 
353
                                {
 
354
                                        if (strcmp (cMountName, "root") == 0)  // on remplace 'root' par un nom plus parlant, sinon on prendra le nom du lien.
 
355
                                        {
 
356
                                                *cName = g_strdup ("/");
 
357
                                        }
 
358
                                }
 
359
                                else if (strcmp (str+1, "drive") == 0)  // on cherche un nom plus parlant si possible.
 
360
                                {
 
361
                                        gchar *cVolumeName = _cd_find_volume_name_from_drive_name (cMountName);
 
362
                                        if (cVolumeName != NULL)
 
363
                                        {
 
364
                                                *cName = cVolumeName;
 
365
                                        }
 
366
                                }
 
367
                        }
 
368
                        if (*cName == NULL)
 
369
                                *cName = cMountName;
 
370
                        //else
 
371
                                //g_free (cMountName);
 
372
                }
 
373
                if (*cName ==  NULL)
 
374
                        *cName = g_strdup (cFileName);
 
375
        }
 
376
        else
 
377
        {
 
378
                *iVolumeID = 0;
 
379
                *cName = g_strdup (cFileName);
 
380
        }
 
381
        
 
382
        *cIconName = NULL;
 
383
        if (cMimeType != NULL && strncmp (cMimeType, "image", 5) == 0)
 
384
        {
 
385
                gchar *cHostname = NULL;
 
386
                GError *erreur = NULL;
 
387
                gchar *cFilePath = g_filename_from_uri (cBaseURI, &cHostname, &erreur);
 
388
                if (erreur != NULL)
 
389
                {
 
390
                        g_error_free (erreur);
 
391
                }
 
392
                else if (cHostname == NULL || strcmp (cHostname, "localhost") == 0)  // on ne recupere la vignette que sur les fichiers locaux.
 
393
                {
 
394
                        *cIconName = g_strdup (cFilePath);
 
395
                        cairo_dock_remove_html_spaces (*cIconName);
 
396
                }
 
397
                //g_free (cHostname);
 
398
        }
 
399
        if (*cIconName == NULL)
 
400
        {
 
401
                GIcon *pSystemIcon = g_file_info_get_icon (pFileInfo);
 
402
                if (pSystemIcon != NULL)
 
403
                {
 
404
                        *cIconName = _cd_get_icon_path (pSystemIcon);
 
405
                }
 
406
        }
 
407
        cd_message ("cIconName : %s", *cIconName);
 
408
        
 
409
        //*iVolumeID = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE);
 
410
        //cd_message ("ID : %d\n", *iVolumeID);
 
411
        //g_object_unref (pFileInfo);
 
412
}
 
413
 
 
414
static Icon *_cd_get_icon_for_volume (GVolume *pVolume, GMount *pMount)
 
415
{
 
416
        Icon *pNewIcon = NULL;
 
417
        GIcon *pIcon;
 
418
        GFile *pRootDir;
 
419
        
 
420
        if (pVolume != NULL)
 
421
                pMount = g_volume_get_mount (pVolume);
 
422
        else if (pMount == NULL)
 
423
                return NULL;
 
424
        
 
425
        if (pMount != NULL)  // ce volume est monte.
 
426
        {
 
427
                pNewIcon = g_new0 (Icon, 1);
 
428
                pNewIcon->cName = g_mount_get_name (pMount);
 
429
                
 
430
                pRootDir = g_mount_get_root (pMount);
 
431
                pNewIcon->cCommand = g_file_get_uri (pRootDir);
 
432
                //g_object_unref (pRootDir);
 
433
                
 
434
                pIcon = g_mount_get_icon (pMount);
 
435
                pNewIcon->cFileName = _cd_get_icon_path (pIcon);
 
436
                //g_object_unref (pIcon);
 
437
                
 
438
                //g_object_unref (pMount);
 
439
        }
 
440
        else  // ce volume est demonte, on le montre quand meme (l'automount peut etre off).
 
441
        {
 
442
                pNewIcon = g_new0 (Icon, 1);
 
443
                pNewIcon->cName = g_volume_get_name (pVolume);
 
444
                
 
445
                pIcon = g_volume_get_icon (pVolume);
 
446
                pNewIcon->cFileName = _cd_get_icon_path (pIcon);
 
447
                //g_object_unref (pIcon);
 
448
                
 
449
                pNewIcon->cCommand = g_strdup (pNewIcon->cName);
 
450
        }
 
451
        pNewIcon->iVolumeID = 1;
 
452
        pNewIcon->cBaseURI = g_strdup (pNewIcon->cCommand);
 
453
        cd_message (" => %s", pNewIcon->cCommand);
 
454
        return pNewIcon;
 
455
}
 
456
 
 
457
GList *vfs_backend_list_volumes (void)
 
458
{
 
459
        GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get ();
 
460
        GList *pIconsList = NULL;
 
461
        Icon *pNewIcon;
 
462
        
 
463
        //\___________________ On chope les disques connectes (lecteur de CD/disquette/etc) et on liste leurs volumes.
 
464
        GList *pDrivesList = g_volume_monitor_get_connected_drives (pVolumeMonitor);
 
465
        GList *pAssociatedVolumes;
 
466
        GList *dl, *av;
 
467
        GDrive *pDrive;
 
468
        GVolume *pVolume;
 
469
        for (dl = pDrivesList; dl != NULL; dl = dl->next)
 
470
        {
 
471
                pDrive = dl->data;
 
472
                cd_message ("drive '%s'", g_drive_get_name  (pDrive));
 
473
                
 
474
                pAssociatedVolumes = g_drive_get_volumes (pDrive);
 
475
                if (pAssociatedVolumes != NULL)
 
476
                {
 
477
                        for (av = pAssociatedVolumes; av != NULL; av = av->next)
 
478
                        {
 
479
                                pVolume = av->data;
 
480
                                cd_message (" + volume '%s'", g_volume_get_name  (pVolume));
 
481
                                pNewIcon = _cd_get_icon_for_volume (pVolume, NULL);
 
482
                                if (pNewIcon != NULL)
 
483
                                        pIconsList = g_list_prepend (pIconsList, pNewIcon);
 
484
                                //g_object_unref (pVolume);
 
485
                        }
 
486
                        g_list_free (pAssociatedVolumes);
 
487
                }
 
488
                else  // le disque n'a aucun volume montable
 
489
                {
 
490
                        cd_message ("  le disque n'a aucun volume montable");
 
491
                        /*if (g_drive_is_media_removable (pDrive) && ! g_drive_is_media_check_automatic (pDrive))
 
492
                        {
 
493
                                g_drive_get_icon (pDrive);
 
494
                                g_drive_get_name (pDrive);
 
495
                        }*/
 
496
                }
 
497
                //g_object_unref (pDrive);
 
498
        }
 
499
        g_list_free (pDrivesList);
 
500
 
 
501
        //\___________________ On chope les volumes qui ne sont pas associes a un disque.
 
502
        GList *pVolumesList = g_volume_monitor_get_volumes (pVolumeMonitor);
 
503
        GList *v;
 
504
        for (v = pVolumesList; v != NULL; v = v->next)
 
505
        {
 
506
                pVolume = v->data;
 
507
                cd_message ("volume '%s'", g_volume_get_name  (pVolume));
 
508
                pDrive = g_volume_get_drive (pVolume);
 
509
                if (pDrive != NULL)  // on l'a deja liste dans la 1ere boucle.
 
510
                {
 
511
                        cd_message ("  drive '%s' est deja liste", g_drive_get_name (pDrive));
 
512
                        //g_object_unref (pDrive);
 
513
                }
 
514
                else
 
515
                {
 
516
                        cd_message (" + volume '%s'\n", g_volume_get_name  (pVolume));
 
517
                        if (pNewIcon != NULL)
 
518
                                pNewIcon = _cd_get_icon_for_volume (pVolume, NULL);
 
519
                        pIconsList = g_list_prepend (pIconsList, pNewIcon);
 
520
                }
 
521
                //g_object_unref (pVolume);
 
522
        }
 
523
        g_list_free (pVolumesList);
 
524
 
 
525
        //\___________________ On chope les points de montage qui n'ont pas de volumes. (montage de mtab, ftp, etc)
 
526
        GList *pMountsList = g_volume_monitor_get_mounts (pVolumeMonitor);
 
527
        GMount *pMount;
 
528
        GList *m;
 
529
        for (m = pMountsList; m != NULL; m = m->next)
 
530
        {
 
531
                pMount = m->data;
 
532
                cd_message ("mount '%s'", g_mount_get_name (pMount));
 
533
                pVolume = g_mount_get_volume (pMount);
 
534
                if (pVolume != NULL)  // on l'a deja liste precedemment.
 
535
                {
 
536
                        cd_message ("volume '%s' est deja liste", g_volume_get_name  (pVolume));
 
537
                        //g_object_unref (pVolume);
 
538
                }
 
539
                else
 
540
                {
 
541
                        cd_message ("+ volume '%s'", g_volume_get_name  (pVolume));
 
542
                        if (pNewIcon != NULL)
 
543
                                pNewIcon = _cd_get_icon_for_volume (NULL, pMount);
 
544
                        pIconsList = g_list_prepend (pIconsList, pNewIcon);
 
545
                }
 
546
                //g_object_unref (pMount);
 
547
        }
 
548
        g_list_free (pMountsList);
 
549
        
 
550
        return pIconsList;
 
551
}
 
552
 
 
553
GList *vfs_backend_list_directory (const gchar *cBaseURI, CairoDockFMSortType iSortType, int iNewIconsType, gboolean bListHiddenFiles, gchar **cFullURI)
 
554
{
 
555
        g_return_val_if_fail (cBaseURI != NULL, NULL);
 
556
        cd_message ("%s (%s)", __func__, cBaseURI);
 
557
        
 
558
        gchar *cURI;
 
559
        gboolean bAddHome = FALSE;
 
560
        if (strcmp (cBaseURI, CAIRO_DOCK_FM_VFS_ROOT) == 0)
 
561
        {
 
562
                cURI = g_strdup ("computer://");
 
563
                bAddHome = TRUE;
 
564
                ///*cFullURI = cURI;
 
565
                ///return vfs_backend_list_volumes ();
 
566
                //vfs_backend_list_volumes ();
 
567
        }
 
568
        else if (strcmp (cBaseURI, CAIRO_DOCK_FM_NETWORK) == 0)
 
569
                cURI = g_strdup ("network://");
 
570
        else
 
571
                cURI = (*cBaseURI == '/' ? g_strconcat ("file://", cBaseURI, NULL) : g_strdup (cBaseURI));
 
572
        *cFullURI = cURI;
 
573
        
 
574
        GFile *pFile = g_file_new_for_uri (cURI);
 
575
        GError *erreur = NULL;
 
576
        const gchar *cAttributes = G_FILE_ATTRIBUTE_STANDARD_TYPE","
 
577
                G_FILE_ATTRIBUTE_STANDARD_SIZE","
 
578
                G_FILE_ATTRIBUTE_TIME_MODIFIED","
 
579
                G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE","
 
580
                G_FILE_ATTRIBUTE_STANDARD_NAME","
 
581
                G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN","
 
582
                G_FILE_ATTRIBUTE_STANDARD_ICON","
 
583
                G_FILE_ATTRIBUTE_STANDARD_TARGET_URI","
 
584
                G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE;
 
585
        GFileEnumerator *pFileEnum = g_file_enumerate_children (pFile,
 
586
                cAttributes,
 
587
                G_FILE_QUERY_INFO_NONE,  /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
 
588
                NULL,
 
589
                &erreur);
 
590
        //g_object_unref (pFile);
 
591
        if (erreur != NULL)
 
592
        {
 
593
                cd_warning ("gnome_integration : %s", erreur->message);
 
594
                g_error_free (erreur);
 
595
                return NULL;
 
596
        }
 
597
        
 
598
        int iOrder = 0;
 
599
        GList *pIconList = NULL;
 
600
        Icon *icon;
 
601
        GFileInfo *pFileInfo;
 
602
        do
 
603
        {
 
604
                pFileInfo = g_file_enumerator_next_file (pFileEnum, NULL, &erreur);
 
605
                if (erreur != NULL)
 
606
                {
 
607
                        cd_warning ("gnome_integration : %s", erreur->message);
 
608
                        g_error_free (erreur);
 
609
                        erreur = NULL;
 
610
                        continue;
 
611
                }
 
612
                if (pFileInfo == NULL)
 
613
                        break ;
 
614
                
 
615
                gboolean bIsHidden = g_file_info_get_is_hidden (pFileInfo);
 
616
                if (bListHiddenFiles || ! bIsHidden)
 
617
                {
 
618
                        GFileType iFileType = g_file_info_get_file_type (pFileInfo);
 
619
                        GIcon *pFileIcon = g_file_info_get_icon (pFileInfo);
 
620
                        if (pFileIcon == NULL)
 
621
                        {
 
622
                                cd_message ("AUCUNE ICONE");
 
623
                                continue;
 
624
                        }
 
625
                        const gchar *cFileName = g_file_info_get_name (pFileInfo);
 
626
                        const gchar *cMimeType = g_file_info_get_content_type (pFileInfo);
 
627
                        gchar *cName = NULL;
 
628
                        
 
629
                        icon = g_new0 (Icon, 1);
 
630
                        icon->iType = iNewIconsType;
 
631
                        icon->cBaseURI = g_strconcat (*cFullURI, "/", cFileName, NULL);
 
632
                        cd_message ("+ %s (mime:%s)", icon->cBaseURI, cMimeType);
 
633
                        
 
634
                        if (iFileType == G_FILE_TYPE_MOUNTABLE)
 
635
                        {
 
636
                                const gchar *cTargetURI = g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
 
637
                                cd_message ("  c'est un point de montage correspondant a %s", cTargetURI);
 
638
                                
 
639
                                GMount *pMount = NULL;
 
640
                                if (cTargetURI != NULL)
 
641
                                {
 
642
                                        icon->cCommand = g_strdup (cTargetURI);
 
643
                                        GFile *file = g_file_new_for_uri (cTargetURI);
 
644
                                        pMount = g_file_find_enclosing_mount (file, NULL, NULL);
 
645
                                        //g_object_unref (file);
 
646
                                }
 
647
                                if (pMount != NULL)
 
648
                                {
 
649
                                        cName = g_mount_get_name (pMount);
 
650
                                        cd_message ("un GMount existe (%s)", cName);
 
651
                                        
 
652
                                        GVolume *volume = g_mount_get_volume (pMount);
 
653
                                        if (volume)
 
654
                                                cd_message ("  volume associe : %s", g_volume_get_name (volume));
 
655
                                        GDrive *drive = g_mount_get_drive (pMount);
 
656
                                        if (drive)
 
657
                                                cd_message ("  disque associe : %s", g_drive_get_name (drive));
 
658
                                        
 
659
                                        ///pFileIcon = g_mount_get_icon (pMount);
 
660
                                }
 
661
                                else
 
662
                                {
 
663
                                        cName = g_strdup (cFileName);
 
664
                                        gchar *str = strrchr (cName, '.');  // on vire l'extension ".volume" ou ".drive".
 
665
                                        if (str != NULL)
 
666
                                        {
 
667
                                                *str = '\0';
 
668
                                                if (strcmp (str+1, "link") == 0)
 
669
                                                {
 
670
                                                        if (strcmp (cName, "root") == 0)
 
671
                                                        {
 
672
                                                                g_free (cName);
 
673
                                                                cName = g_strdup ("/");
 
674
                                                        }
 
675
                                                }
 
676
                                                else if (strcmp (str+1, "drive") == 0)  // on cherche un nom plus parlant si possible.
 
677
                                                {
 
678
                                                        gchar *cVolumeName = _cd_find_volume_name_from_drive_name (cName);
 
679
                                                        if (cVolumeName != NULL)
 
680
                                                        {
 
681
                                                                g_free (cName);
 
682
                                                                g_free (cVolumeName);
 
683
                                                                continue;  /// apparemment il n'est plus necessaire d'afficher les .drives qui ont 1 (ou plusieurs ?) volumes, car ces derniers sont dans la liste, donc ca fait redondant.
 
684
                                                                /**if (strcmp (cVolumeName, "discard") == 0)
 
685
                                                                        continue;
 
686
                                                                g_free (cName);
 
687
                                                                cName = cVolumeName;*/
 
688
                                                        }
 
689
                                                }
 
690
                                        }
 
691
                                }
 
692
                                icon->iVolumeID = 1;
 
693
                                cd_message ("le nom de ce volume est : %s", cName);
 
694
                        }
 
695
                        else
 
696
                                cName = g_strdup (cFileName);
 
697
                        
 
698
                        if (icon->cCommand == NULL)
 
699
                                icon->cCommand = g_strdup (icon->cBaseURI);
 
700
                        icon->cName = cName;
 
701
                        icon->cFileName = NULL;
 
702
                        if (cMimeType != NULL && strncmp (cMimeType, "image", 5) == 0)
 
703
                        {
 
704
                                gchar *cHostname = NULL;
 
705
                                gchar *cFilePath = g_filename_from_uri (icon->cBaseURI, &cHostname, &erreur);
 
706
                                if (erreur != NULL)
 
707
                                {
 
708
                                        g_error_free (erreur);
 
709
                                        erreur = NULL;
 
710
                                }
 
711
                                else if (cHostname == NULL || strcmp (cHostname, "localhost") == 0)  // on ne recupere la vignette que sur les fichiers locaux.
 
712
                                {
 
713
                                        icon->cFileName = g_strdup (cFilePath);
 
714
                                        cairo_dock_remove_html_spaces (icon->cFileName);
 
715
                                }
 
716
                                g_free (cHostname);
 
717
                                g_free (cFilePath);
 
718
                        }
 
719
                        if (icon->cFileName == NULL)
 
720
                        {
 
721
                                icon->cFileName = _cd_get_icon_path (pFileIcon);
 
722
                                cd_message ("icon->cFileName : %s", icon->cFileName);
 
723
                        }
 
724
                        
 
725
                        if (iSortType == CAIRO_DOCK_FM_SORT_BY_SIZE)
 
726
                                icon->fOrder = g_file_info_get_size (pFileInfo);
 
727
                        else if (iSortType == CAIRO_DOCK_FM_SORT_BY_DATE)
 
728
                        {
 
729
                                GTimeVal t;
 
730
                                g_file_info_get_modification_time (pFileInfo, &t);
 
731
                                icon->fOrder = t.tv_sec;
 
732
                        }
 
733
                        else if (iSortType == CAIRO_DOCK_FM_SORT_BY_TYPE)
 
734
                                icon->fOrder = (cMimeType != NULL ? *((int *) cMimeType) : 0);
 
735
                        if (icon->fOrder == 0)  // un peu moyen mais mieux que rien non ?
 
736
                                icon->fOrder = iOrder;
 
737
                        pIconList = g_list_insert_sorted (pIconList,
 
738
                                icon,
 
739
                                (GCompareFunc) cairo_dock_compare_icons_order);
 
740
                        //g_list_prepend (pIconList, icon);
 
741
                        iOrder ++;
 
742
                }
 
743
        } while (TRUE);  // 'g_file_enumerator_close' est appelee lors du dernier 'g_file_enumerator_next_file'.
 
744
        
 
745
        if (bAddHome && pIconList != NULL)
 
746
        {
 
747
                icon = g_new0 (Icon, 1);
 
748
                icon->iType = iNewIconsType;
 
749
                icon->cBaseURI = g_strdup_printf ("file://%s", "/home");
 
750
                icon->cCommand = g_strdup ("/home");
 
751
                //icon->cCommand = g_strdup (icon->cBaseURI);
 
752
                icon->iVolumeID = 0;
 
753
                icon->cName = g_strdup ("home");
 
754
                Icon *pRootIcon = cairo_dock_get_icon_with_name (pIconList, "/");
 
755
                if (pRootIcon == NULL)
 
756
                {
 
757
                        pRootIcon = cairo_dock_get_first_icon (pIconList);
 
758
                        g_print ("domage ! (%s:%s)\n", pRootIcon->cCommand, pRootIcon->cName);
 
759
                }
 
760
                icon->cFileName = g_strdup (pRootIcon->cFileName);
 
761
                icon->fOrder = iOrder++;
 
762
                pIconList = g_list_insert_sorted (pIconList,
 
763
                        icon,
 
764
                        (GCompareFunc) cairo_dock_compare_icons_order);
 
765
        }
 
766
        
 
767
        if (iSortType == CAIRO_DOCK_FM_SORT_BY_NAME)
 
768
                pIconList = cairo_dock_sort_icons_by_name (pIconList);
 
769
        else
 
770
                pIconList = cairo_dock_sort_icons_by_order (pIconList);
 
771
        
 
772
        return pIconList;
 
773
}
 
774
 
 
775
 
 
776
 
 
777
static gchar *_cd_find_target_uri (const gchar *cBaseURI)
 
778
{
 
779
        GError *erreur = NULL;
 
780
        GFile *pFile = g_file_new_for_uri (cBaseURI);
 
781
        GFileInfo *pFileInfo = g_file_query_info (pFile,
 
782
                G_FILE_ATTRIBUTE_STANDARD_TARGET_URI,
 
783
                G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
 
784
                NULL,
 
785
                &erreur);
 
786
        g_object_unref (pFile);
 
787
        if (erreur != NULL)
 
788
        {
 
789
                cd_warning ("gnome-integration : %s", erreur->message);
 
790
                g_error_free (erreur);
 
791
                return NULL;
 
792
        }
 
793
        gchar *cTargetURI = g_strdup (g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI));
 
794
        g_object_unref (pFileInfo);
 
795
        return cTargetURI;
 
796
}
 
797
void vfs_backend_launch_uri (const gchar *cURI)
 
798
{
 
799
        g_return_if_fail (cURI != NULL);
 
800
        
 
801
        g_print ("%s (%s)", __func__, cURI);
 
802
        gchar *cCommand = g_strdup_printf ("kfmclient exec \"%s\"", cURI);
 
803
        cairo_dock_launch_command (cCommand);
 
804
        g_free (cCommand);
 
805
        
 
806
        /// tester ca :
 
807
        //KURL url(cURI);
 
808
        //new KRun(url);
 
809
}
 
810
 
 
811
GMount *_cd_find_mount_from_uri (const gchar *cURI, gchar **cTargetURI)
 
812
{
 
813
        cd_message ("%s (%s)", __func__, cURI);
 
814
        gchar *_cTargetURI = _cd_find_target_uri (cURI);
 
815
        
 
816
        GMount *pMount = NULL;
 
817
        if (_cTargetURI != NULL)
 
818
        {
 
819
                cd_message ("  pointe sur %s", _cTargetURI);
 
820
                GFile *file = g_file_new_for_uri (_cTargetURI);
 
821
                pMount = g_file_find_enclosing_mount (file, NULL, NULL);
 
822
                g_object_unref (file);
 
823
        }
 
824
        if (cTargetURI != NULL)
 
825
                *cTargetURI = _cTargetURI;
 
826
        else
 
827
                g_free (_cTargetURI);
 
828
        return pMount;
 
829
}
 
830
 
 
831
gchar *vfs_backend_is_mounted (const gchar *cURI, gboolean *bIsMounted)
 
832
{
 
833
        cd_message ("%s (%s)", __func__, cURI);
 
834
        gchar *cTargetURI = NULL;
 
835
        GMount *pMount = _cd_find_mount_from_uri (cURI, &cTargetURI);
 
836
        cd_message (" cTargetURI : %s", cTargetURI);
 
837
        if (pMount != NULL)
 
838
                *bIsMounted = TRUE;
 
839
        else
 
840
        {
 
841
                if (cTargetURI != NULL && strcmp (cTargetURI, "file:///") == 0)  // cas particulier ?
 
842
                        *bIsMounted = TRUE;
 
843
                else
 
844
                        *bIsMounted = FALSE;
 
845
        }
 
846
        return cTargetURI;
 
847
}
 
848
 
 
849
static gchar * _cd_find_drive_name_from_URI (const gchar *cURI)
 
850
{
 
851
        g_return_val_if_fail (cURI != NULL, NULL);
 
852
        if (strncmp (cURI, "computer:///", 12) == 0)
 
853
        {
 
854
                gchar *cDriveName = g_strdup (cURI+12);
 
855
                gchar *str = strrchr (cDriveName, '.');
 
856
                if (str != NULL)
 
857
                {
 
858
                        if (strcmp (str+1, "drive") == 0)
 
859
                        {
 
860
                                *str = '\0';
 
861
                                while (1)
 
862
                                {
 
863
                                        str = strchr (cDriveName, '\\');
 
864
                                        if (str == NULL)
 
865
                                                break;
 
866
                                        *str = '/';
 
867
                                }
 
868
                                return cDriveName;
 
869
                        }
 
870
                }
 
871
                g_free (cDriveName);
 
872
        }
 
873
        return NULL;
 
874
}
 
875
gboolean vfs_backend_can_eject (const gchar *cURI)
 
876
{
 
877
        cd_message ("%s (%s)", __func__, cURI);
 
878
        gchar *cDriveName = _cd_find_drive_name_from_URI (cURI);
 
879
        if (cDriveName == NULL)
 
880
                return FALSE;
 
881
        
 
882
        gboolean bCanEject = _cd_find_can_eject_from_drive_name (cDriveName);
 
883
        //g_free (cDriveName);
 
884
        return bCanEject;
 
885
}
 
886
gboolean vfs_backend_eject_drive (const gchar *cURI)
 
887
{
 
888
        cd_message ("%s (%s)", __func__, cURI);
 
889
        gchar *cDriveName = _cd_find_drive_name_from_URI (cURI);
 
890
        GDrive *pDrive = _cd_find_drive_from_name (cDriveName);
 
891
        if (pDrive != NULL)
 
892
        {
 
893
                g_drive_eject (pDrive,
 
894
                        G_MOUNT_UNMOUNT_NONE,
 
895
                        NULL,
 
896
                        NULL,
 
897
                        NULL);
 
898
        }
 
899
        //g_object_unref (pDrive);
 
900
        //g_free (cDriveName);
 
901
        return TRUE;
 
902
}
 
903
 
 
904
 
 
905
static void _vfs_backend_mount_callback (gpointer pObject, GAsyncResult *res, gpointer *data)
 
906
//static void _vfs_backend_mount_callback (gboolean succeeded, char *error, char *detailed_error, gpointer *data)
 
907
{
 
908
        cd_message ("%s (%d)", __func__, GPOINTER_TO_INT (data[1]));
 
909
        
 
910
        CairoDockFMMountCallback pCallback = data[0];
 
911
        
 
912
        GError *erreur = NULL;
 
913
        gboolean bSuccess;
 
914
        if (GPOINTER_TO_INT (data[1]) == 1)
 
915
                bSuccess = (g_file_mount_mountable_finish (G_FILE (pObject), res, &erreur) != NULL);
 
916
                //bSuccess = (g_volume_mount_finish (G_VOLUME (pObject), res, &erreur));
 
917
        else if (GPOINTER_TO_INT (data[1]) == 0)
 
918
                bSuccess = g_mount_unmount_finish (G_MOUNT (pObject), res, &erreur);
 
919
        else
 
920
                bSuccess = g_mount_eject_finish (G_MOUNT (pObject), res, &erreur);
 
921
        if (erreur != NULL)
 
922
        {
 
923
                cd_warning ("gnome-integration : %s", erreur->message);
 
924
                g_error_free (erreur);
 
925
        }
 
926
        
 
927
        cd_message ("(un)mount fini -> %d", bSuccess);
 
928
        pCallback (GPOINTER_TO_INT (data[1]) == 1, bSuccess, data[2], data[3], data[4]);
 
929
        //g_free (data[2]);
 
930
        //g_object_unref (pObject);
 
931
        //g_free (data);
 
932
}
 
933
 
 
934
void vfs_backend_mount (const gchar *cURI, int iVolumeID, CairoDockFMMountCallback pCallback, Icon *icon, CairoContainer *pContainer)
 
935
{
 
936
        g_return_if_fail (iVolumeID > 0);
 
937
        cd_message ("%s (%s)", __func__, cURI);
 
938
        
 
939
        /*gchar *cTargetURI = NULL;
 
940
        GMount *pMount = _cd_find_mount_from_uri (cURI, &cTargetURI);
 
941
        cd_message (" %x / %s\n", pMount, cTargetURI);
 
942
        GVolume *pVolume = g_mount_get_volume (pMount);
 
943
        gpointer *data2 = g_new (gpointer, 5);
 
944
        data2[0] = pCallback;
 
945
        data2[1] = GINT_TO_POINTER (1);
 
946
        data2[2] = g_path_get_basename (cURI);
 
947
        data2[3] = icon;
 
948
        data2[4] = pDock;
 
949
        g_volume_mount (pVolume,
 
950
                G_MOUNT_MOUNT_NONE,
 
951
                NULL,
 
952
                NULL,
 
953
                (GAsyncReadyCallback) _vfs_backend_mount_callback,
 
954
                data2);*/
 
955
        gchar *cTargetURI = _cd_find_target_uri (cURI);
 
956
        GFile *pFile = g_file_new_for_uri (cURI);
 
957
        
 
958
        gpointer *data2 = g_new (gpointer, 5);
 
959
        data2[0] = pCallback;
 
960
        data2[1] = GINT_TO_POINTER (1);
 
961
        data2[2] = g_path_get_basename (cTargetURI);
 
962
        data2[3] = icon;
 
963
        data2[4] = pContainer;
 
964
        g_file_mount_mountable  (pFile,
 
965
                G_MOUNT_MOUNT_NONE,
 
966
                NULL,
 
967
                NULL,
 
968
                (GAsyncReadyCallback) _vfs_backend_mount_callback,
 
969
                data2);
 
970
        g_free (cTargetURI);
 
971
}
 
972
 
 
973
void vfs_backend_unmount (const gchar *cURI, int iVolumeID, CairoDockFMMountCallback pCallback, Icon *icon, CairoContainer *pContainer)
 
974
{
 
975
        g_return_if_fail (cURI != NULL);
 
976
        cd_message ("%s (%s)", __func__, cURI);
 
977
        
 
978
        gchar *cTargetURI = NULL;
 
979
        GMount *pMount = _cd_find_mount_from_uri (cURI, &cTargetURI);
 
980
        if (pMount == NULL || ! G_IS_MOUNT (pMount))
 
981
        {
 
982
                return ;
 
983
        }
 
984
        
 
985
        if ( ! g_mount_can_unmount (pMount))
 
986
                return ;
 
987
        
 
988
        gboolean bCanEject = g_mount_can_eject (pMount);
 
989
        gboolean bCanUnmount = g_mount_can_unmount (pMount);
 
990
        cd_message ("eject:%d / unmount:%d\n", bCanEject, bCanUnmount);
 
991
        if (! bCanEject && ! bCanUnmount)
 
992
                return ;
 
993
        
 
994
        gpointer *data2 = g_new (gpointer, 5);
 
995
        data2[0] = pCallback;
 
996
        data2[1] = GINT_TO_POINTER (bCanEject ? 2 : 0);
 
997
        data2[2] = g_mount_get_name (pMount);
 
998
        data2[3] = icon;
 
999
        data2[4] = pContainer;
 
1000
        if (bCanEject)
 
1001
                g_mount_eject (pMount,
 
1002
                        G_MOUNT_UNMOUNT_NONE,
 
1003
                        NULL,
 
1004
                        (GAsyncReadyCallback) _vfs_backend_mount_callback,
 
1005
                        data2);
 
1006
        else
 
1007
                g_mount_unmount (pMount,
 
1008
                        G_MOUNT_UNMOUNT_NONE ,
 
1009
                        NULL,
 
1010
                        (GAsyncReadyCallback) _vfs_backend_mount_callback,
 
1011
                        data2);
 
1012
}
 
1013
 
 
1014
 
 
1015
static void _on_monitor_changed (GFileMonitor *monitor,
 
1016
        GFile *file,
 
1017
        GFile *other_file,
 
1018
        GFileMonitorEvent event_type,
 
1019
        gpointer  *data)
 
1020
{
 
1021
        CairoDockFMMonitorCallback pCallback = data[0];
 
1022
        gpointer user_data = data[1];
 
1023
        cd_message ("%s (%d , data : %x)", __func__, event_type, user_data);
 
1024
        
 
1025
        CairoDockFMEventType iEventType;
 
1026
        switch (event_type)
 
1027
        {
 
1028
                case G_FILE_MONITOR_EVENT_CHANGED :
 
1029
                case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT :
 
1030
                //case G_FILE_MONITOR_EVENT_UNMOUNTED : // pertinent ?...
 
1031
                        iEventType = CAIRO_DOCK_FILE_MODIFIED;
 
1032
                        cd_message ("modification d'un fichier");
 
1033
                break;
 
1034
                
 
1035
                case G_FILE_MONITOR_EVENT_DELETED :
 
1036
                        iEventType = CAIRO_DOCK_FILE_DELETED;
 
1037
                        cd_message ("effacement d'un fichier");
 
1038
                break;
 
1039
                
 
1040
                case G_FILE_MONITOR_EVENT_CREATED :
 
1041
                        iEventType = CAIRO_DOCK_FILE_CREATED;
 
1042
                        cd_message ("creation d'un fichier");
 
1043
                break;
 
1044
                
 
1045
                default :
 
1046
                return ;
 
1047
        }
 
1048
        gchar *cURI = g_file_get_uri (file);
 
1049
        cd_message (" c'est le fichier %s", cURI);
 
1050
        gchar *cPath = NULL;
 
1051
        if (strncmp (cURI, "computer://", 11) == 0)
 
1052
        {
 
1053
                if (event_type == G_FILE_MONITOR_EVENT_CHANGED)
 
1054
                {
 
1055
                        g_free (cURI);
 
1056
                        return ;
 
1057
                }
 
1058
                memcpy (cURI+4, "file", 4);
 
1059
                cPath = g_filename_from_uri (cURI+4, NULL, NULL);
 
1060
                cd_debug(" (path:%s)", cPath);
 
1061
                g_free (cURI);
 
1062
                cURI = g_strdup_printf ("computer://%s", cPath);
 
1063
                cd_message ("son URI complete est : %s", cURI);
 
1064
        }
 
1065
        
 
1066
        pCallback (iEventType, cURI, user_data);
 
1067
        g_free (cURI);
 
1068
}
 
1069
 
 
1070
 
 
1071
void vfs_backend_add_monitor (const gchar *cURI, gboolean bDirectory, CairoDockFMMonitorCallback pCallback, gpointer user_data)
 
1072
{
 
1073
        g_return_if_fail (cURI != NULL);
 
1074
        GError *erreur = NULL;
 
1075
        GFileMonitor *pMonitor;
 
1076
        GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
 
1077
        if (bDirectory)
 
1078
                pMonitor = g_file_monitor_directory (pFile,
 
1079
                        G_FILE_MONITOR_WATCH_MOUNTS,
 
1080
                        NULL,
 
1081
                        &erreur);
 
1082
        else
 
1083
                pMonitor = g_file_monitor_file (pFile,
 
1084
                        G_FILE_MONITOR_WATCH_MOUNTS,
 
1085
                        NULL,
 
1086
                        &erreur);
 
1087
        //g_object_unref (pFile);
 
1088
        if (erreur != NULL)
 
1089
        {
 
1090
                cd_warning ("gnome-integration : couldn't add monitor on '%s' (%d) [%s]", cURI, bDirectory, erreur->message);
 
1091
                g_error_free (erreur);
 
1092
                return ;
 
1093
        }
 
1094
        
 
1095
        gpointer *data = g_new0 (gpointer, 3);
 
1096
        data[0] = pCallback;
 
1097
        data[1] = user_data;
 
1098
        data[2] = pMonitor;
 
1099
        g_signal_connect (G_OBJECT (pMonitor), "changed", G_CALLBACK (_on_monitor_changed), data);
 
1100
        
 
1101
        g_hash_table_insert (s_hMonitorHandleTable, g_strdup (cURI), data);
 
1102
        cd_message (">>> moniteur ajoute sur %s (%x)", cURI, user_data);
 
1103
}
 
1104
 
 
1105
void vfs_backend_remove_monitor (const gchar *cURI)
 
1106
{
 
1107
        if (cURI != NULL)
 
1108
        {
 
1109
                cd_message (">>> moniteur supprime sur %s", cURI);
 
1110
                g_hash_table_remove (s_hMonitorHandleTable, cURI);
 
1111
        }
 
1112
}
 
1113
 
 
1114
 
 
1115
 
 
1116
gboolean vfs_backend_delete_file (const gchar *cURI)
 
1117
{
 
1118
        g_return_val_if_fail (cURI != NULL, FALSE);
 
1119
        GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
 
1120
        
 
1121
        GError *erreur = NULL;
 
1122
        gboolean bSuccess = g_file_trash (pFile, NULL, &erreur);
 
1123
        if (erreur != NULL)
 
1124
        {
 
1125
                cd_warning ("gnome-integration : %s", erreur->message);
 
1126
                g_error_free (erreur);
 
1127
        }
 
1128
        g_object_unref (pFile);
 
1129
        return bSuccess;
 
1130
}
 
1131
 
 
1132
gboolean vfs_backend_rename_file (const gchar *cOldURI, const gchar *cNewName)
 
1133
{
 
1134
        g_return_val_if_fail (cOldURI != NULL, FALSE);
 
1135
        GFile *pOldFile = (*cOldURI == '/' ? g_file_new_for_path (cOldURI) : g_file_new_for_uri (cOldURI));
 
1136
        GError *erreur = NULL;
 
1137
        GFile *pNewFile = g_file_set_display_name (pOldFile, cNewName, NULL, &erreur);
 
1138
        if (erreur != NULL)
 
1139
        {
 
1140
                cd_warning ("gnome-integration : %s", erreur->message);
 
1141
                g_error_free (erreur);
 
1142
        }
 
1143
        gboolean bSuccess = (pNewFile != NULL);
 
1144
        if (pNewFile != NULL)
 
1145
                g_object_unref (pNewFile);
 
1146
        g_object_unref (pOldFile);
 
1147
        return bSuccess;
 
1148
}
 
1149
 
 
1150
gboolean vfs_backend_move_file (const gchar *cURI, const gchar *cDirectoryURI)
 
1151
{
 
1152
        g_return_val_if_fail (cURI != NULL, FALSE);
 
1153
        cd_message (" %s -> %s", cURI, cDirectoryURI);
 
1154
        GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
 
1155
        
 
1156
        gchar *cFileName = g_file_get_basename (pFile);
 
1157
        gchar *cNewFileURI = g_strconcat (cDirectoryURI, "/", cFileName, NULL);  // un peu moyen mais bon...
 
1158
        GFile *pDestinationFile = (*cNewFileURI == '/' ? g_file_new_for_path (cNewFileURI) : g_file_new_for_uri (cNewFileURI));
 
1159
        g_free (cNewFileURI);
 
1160
        g_free (cFileName);
 
1161
        
 
1162
        GError *erreur = NULL;
 
1163
        gboolean bSuccess = g_file_move (pFile,
 
1164
                pDestinationFile,
 
1165
                G_FILE_COPY_NOFOLLOW_SYMLINKS,
 
1166
                NULL,
 
1167
                NULL,  // GFileProgressCallback
 
1168
                NULL,  // data
 
1169
                &erreur);
 
1170
        if (erreur != NULL)
 
1171
        {
 
1172
                cd_warning ("gnome-integration : %s", erreur->message);
 
1173
                g_error_free (erreur);
 
1174
        }
 
1175
        g_object_unref (pFile);
 
1176
        g_object_unref (pDestinationFile);
 
1177
        return bSuccess;
 
1178
}
 
1179
 
 
1180
void vfs_backend_get_file_properties (const gchar *cURI, guint64 *iSize, time_t *iLastModificationTime, gchar **cMimeType, int *iUID, int *iGID, int *iPermissionsMask)
 
1181
{
 
1182
        g_return_if_fail (cURI != NULL);
 
1183
        GFile *pFile = (*cURI == '/' ? g_file_new_for_path (cURI) : g_file_new_for_uri (cURI));
 
1184
        GError *erreur = NULL;
 
1185
        const gchar *cQuery = G_FILE_ATTRIBUTE_STANDARD_SIZE","
 
1186
                G_FILE_ATTRIBUTE_TIME_MODIFIED","
 
1187
                G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE","
 
1188
                G_FILE_ATTRIBUTE_UNIX_UID","
 
1189
                G_FILE_ATTRIBUTE_UNIX_GID","
 
1190
                G_FILE_ATTRIBUTE_ACCESS_CAN_READ","
 
1191
                G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE","
 
1192
                G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE;
 
1193
        GFileInfo *pFileInfo = g_file_query_info (pFile,
 
1194
                cQuery,
 
1195
                G_FILE_QUERY_INFO_NONE,  /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
 
1196
                NULL,
 
1197
                &erreur);
 
1198
        if (erreur != NULL)
 
1199
        {
 
1200
                cd_warning ("gnome-integration : couldn't get file properties for '%s' [%s]", cURI, erreur->message);
 
1201
                g_error_free (erreur);
 
1202
        }
 
1203
        
 
1204
        *iSize = g_file_info_get_attribute_uint64 (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_SIZE);
 
1205
        *iLastModificationTime = (time_t) g_file_info_get_attribute_uint64 (pFileInfo, G_FILE_ATTRIBUTE_TIME_MODIFIED);
 
1206
        *cMimeType = g_file_info_get_attribute_as_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
 
1207
        *iUID = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_UNIX_UID);
 
1208
        *iGID = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_UNIX_GID);
 
1209
        int r = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
 
1210
        int w = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
 
1211
        int x = g_file_info_get_attribute_uint32 (pFileInfo, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE);
 
1212
        *iPermissionsMask = r * 8 * 8 + w * 8 + x;
 
1213
        
 
1214
        g_object_unref (pFileInfo);
 
1215
        g_object_unref (pFile);
 
1216
}
 
1217
 
 
1218
 
 
1219
gchar *vfs_backend_get_trash_path (const gchar *cNearURI, gchar **cFileInfoPath)
 
1220
{
 
1221
        gchar *cPath = NULL;
 
1222
        /*GFile *pFile = g_file_new_for_uri ("trash://");
 
1223
        gchar *cPath = g_file_get_path (pFile);
 
1224
        g_object_unref (pFile);*/
 
1225
        const gchar *xdgPath = g_getenv ("XDG_DATA_HOME");
 
1226
        if (xdgPath != NULL)
 
1227
        {
 
1228
                cPath = g_strdup_printf ("%s/Trash/files", xdgPath);
 
1229
                if (cFileInfoPath != NULL)
 
1230
                        *cFileInfoPath = g_strdup_printf ("%s/Trash/info", xdgPath);
 
1231
        }
 
1232
        else
 
1233
        {
 
1234
                cPath = g_strdup_printf ("%s/.local/share/Trash/files", g_getenv ("HOME"));
 
1235
                if (cFileInfoPath != NULL)
 
1236
                        *cFileInfoPath = g_strdup_printf ("%s/.local/share/Trash/info", g_getenv ("HOME"));
 
1237
        }
 
1238
        return cPath;
 
1239
}
 
1240
 
 
1241
gchar *vfs_backend_get_desktop_path (void)
 
1242
{
 
1243
        GFile *pFile = g_file_new_for_uri ("desktop://");
 
1244
        gchar *cPath = g_file_get_path (pFile);
 
1245
        g_object_unref (pFile);
 
1246
        if (cPath == NULL)
 
1247
                cPath = g_strdup_printf ("%s/Desktop", g_getenv ("HOME"));
 
1248
        return cPath;
 
1249
}