← Back to branch summary

~cairo-dock-team/cairo-dock-plug-ins/popup_from_shortkey

« back to all changes in this revision

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

  • Committer: Fabounet (Fabrice Rey) - http://cairo-dock.org
  • Date: 2009-10-02 00:10:12 UTC
  • Revision ID: fabounet_fabrice_rey_-_httpcairo-dock.org-20091002001012-g7xd63cloqie9oix
small bug fixes

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