Pileus Git - ~andy/gtk/blob - gtk/gtkfilesystem.c

   1 /* GTK - The GIMP Toolkit
   2  * gtkfilesystem.c: Abstract file system interfaces
   3  * Copyright (C) 2003, Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "gtkfilesystem.h"
  22
  23 #include <string.h>
  24
  25 struct _GtkFileInfo
  26 {
  27   GtkFileTime modification_time;
  28   gint64 size;
  29   gchar *display_name;
  30   gchar *display_key;
  31   gchar *mime_type;
  32   GdkPixbuf *icon;
  33   guint is_folder : 1;
  34   guint is_hidden : 1;
  35 };
  36
  37 static void gtk_file_system_base_init (gpointer g_class);
  38 static void gtk_file_folder_base_init (gpointer g_class);
  39
  40 GQuark
  41 gtk_file_system_error_quark (void)
  42 {
  43   static GQuark quark = 0;
  44   if (quark == 0)
  45     quark = g_quark_from_static_string ("gtk-file-system-error-quark");
  46   return quark;
  47 }
  48
  49 /*****************************************
  50  *             GtkFileInfo               *
  51  *****************************************/
  52 GType
  53 gtk_file_info_get_type (void)
  54 {
  55   static GType our_type = 0;
  56
  57   if (our_type == 0)
  58     our_type = g_boxed_type_register_static ("GtkFileInfo",
  59                                              (GBoxedCopyFunc) gtk_file_info_copy,
  60                                              (GBoxedFreeFunc) gtk_file_info_free);
  61
  62   return our_type;
  63 }
  64
  65 GtkFileInfo *
  66 gtk_file_info_new  (void)
  67 {
  68   GtkFileInfo *info;
  69
  70   info = g_new0 (GtkFileInfo, 1);
  71
  72   return info;
  73 }
  74
  75 GtkFileInfo *
  76 gtk_file_info_copy (GtkFileInfo *info)
  77 {
  78   GtkFileInfo *new_info;
  79
  80   g_return_val_if_fail (info != NULL, NULL);
  81
  82   new_info = g_memdup (info, sizeof (GtkFileInfo));
  83   if (new_info->display_name)
  84     new_info->display_name = g_strdup (new_info->display_name);
  85   if (new_info->mime_type)
  86     new_info->mime_type = g_strdup (new_info->mime_type);
  87   if (new_info->icon)
  88     g_object_ref (new_info->icon);
  89
  90   return new_info;
  91 }
  92
  93 void
  94 gtk_file_info_free (GtkFileInfo *info)
  95 {
  96   g_return_if_fail (info != NULL);
  97
  98   if (info->display_name)
  99     g_free (info->display_name);
 100   if (info->mime_type)
 101     g_free (info->mime_type);
 102   if (info->icon)
 103     g_object_unref (info->icon);
 104 }
 105
 106 G_CONST_RETURN gchar *
 107 gtk_file_info_get_display_name (const GtkFileInfo *info)
 108 {
 109   g_return_val_if_fail (info != NULL, NULL);
 110
 111   return info->display_name;
 112 }
 113
 114 /**
 115  * gtk_file_info_get_display_key:
 116  * @info: a #GtkFileInfo
 117  *
 118  * Returns results of g_utf8_collate_key() on the display name
 119  * for @info. This is useful when sorting a bunch of #GtkFileInfo
 120  * structures since the collate key will be only computed once.
 121  *
 122  * Return value: The collate key for the display name, or %NULL
 123  *   if the display name hasn't been set.
 124  **/
 125 G_CONST_RETURN gchar *
 126 gtk_file_info_get_display_key (const GtkFileInfo *info)
 127 {
 128   g_return_val_if_fail (info != NULL, NULL);
 129
 130   if (!info->display_key && info->display_name)
 131     {
 132       /* Since info->display_key is only a cache, we cast off the const
 133        */
 134       ((GtkFileInfo *)info)->display_key = g_utf8_collate_key (info->display_name, -1);
 135     }
 136
 137
 138   return info->display_key;
 139 }
 140
 141 void
 142 gtk_file_info_set_display_name (GtkFileInfo *info,
 143                                 const gchar *display_name)
 144 {
 145   g_return_if_fail (info != NULL);
 146
 147   if (info->display_name)
 148     g_free (info->display_name);
 149   if (info->display_key)
 150     {
 151       g_free (info->display_key);
 152       info->display_key = NULL;
 153     }
 154
 155   info->display_name = g_strdup (display_name);
 156 }
 157
 158 gboolean
 159 gtk_file_info_get_is_folder (const GtkFileInfo *info)
 160 {
 161   g_return_val_if_fail (info != NULL, FALSE);
 162
 163   return info->is_folder;
 164 }
 165
 166 void
 167 gtk_file_info_set_is_folder (GtkFileInfo *info,
 168                              gboolean     is_folder)
 169 {
 170   g_return_if_fail (info != NULL);
 171
 172   info->is_folder = is_folder != FALSE;
 173 }
 174
 175 gboolean
 176 gtk_file_info_get_is_hidden (const GtkFileInfo *info)
 177 {
 178   g_return_val_if_fail (info != NULL, FALSE);
 179
 180   return info->is_hidden;
 181 }
 182
 183 void
 184 gtk_file_info_set_is_hidden (GtkFileInfo *info,
 185                              gboolean     is_hidden)
 186 {
 187   g_return_if_fail (info != NULL);
 188
 189   info->is_hidden = is_hidden != FALSE;
 190 }
 191
 192 G_CONST_RETURN gchar *
 193 gtk_file_info_get_mime_type (const GtkFileInfo *info)
 194 {
 195   g_return_val_if_fail (info != NULL, NULL);
 196
 197   return info->mime_type;
 198 }
 199
 200 void
 201 gtk_file_info_set_mime_type (GtkFileInfo *info,
 202                              const gchar *mime_type)
 203 {
 204   g_return_if_fail (info != NULL);
 205
 206   if (info->mime_type)
 207     g_free (info->mime_type);
 208
 209   info->mime_type = g_strdup (mime_type);
 210 }
 211
 212 GtkFileTime
 213 gtk_file_info_get_modification_time (const GtkFileInfo *info)
 214 {
 215   g_return_val_if_fail (info != NULL, 0);
 216
 217   return info->modification_time;
 218 }
 219
 220 void
 221 gtk_file_info_set_modification_time (GtkFileInfo *info,
 222                                      GtkFileTime  modification_time)
 223 {
 224   g_return_if_fail (info != NULL);
 225
 226   info->modification_time = modification_time;
 227 }
 228
 229 gint64
 230 gtk_file_info_get_size (const GtkFileInfo *info)
 231 {
 232   g_return_val_if_fail (info != NULL, 0);
 233
 234   return info->size;
 235 }
 236
 237 void
 238 gtk_file_info_set_size (GtkFileInfo *info,
 239                         gint64       size)
 240 {
 241   g_return_if_fail (info != NULL);
 242   g_return_if_fail (size >= 0);
 243
 244   info->size = size;
 245 }
 246
 247 GdkPixbuf *
 248 gtk_file_info_get_icon (const GtkFileInfo *info)
 249 {
 250   g_return_val_if_fail (info != NULL, NULL);
 251
 252   return info->icon;
 253 }
 254
 255 void
 256 gtk_file_info_set_icon (GtkFileInfo *info,
 257                         GdkPixbuf   *icon)
 258 {
 259   g_return_if_fail (info != NULL);
 260   g_return_if_fail (icon == NULL || GDK_IS_PIXBUF (icon));
 261
 262   if (icon != info->icon)
 263     {
 264       if (info->icon)
 265         g_object_unref (info->icon);
 266
 267       info->icon = icon;
 268
 269       if (info->icon)
 270         g_object_ref (info->icon);
 271     }
 272 }
 273
 274 /*****************************************
 275  *             GtkFileSystem             *
 276  *****************************************/
 277 GType
 278 gtk_file_system_get_type (void)
 279 {
 280   static GType file_system_type = 0;
 281
 282   if (!file_system_type)
 283     {
 284       static const GTypeInfo file_system_info =
 285       {
 286         sizeof (GtkFileSystemIface),  /* class_size */
 287         gtk_file_system_base_init,    /* base_init */
 288         NULL,                         /* base_finalize */
 289       };
 290
 291       file_system_type = g_type_register_static (G_TYPE_INTERFACE,
 292                                                  "GtkFileSystem",
 293                                                  &file_system_info, 0);
 294
 295       g_type_interface_add_prerequisite (file_system_type, G_TYPE_OBJECT);
 296     }
 297
 298   return file_system_type;
 299 }
 300
 301 static void
 302 gtk_file_system_base_init (gpointer g_class)
 303 {
 304   static gboolean initialized = FALSE;
 305
 306   if (!initialized)
 307     {
 308       GType iface_type = G_TYPE_FROM_INTERFACE (g_class);
 309
 310       g_signal_new ("roots_changed",
 311                     iface_type,
 312                     G_SIGNAL_RUN_LAST,
 313                     G_STRUCT_OFFSET (GtkFileSystemIface, roots_changed),
 314                     NULL, NULL,
 315                     g_cclosure_marshal_VOID__VOID,
 316                     G_TYPE_NONE, 0);
 317
 318       initialized = TRUE;
 319     }
 320 }
 321
 322 GSList *
 323 gtk_file_system_list_roots (GtkFileSystem  *file_system)
 324 {
 325   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 326
 327   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->list_roots (file_system);
 328 }
 329
 330 GtkFileInfo *
 331 gtk_file_system_get_root_info  (GtkFileSystem     *file_system,
 332                                 const GtkFilePath *path,
 333                                 GtkFileInfoType    types,
 334                                 GError           **error)
 335 {
 336   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 337   g_return_val_if_fail (path != NULL, NULL);
 338   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 339
 340   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->get_root_info (file_system, path, types, error);
 341 }
 342
 343 GtkFileFolder *
 344 gtk_file_system_get_folder (GtkFileSystem     *file_system,
 345                             const GtkFilePath *path,
 346                             GtkFileInfoType    types,
 347                             GError           **error)
 348 {
 349   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 350   g_return_val_if_fail (path != NULL, NULL);
 351   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 352
 353   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->get_folder (file_system, path, types, error);
 354 }
 355
 356 gboolean
 357 gtk_file_system_create_folder(GtkFileSystem     *file_system,
 358                               const GtkFilePath *path,
 359                               GError           **error)
 360 {
 361   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), FALSE);
 362   g_return_val_if_fail (path != NULL, FALSE);
 363   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 364
 365   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->create_folder (file_system, path, error);
 366 }
 367
 368 gboolean
 369 gtk_file_system_get_parent (GtkFileSystem     *file_system,
 370                             const GtkFilePath *path,
 371                             GtkFilePath      **parent,
 372                             GError           **error)
 373 {
 374   GtkFilePath *tmp_parent = NULL;
 375   gboolean result;
 376
 377   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), FALSE);
 378   g_return_val_if_fail (path != NULL, FALSE);
 379   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 380
 381   result = GTK_FILE_SYSTEM_GET_IFACE (file_system)->get_parent (file_system, path, &tmp_parent, error);
 382   g_assert (result || tmp_parent == NULL);
 383
 384   if (parent)
 385     *parent = tmp_parent;
 386   else
 387     gtk_file_path_free (tmp_parent);
 388
 389   return result;
 390 }
 391
 392 GtkFilePath *
 393 gtk_file_system_make_path (GtkFileSystem    *file_system,
 394                           const GtkFilePath *base_path,
 395                           const gchar       *display_name,
 396                           GError           **error)
 397 {
 398   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 399   g_return_val_if_fail (base_path != NULL, NULL);
 400   g_return_val_if_fail (display_name != NULL, NULL);
 401   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 402
 403   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->make_path (file_system, base_path, display_name, error);
 404 }
 405
 406 /**
 407  * gtk_file_system_parse:
 408  * @file_system: a #GtkFileSystem
 409  * @base_path: reference folder with respect to which relative
 410  *            paths should be interpreted.
 411  * @str: the string to parse
 412  * @folder: location to store folder portion of result, or %NULL
 413  * @file_part: location to store file portion of result, or %NULL
 414  * @error: location to store error, or %NULL
 415  *
 416  * Given a string entered by a user, parse it (possibly using
 417  * heuristics) into a folder path and a UTF-8 encoded
 418  * filename part. (Suitable for passing to gtk_file_system_make_path())
 419  *
 420  * Note that the returned filename point may point to a subfolder
 421  * of the returned folder. Adding a trailing path separator is needed
 422  * to enforce the interpretation as a folder name.
 423  *
 424  * If parsing fails because the syntax of @str is not understood,
 425  * and error of type GTK_FILE_SYSTEM_ERROR_BAD_FILENAME will
 426  * be set in @error and %FALSE returned.
 427  *
 428  * If parsing fails because a path was encountered that doesn't
 429  * exist on the filesystem, then an error of type
 430  * %GTK_FILE_SYSTEM_ERROR_NONEXISTANT will be set in @error
 431  * and %FALSE returned. (This only applies to parsing relative paths,
 432  * not to interpretation of @file_part. No check is made as
 433  * to whether @file_part exists.)
 434  *
 435  * Return value: %TRUE if the parsing succeeds, otherwise, %FALSE.
 436  **/
 437 gboolean
 438 gtk_file_system_parse (GtkFileSystem     *file_system,
 439                        const GtkFilePath *base_path,
 440                        const gchar       *str,
 441                        GtkFilePath      **folder,
 442                        gchar            **file_part,
 443                        GError           **error)
 444 {
 445   GtkFilePath *tmp_folder = NULL;
 446   gchar *tmp_file_part = NULL;
 447   gboolean result;
 448
 449   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), FALSE);
 450   g_return_val_if_fail (base_path != NULL, FALSE);
 451   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 452
 453
 454   result = GTK_FILE_SYSTEM_GET_IFACE (file_system)->parse (file_system, base_path, str,
 455                                                            &tmp_folder, &tmp_file_part,
 456                                                            error);
 457   g_assert (result || (tmp_folder == NULL && tmp_file_part == NULL));
 458
 459   if (folder)
 460     *folder = tmp_folder;
 461   else
 462     gtk_file_path_free (tmp_folder);
 463
 464   if (file_part)
 465     *file_part = tmp_file_part;
 466   else
 467     g_free (tmp_file_part);
 468
 469   return result;
 470 }
 471
 472
 473 gchar *
 474 gtk_file_system_path_to_uri (GtkFileSystem     *file_system,
 475                              const GtkFilePath *path)
 476 {
 477   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 478   g_return_val_if_fail (path != NULL, NULL);
 479
 480   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->path_to_uri (file_system, path);
 481 }
 482
 483 gchar *
 484 gtk_file_system_path_to_filename (GtkFileSystem     *file_system,
 485                                   const GtkFilePath *path)
 486 {
 487   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 488   g_return_val_if_fail (path != NULL, NULL);
 489
 490   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->path_to_filename (file_system, path);
 491 }
 492
 493 GtkFilePath *
 494 gtk_file_system_uri_to_path (GtkFileSystem *file_system,
 495                              const gchar    *uri)
 496 {
 497   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 498   g_return_val_if_fail (uri != NULL, NULL);
 499
 500   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->uri_to_path (file_system, uri);
 501 }
 502
 503 GtkFilePath *
 504 gtk_file_system_filename_to_path (GtkFileSystem *file_system,
 505                                   const gchar   *filename)
 506 {
 507   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 508   g_return_val_if_fail (filename != NULL, NULL);
 509
 510   return GTK_FILE_SYSTEM_GET_IFACE (file_system)->filename_to_path (file_system, filename);
 511 }
 512
 513 /*****************************************
 514  *             GtkFileFolder             *
 515  *****************************************/
 516 GType
 517 gtk_file_folder_get_type (void)
 518 {
 519   static GType file_folder_type = 0;
 520
 521   if (!file_folder_type)
 522     {
 523       static const GTypeInfo file_folder_info =
 524       {
 525         sizeof (GtkFileFolderIface),  /* class_size */
 526         gtk_file_folder_base_init,    /* base_init */
 527         NULL,                         /* base_finalize */
 528       };
 529
 530       file_folder_type = g_type_register_static (G_TYPE_INTERFACE,
 531                                                  "GtkFileFolder",
 532                                                  &file_folder_info, 0);
 533
 534       g_type_interface_add_prerequisite (file_folder_type, G_TYPE_OBJECT);
 535     }
 536
 537   return file_folder_type;
 538 }
 539
 540 static void
 541 gtk_file_folder_base_init (gpointer g_class)
 542 {
 543   static gboolean initialized = FALSE;
 544
 545   if (!initialized)
 546     {
 547       GType iface_type = G_TYPE_FROM_INTERFACE (g_class);
 548
 549       g_signal_new ("deleted",
 550                     iface_type,
 551                     G_SIGNAL_RUN_LAST,
 552                     G_STRUCT_OFFSET (GtkFileFolderIface, deleted),
 553                     NULL, NULL,
 554                     g_cclosure_marshal_VOID__VOID,
 555                     G_TYPE_NONE, 0);
 556       g_signal_new ("files_added",
 557                     iface_type,
 558                     G_SIGNAL_RUN_LAST,
 559                     G_STRUCT_OFFSET (GtkFileFolderIface, files_added),
 560                     NULL, NULL,
 561                     g_cclosure_marshal_VOID__POINTER,
 562                     G_TYPE_NONE, 1,
 563                     G_TYPE_POINTER);
 564       g_signal_new ("files_changed",
 565                     iface_type,
 566                     G_SIGNAL_RUN_LAST,
 567                     G_STRUCT_OFFSET (GtkFileFolderIface, files_changed),
 568                     NULL, NULL,
 569                     g_cclosure_marshal_VOID__POINTER,
 570                     G_TYPE_NONE, 1,
 571                     G_TYPE_POINTER);
 572       g_signal_new ("files_removed",
 573                     iface_type,
 574                     G_SIGNAL_RUN_LAST,
 575                     G_STRUCT_OFFSET (GtkFileFolderIface, files_removed),
 576                     NULL, NULL,
 577                     g_cclosure_marshal_VOID__POINTER,
 578                     G_TYPE_NONE, 1,
 579                     G_TYPE_POINTER);
 580
 581       initialized = TRUE;
 582     }
 583 }
 584
 585 gboolean
 586 gtk_file_folder_list_children (GtkFileFolder    *folder,
 587                                GSList          **children,
 588                                GError          **error)
 589 {
 590   gboolean result;
 591   GSList *tmp_children = NULL;
 592
 593   g_return_val_if_fail (GTK_IS_FILE_FOLDER (folder), FALSE);
 594   g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 595
 596   result = GTK_FILE_FOLDER_GET_IFACE (folder)->list_children (folder, &tmp_children, error);
 597   g_assert (result || tmp_children == NULL);
 598
 599   if (children)
 600     *children = tmp_children;
 601   else
 602     gtk_file_paths_free (tmp_children);
 603
 604   return result;
 605 }
 606
 607 GtkFileInfo *
 608 gtk_file_folder_get_info (GtkFileFolder     *folder,
 609                           const GtkFilePath *path,
 610                           GError           **error)
 611 {
 612   g_return_val_if_fail (GTK_IS_FILE_FOLDER (folder), NULL);
 613   g_return_val_if_fail (path != NULL, NULL);
 614   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 615
 616   return GTK_FILE_FOLDER_GET_IFACE (folder)->get_info (folder, path, error);
 617 }
 618
 619 GSList *
 620 gtk_file_paths_sort (GSList *paths)
 621 {
 622   return g_slist_sort (paths, (GCompareFunc)strcmp);
 623 }
 624
 625 void
 626 gtk_file_paths_free (GSList *paths)
 627 {
 628   GSList *tmp_list;
 629
 630   for (tmp_list = paths; tmp_list; tmp_list = tmp_list->next)
 631     gtk_file_path_free (tmp_list->data);
 632
 633   g_slist_free (paths);
 634 }