← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gnome-integration/src/applet-gvfs.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2009-08-26 21:07:39 UTC
  • Revision ID: james.westby@ubuntu.com-20090826210739-gyjuuqezrzuluao4
Tags: upstream-2.0.8.1
Import upstream version 2.0.8.1

Show diffs side-by-side

added added

removed removed

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