gio/gwin32mount.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  * Copyright (C) 2008 Hans Breuer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  * Author: Alexander Larsson <alexl@redhat.com>
  22  *         David Zeuthen <davidz@redhat.com>
  23  *         Hans Breuer <hans@breuer.org>
  24  */
  25
  26 #include "config.h"
  27
  28 #include <string.h>
  29 #define WIN32_MEAN_AND_LEAN
  30 #include <windows.h>
  31
  32 #include <glib.h>
  33 #include "gwin32volumemonitor.h"
  34 #include "gwin32mount.h"
  35 #include "gmount.h"
  36 #include "gfile.h"
  37 #include "gmountprivate.h"
  38 #include "gvolumemonitor.h"
  39 #include "gthemedicon.h"
  40 #include "gsimpleasyncresult.h"
  41 #include "glibintl.h"
  42
  43 #include "gioalias.h"
  44
  45 struct _GWin32Mount {
  46   GObject parent;
  47
  48   GVolumeMonitor   *volume_monitor;
  49
  50   GWin32Volume      *volume; /* owned by volume monitor */
  51   int   drive_type;
  52
  53   /* why does all this stuff need to be duplicated? It is in volume already! */
  54   char *name;
  55   GIcon *icon;
  56   char *mount_path;
  57
  58   gboolean can_eject;
  59 };
  60
  61 static void g_win32_mount_mount_iface_init (GMountIface *iface);
  62
  63 #define g_win32_mount_get_type _g_win32_mount_get_type
  64 G_DEFINE_TYPE_WITH_CODE (GWin32Mount, g_win32_mount, G_TYPE_OBJECT,
  65                          G_IMPLEMENT_INTERFACE (G_TYPE_MOUNT,
  66                                                 g_win32_mount_mount_iface_init))
  67
  68
  69 static void
  70 g_win32_mount_finalize (GObject *object)
  71 {
  72   GWin32Mount *mount;
  73
  74   mount = G_WIN32_MOUNT (object);
  75
  76   if (mount->volume_monitor != NULL)
  77     g_object_unref (mount->volume_monitor);
  78 #if 0
  79   if (mount->volume)
  80     _g_win32_volume_unset_mount (mount->volume, mount);
  81 #endif
  82   /* TODO: g_warn_if_fail (volume->volume == NULL); */
  83   g_object_unref (mount->icon);
  84   g_free (mount->name);
  85   g_free (mount->mount_path);
  86
  87   if (G_OBJECT_CLASS (g_win32_mount_parent_class)->finalize)
  88     (*G_OBJECT_CLASS (g_win32_mount_parent_class)->finalize) (object);
  89 }
  90
  91 static void
  92 g_win32_mount_class_init (GWin32MountClass *klass)
  93 {
  94   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  95
  96   gobject_class->finalize = g_win32_mount_finalize;
  97 }
  98
  99 static void
 100 g_win32_mount_init (GWin32Mount *win32_mount)
 101 {
 102 }
 103
 104 gchar *
 105 _win32_get_displayname (const char *drive)
 106 {
 107   gunichar2 *wdrive = g_utf8_to_utf16 (drive, -1, NULL, NULL, NULL);
 108   gchar *name = NULL;
 109   SHFILEINFOW sfi;
 110   if (SHGetFileInfoW(wdrive, 0, &sfi, sizeof(sfi), SHGFI_DISPLAYNAME))
 111     name = g_utf16_to_utf8 (sfi.szDisplayName, -1, NULL, NULL, NULL);
 112
 113   g_free (wdrive);
 114   return name ? name : g_strdup (drive);
 115 }
 116
 117 /**
 118  * _g_win32_mount_new:
 119  * @volume_monitor: a #GVolumeMonitor.
 120  * @path: a win32 path.
 121  * @volume: ususally NULL
 122  *
 123  * Returns: a #GWin32Mount for the given win32 path.
 124  **/
 125 GWin32Mount *
 126 _g_win32_mount_new (GVolumeMonitor  *volume_monitor,
 127                     const char      *path,
 128                     GWin32Volume    *volume)
 129 {
 130   GWin32Mount *mount;
 131   const gchar *drive = path; //fixme
 132
 133 #if 0
 134   /* No volume for mount: Ignore internal things */
 135   if (volume == NULL && !g_win32_mount_guess_should_display (mount_entry))
 136     return NULL;
 137 #endif
 138
 139   mount = g_object_new (G_TYPE_WIN32_MOUNT, NULL);
 140   mount->volume_monitor = volume_monitor != NULL ? g_object_ref (volume_monitor) : NULL;
 141   mount->mount_path = g_strdup (path);
 142   mount->drive_type = GetDriveType (drive);
 143   mount->can_eject = FALSE; /* TODO */
 144   mount->name = _win32_get_displayname (drive);
 145
 146   /* need to do this last */
 147   mount->volume = volume;
 148 #if 0
 149   if (volume != NULL)
 150     _g_win32_volume_set_mount (volume, mount);
 151 #endif
 152   return mount;
 153 }
 154
 155 void
 156 _g_win32_mount_unmounted (GWin32Mount *mount)
 157 {
 158   if (mount->volume != NULL)
 159     {
 160 #if 0
 161       _g_win32_volume_unset_mount (mount->volume, mount);
 162 #endif
 163       mount->volume = NULL;
 164       g_signal_emit_by_name (mount, "changed");
 165       /* there's really no need to emit mount_changed on the volume monitor
 166        * as we're going to be deleted.. */
 167     }
 168 }
 169
 170 void
 171 _g_win32_mount_unset_volume (GWin32Mount  *mount,
 172                              GWin32Volume *volume)
 173 {
 174   if (mount->volume == volume)
 175     {
 176       mount->volume = NULL;
 177       /* TODO: Emit changed in idle to avoid locking issues */
 178       g_signal_emit_by_name (mount, "changed");
 179       if (mount->volume_monitor != NULL)
 180         g_signal_emit_by_name (mount->volume_monitor, "mount_changed", mount);
 181     }
 182 }
 183
 184 static GFile *
 185 g_win32_mount_get_root (GMount *mount)
 186 {
 187   GWin32Mount *win32_mount = G_WIN32_MOUNT (mount);
 188
 189   return g_file_new_for_path (win32_mount->mount_path);
 190 }
 191
 192 const char *
 193 _win32_drive_type_to_icon (int type)
 194 {
 195   switch (type)
 196   {
 197   case DRIVE_REMOVABLE : return "gtk-floppy";
 198   case DRIVE_FIXED : return "gtk-harddisk";
 199   case DRIVE_REMOTE : return "gtk-network";
 200   case DRIVE_CDROM : return "gtk-cdrom";
 201   default : return "gtk-directory";
 202   }
 203 }
 204
 205 static GIcon *
 206 g_win32_mount_get_icon (GMount *mount)
 207 {
 208   GWin32Mount *win32_mount = G_WIN32_MOUNT (mount);
 209
 210   g_return_val_if_fail (win32_mount->mount_path != NULL, NULL);
 211
 212   /* lazy creation */
 213   if (!win32_mount->icon)
 214     {
 215       SHFILEINFOW shfi;
 216       wchar_t *wfn = g_utf8_to_utf16 (win32_mount->mount_path, -1, NULL, NULL, NULL);
 217
 218       if (SHGetFileInfoW (wfn, 0, &shfi, sizeof (shfi), SHGFI_ICONLOCATION))
 219         {
 220           gchar *name = g_utf16_to_utf8 (shfi.szDisplayName, -1, NULL, NULL, NULL);
 221           gchar *id = g_strdup_printf ("%s,%i", name, shfi.iIcon);
 222           win32_mount->icon = g_themed_icon_new (id);
 223           g_free (name);
 224           g_free (id);
 225         }
 226       else
 227         {
 228           win32_mount->icon = g_themed_icon_new_with_default_fallbacks (
 229                                 _win32_drive_type_to_icon (win32_mount->drive_type));
 230         }
 231     }
 232
 233   return g_object_ref (win32_mount->icon);
 234 }
 235
 236 static char *
 237 g_win32_mount_get_uuid (GMount *mount)
 238 {
 239   return NULL;
 240 }
 241
 242 static char *
 243 g_win32_mount_get_name (GMount *mount)
 244 {
 245   GWin32Mount *win32_mount = G_WIN32_MOUNT (mount);
 246
 247   return g_strdup (win32_mount->name);
 248 }
 249
 250 static GDrive *
 251 g_win32_mount_get_drive (GMount *mount)
 252 {
 253   GWin32Mount *win32_mount = G_WIN32_MOUNT (mount);
 254
 255   if (win32_mount->volume != NULL)
 256     return g_volume_get_drive (G_VOLUME (win32_mount->volume));
 257
 258   return NULL;
 259 }
 260
 261 static GVolume *
 262 g_win32_mount_get_volume (GMount *mount)
 263 {
 264   GWin32Mount *win32_mount = G_WIN32_MOUNT (mount);
 265
 266   if (win32_mount->volume)
 267     return G_VOLUME (g_object_ref (win32_mount->volume));
 268
 269   return NULL;
 270 }
 271
 272 static gboolean
 273 g_win32_mount_can_unmount (GMount *mount)
 274 {
 275   return FALSE;
 276 }
 277
 278 static gboolean
 279 g_win32_mount_can_eject (GMount *mount)
 280 {
 281   GWin32Mount *win32_mount = G_WIN32_MOUNT (mount);
 282   return win32_mount->can_eject;
 283 }
 284
 285
 286 typedef struct {
 287   GWin32Mount *win32_mount;
 288   GAsyncReadyCallback callback;
 289   gpointer user_data;
 290   GCancellable *cancellable;
 291   int error_fd;
 292   GIOChannel *error_channel;
 293   guint error_channel_source_id;
 294   GString *error_string;
 295 } UnmountEjectOp;
 296
 297 static void
 298 g_win32_mount_unmount (GMount              *mount,
 299                        GMountUnmountFlags   flags,
 300                        GCancellable        *cancellable,
 301                        GAsyncReadyCallback  callback,
 302                        gpointer             user_data)
 303 {
 304 }
 305
 306 static gboolean
 307 g_win32_mount_unmount_finish (GMount        *mount,
 308                               GAsyncResult  *result,
 309                               GError       **error)
 310 {
 311   return FALSE;
 312 }
 313
 314 static void
 315 g_win32_mount_eject (GMount              *mount,
 316                      GMountUnmountFlags   flags,
 317                      GCancellable        *cancellable,
 318                      GAsyncReadyCallback  callback,
 319                      gpointer             user_data)
 320 {
 321 }
 322
 323 static gboolean
 324 g_win32_mount_eject_finish (GMount        *mount,
 325                             GAsyncResult  *result,
 326                             GError       **error)
 327 {
 328   return FALSE;
 329 }
 330
 331 static void
 332 g_win32_mount_mount_iface_init (GMountIface *iface)
 333 {
 334   iface->get_root = g_win32_mount_get_root;
 335   iface->get_name = g_win32_mount_get_name;
 336   iface->get_icon = g_win32_mount_get_icon;
 337   iface->get_uuid = g_win32_mount_get_uuid;
 338   iface->get_drive = g_win32_mount_get_drive;
 339   iface->get_volume = g_win32_mount_get_volume;
 340   iface->can_unmount = g_win32_mount_can_unmount;
 341   iface->can_eject = g_win32_mount_can_eject;
 342   iface->unmount = g_win32_mount_unmount;
 343   iface->unmount_finish = g_win32_mount_unmount_finish;
 344   iface->eject = g_win32_mount_eject;
 345   iface->eject_finish = g_win32_mount_eject_finish;
 346 }