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

   1 /* gtkrecentchooserutils.h - Private utility functions for implementing a
   2  *                           GtkRecentChooser interface
   3  *
   4  * Copyright (C) 2006 Emmanuele Bassi
   5  *
   6  * All rights reserved
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  *
  23  * Based on gtkfilechooserutils.c:
  24  *      Copyright (C) 2003 Red Hat, Inc.
  25  */
  26
  27 #include "config.h"
  28
  29 #include "gtkrecentchooserutils.h"
  30
  31 /* Methods */
  32 static void      delegate_set_sort_func              (GtkRecentChooser  *chooser,
  33                                                       GtkRecentSortFunc  sort_func,
  34                                                       gpointer           sort_data,
  35                                                       GDestroyNotify     data_destroy);
  36 static void      delegate_add_filter                 (GtkRecentChooser  *chooser,
  37                                                       GtkRecentFilter   *filter);
  38 static void      delegate_remove_filter              (GtkRecentChooser  *chooser,
  39                                                       GtkRecentFilter   *filter);
  40 static GSList   *delegate_list_filters               (GtkRecentChooser  *chooser);
  41 static gboolean  delegate_select_uri                 (GtkRecentChooser  *chooser,
  42                                                       const gchar       *uri,
  43                                                       GError           **error);
  44 static void      delegate_unselect_uri               (GtkRecentChooser  *chooser,
  45                                                       const gchar       *uri);
  46 static GList    *delegate_get_items                  (GtkRecentChooser  *chooser);
  47 static GtkRecentManager *delegate_get_recent_manager (GtkRecentChooser  *chooser);
  48 static void      delegate_select_all                 (GtkRecentChooser  *chooser);
  49 static void      delegate_unselect_all               (GtkRecentChooser  *chooser);
  50 static gboolean  delegate_set_current_uri            (GtkRecentChooser  *chooser,
  51                                                       const gchar       *uri,
  52                                                       GError           **error);
  53 static gchar *   delegate_get_current_uri            (GtkRecentChooser  *chooser);
  54
  55 /* Signals */
  56 static void      delegate_notify            (GObject          *object,
  57                                              GParamSpec       *pspec,
  58                                              gpointer          user_data);
  59 static void      delegate_selection_changed (GtkRecentChooser *receiver,
  60                                              gpointer          user_data);
  61 static void      delegate_item_activated    (GtkRecentChooser *receiver,
  62                                              gpointer          user_data);
  63
  64 /**
  65  * _gtk_recent_chooser_install_properties:
  66  * @klass: the class structure for a type deriving from #GObject
  67  *
  68  * Installs the necessary properties for a class implementing
  69  * #GtkRecentChooser. A #GtkParamSpecOverride property is installed
  70  * for each property, using the values from the #GtkRecentChooserProp
  71  * enumeration. The caller must make sure itself that the enumeration
  72  * values don't collide with some other property values they
  73  * are using.
  74  */
  75 void
  76 _gtk_recent_chooser_install_properties (GObjectClass *klass)
  77 {
  78   g_object_class_override_property (klass,
  79                                     GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER,
  80                                     "recent-manager");
  81   g_object_class_override_property (klass,
  82                                     GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE,
  83                                     "show-private");
  84   g_object_class_override_property (klass,
  85                                     GTK_RECENT_CHOOSER_PROP_SHOW_TIPS,
  86                                     "show-tips");
  87   g_object_class_override_property (klass,
  88                                     GTK_RECENT_CHOOSER_PROP_SHOW_ICONS,
  89                                     "show-icons");
  90   g_object_class_override_property (klass,
  91                                     GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND,
  92                                     "show-not-found");
  93   g_object_class_override_property (klass,
  94                                     GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE,
  95                                     "select-multiple");
  96   g_object_class_override_property (klass,
  97                                     GTK_RECENT_CHOOSER_PROP_LIMIT,
  98                                     "limit");
  99   g_object_class_override_property (klass,
 100                                     GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY,
 101                                     "local-only");
 102   g_object_class_override_property (klass,
 103                                     GTK_RECENT_CHOOSER_PROP_SORT_TYPE,
 104                                     "sort-type");
 105   g_object_class_override_property (klass,
 106                                     GTK_RECENT_CHOOSER_PROP_FILTER,
 107                                     "filter");
 108 }
 109
 110 /**
 111  * _gtk_recent_chooser_delegate_iface_init:
 112  * @iface: a #GtkRecentChooserIface
 113  *
 114  * An interface-initialization function for use in cases where
 115  * an object is simply delegating the methods, signals of
 116  * the #GtkRecentChooser interface to another object.
 117  * _gtk_recent_chooser_set_delegate() must be called on each
 118  * instance of the object so that the delegate object can
 119  * be found.
 120  */
 121 void
 122 _gtk_recent_chooser_delegate_iface_init (GtkRecentChooserIface *iface)
 123 {
 124   iface->set_current_uri = delegate_set_current_uri;
 125   iface->get_current_uri = delegate_get_current_uri;
 126   iface->select_uri = delegate_select_uri;
 127   iface->unselect_uri = delegate_unselect_uri;
 128   iface->select_all = delegate_select_all;
 129   iface->unselect_all = delegate_unselect_all;
 130   iface->get_items = delegate_get_items;
 131   iface->get_recent_manager = delegate_get_recent_manager;
 132   iface->set_sort_func = delegate_set_sort_func;
 133   iface->add_filter = delegate_add_filter;
 134   iface->remove_filter = delegate_remove_filter;
 135   iface->list_filters = delegate_list_filters;
 136 }
 137
 138 /**
 139  * _gtk_recent_chooser_set_delegate:
 140  * @receiver: a #GObject implementing #GtkRecentChooser
 141  * @delegate: another #GObject implementing #GtkRecentChooser
 142  *
 143  * Establishes that calls on @receiver for #GtkRecentChooser
 144  * methods should be delegated to @delegate, and that
 145  * #GtkRecentChooser signals emitted on @delegate should be
 146  * forwarded to @receiver. Must be used in conjunction with
 147  * _gtk_recent_chooser_delegate_iface_init().
 148  */
 149 void
 150 _gtk_recent_chooser_set_delegate (GtkRecentChooser *receiver,
 151                                   GtkRecentChooser *delegate)
 152 {
 153   g_return_if_fail (GTK_IS_RECENT_CHOOSER (receiver));
 154   g_return_if_fail (GTK_IS_RECENT_CHOOSER (delegate));
 155
 156   g_object_set_data (G_OBJECT (receiver),
 157                     "gtk-recent-chooser-delegate", delegate);
 158
 159   g_signal_connect (delegate, "notify",
 160                     G_CALLBACK (delegate_notify), receiver);
 161   g_signal_connect (delegate, "selection-changed",
 162                     G_CALLBACK (delegate_selection_changed), receiver);
 163   g_signal_connect (delegate, "item_activated",
 164                     G_CALLBACK (delegate_item_activated), receiver);
 165 }
 166
 167 GQuark
 168 _gtk_recent_chooser_delegate_get_quark (void)
 169 {
 170   static GQuark quark = 0;
 171
 172   if (G_UNLIKELY (quark == 0))
 173     quark = g_quark_from_static_string ("gtk-recent-chooser-delegate");
 174
 175   return quark;
 176 }
 177
 178 static GtkRecentChooser *
 179 get_delegate (GtkRecentChooser *receiver)
 180 {
 181   return g_object_get_qdata (G_OBJECT (receiver),
 182                              GTK_RECENT_CHOOSER_DELEGATE_QUARK);
 183 }
 184
 185 static void
 186 delegate_set_sort_func (GtkRecentChooser  *chooser,
 187                         GtkRecentSortFunc  sort_func,
 188                         gpointer           sort_data,
 189                         GDestroyNotify     data_destroy)
 190 {
 191   gtk_recent_chooser_set_sort_func (get_delegate (chooser),
 192                                     sort_func,
 193                                     sort_data,
 194                                     data_destroy);
 195 }
 196
 197 static void
 198 delegate_add_filter (GtkRecentChooser *chooser,
 199                      GtkRecentFilter  *filter)
 200 {
 201   gtk_recent_chooser_add_filter (get_delegate (chooser), filter);
 202 }
 203
 204 static void
 205 delegate_remove_filter (GtkRecentChooser *chooser,
 206                         GtkRecentFilter  *filter)
 207 {
 208   gtk_recent_chooser_remove_filter (get_delegate (chooser), filter);
 209 }
 210
 211 static GSList *
 212 delegate_list_filters (GtkRecentChooser *chooser)
 213 {
 214   return gtk_recent_chooser_list_filters (get_delegate (chooser));
 215 }
 216
 217 static gboolean
 218 delegate_select_uri (GtkRecentChooser  *chooser,
 219                      const gchar       *uri,
 220                      GError           **error)
 221 {
 222   return gtk_recent_chooser_select_uri (get_delegate (chooser), uri, error);
 223 }
 224
 225 static void
 226 delegate_unselect_uri (GtkRecentChooser *chooser,
 227                        const gchar      *uri)
 228 {
 229  gtk_recent_chooser_unselect_uri (get_delegate (chooser), uri);
 230 }
 231
 232 static GList *
 233 delegate_get_items (GtkRecentChooser *chooser)
 234 {
 235   return gtk_recent_chooser_get_items (get_delegate (chooser));
 236 }
 237
 238 static GtkRecentManager *
 239 delegate_get_recent_manager (GtkRecentChooser *chooser)
 240 {
 241   return _gtk_recent_chooser_get_recent_manager (get_delegate (chooser));
 242 }
 243
 244 static void
 245 delegate_select_all (GtkRecentChooser *chooser)
 246 {
 247   gtk_recent_chooser_select_all (get_delegate (chooser));
 248 }
 249
 250 static void
 251 delegate_unselect_all (GtkRecentChooser *chooser)
 252 {
 253   gtk_recent_chooser_unselect_all (get_delegate (chooser));
 254 }
 255
 256 static gboolean
 257 delegate_set_current_uri (GtkRecentChooser  *chooser,
 258                           const gchar       *uri,
 259                           GError           **error)
 260 {
 261   return gtk_recent_chooser_set_current_uri (get_delegate (chooser), uri, error);
 262 }
 263
 264 static gchar *
 265 delegate_get_current_uri (GtkRecentChooser *chooser)
 266 {
 267   return gtk_recent_chooser_get_current_uri (get_delegate (chooser));
 268 }
 269
 270 static void
 271 delegate_notify (GObject    *object,
 272                  GParamSpec *pspec,
 273                  gpointer    user_data)
 274 {
 275   gpointer iface;
 276
 277   iface = g_type_interface_peek (g_type_class_peek (G_OBJECT_TYPE (object)),
 278                                  gtk_recent_chooser_get_type ());
 279   if (g_object_interface_find_property (iface, pspec->name))
 280     g_object_notify (user_data, pspec->name);
 281 }
 282
 283 static void
 284 delegate_selection_changed (GtkRecentChooser *receiver,
 285                             gpointer          user_data)
 286 {
 287   _gtk_recent_chooser_selection_changed (GTK_RECENT_CHOOSER (user_data));
 288 }
 289
 290 static void
 291 delegate_item_activated (GtkRecentChooser *receiver,
 292                          gpointer          user_data)
 293 {
 294   _gtk_recent_chooser_item_activated (GTK_RECENT_CHOOSER (user_data));
 295 }