ROX-Filer/src/view_iface.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2002, the ROX-Filer team.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* view_iface.c - operations supported by all views */
  23
  24 #include "config.h"
  25
  26 #include "global.h"
  27
  28 #include "view_iface.h"
  29 #include "support.h"
  30 #include "filer.h"
  31 #include "diritem.h"
  32
  33 /* A word about interfaces:
  34  *
  35  * gobject's documentation's explanation of interfaces leaves something[1] to
  36  * be desired, so I'd better explain here...
  37  *
  38  * [1] Like, eg, an explanation.
  39  *
  40  * A ViewIfaceClass is a struct which contains a number of function
  41  * pointers. Each class that implements the View interface creates its
  42  * own ViewIfaceClass with pointers to its implementation. This is stored
  43  * with the class.
  44  *
  45  * When you want to call a method (eg, sort()) on a View, you call
  46  * view_sort(object) here, which gets the class of object and then looks
  47  * for that class's implementation of the View interface, and then calls
  48  * the actual function through that.
  49  */
  50
  51 /* ViewIters
  52  *
  53  * A ViewIter is used to index items. They are usually allocated
  54  * on the stack and then initialised using view_get_iter().
  55  *
  56  * Normally, an iterator starts of not pointing at any item, but
  57  * each call to iter->next(iter) returns the next item, and leaves
  58  * the iterator pointing at the returned item. If you like the item,
  59  * you can then pass the iterator to view_cursor_to_iter(), etc.
  60  *
  61  * Using flags passed to view_get_iter, you can start the sequence from the
  62  * beginning, end, cursor or 'base' (a saved cursor position). You can
  63  * go forwards or backwards. You can opt to only get selected items returned.
  64  *
  65  * You can also have one-shot iterators which already point to an item, and
  66  * you never call the next method (view_get_cursor, for example). In fact,
  67  * these iterators return a sequence of one item, but next() gets called
  68  * automatically for you.
  69  *
  70  * You don't need to free iterators, and they become invalid if the
  71  * View changes (items added, removed or altered), so don't hang on to
  72  * them!
  73  */
  74
  75 /****************************************************************
  76  *                      EXTERNAL INTERFACE                      *
  77  ****************************************************************/
  78
  79 GType view_iface_get_type(void)
  80 {
  81         static GType iface_type = 0;
  82
  83         if (!iface_type)
  84         {
  85                 static const GTypeInfo iface_info =
  86                 {
  87                         sizeof (ViewIfaceClass),
  88                         NULL,           /* base_init */
  89                         NULL,           /* base_finalize */
  90                 };
  91
  92                 iface_type = g_type_register_static(G_TYPE_INTERFACE,
  93                                                 "ViewIface", &iface_info, 0);
  94
  95                 /* Actually, all Views should be GTK_TYPE_WIDGETs, to be more
  96                  * accurate, but including gtk.h takes so long, and noone's
  97                  * going to get this wrong ;-)
  98                  */
  99                 g_type_interface_add_prerequisite(iface_type, G_TYPE_OBJECT);
 100         }
 101
 102         return iface_type;
 103 }
 104
 105 /* The sort function has changed -- resort */
 106 void view_sort(ViewIface *obj)
 107 {
 108         g_return_if_fail(VIEW_IS_IFACE(obj));
 109         VIEW_IFACE_GET_CLASS(obj)->sort(obj);
 110 }
 111
 112 /* The style has changed -- shrink the grid and redraw.
 113  * Also update ViewData (and name layout too) if appropriate
 114  * flags are set.
 115  */
 116 void view_style_changed(ViewIface *obj, int flags)
 117 {
 118         g_return_if_fail(VIEW_IS_IFACE(obj));
 119
 120         VIEW_IFACE_GET_CLASS(obj)->style_changed(obj, flags);
 121 }
 122
 123 /* Wink or move the cursor to this item, if present. Return TRUE on
 124  * success (iff leaf was present).
 125  */
 126 gboolean view_autoselect(ViewIface *obj, const gchar *leaf)
 127 {
 128         g_return_val_if_fail(VIEW_IS_IFACE(obj), FALSE);
 129         g_return_val_if_fail(leaf != NULL, FALSE);
 130
 131         return VIEW_IFACE_GET_CLASS(obj)->autoselect(obj, leaf);
 132 }
 133
 134 /* Scanning has turned up some new items... */
 135 void view_add_items(ViewIface *obj, GPtrArray *items)
 136 {
 137         VIEW_IFACE_GET_CLASS(obj)->add_items(obj, items);
 138 }
 139
 140 /* These items are already known, but have changed... */
 141 void view_update_items(ViewIface *obj, GPtrArray *items)
 142 {
 143         VIEW_IFACE_GET_CLASS(obj)->update_items(obj, items);
 144 }
 145
 146 /* Call test(item) for each item in the view and delete all those for
 147  * which it returns TRUE.
 148  */
 149 void view_delete_if(ViewIface *obj,
 150                     gboolean (*test)(gpointer item, gpointer data),
 151                     gpointer data)
 152 {
 153         g_return_if_fail(VIEW_IS_IFACE(obj));
 154
 155         VIEW_IFACE_GET_CLASS(obj)->delete_if(obj, test, data);
 156 }
 157
 158 /* Remove all items from the view (used when changing directory) */
 159 void view_clear(ViewIface *obj)
 160 {
 161         g_return_if_fail(VIEW_IS_IFACE(obj));
 162
 163         VIEW_IFACE_GET_CLASS(obj)->clear(obj);
 164 }
 165
 166 /* Select all items */
 167 void view_select_all(ViewIface *obj)
 168 {
 169         g_return_if_fail(VIEW_IS_IFACE(obj));
 170
 171         VIEW_IFACE_GET_CLASS(obj)->select_all(obj);
 172 }
 173
 174 /* Unselect all items */
 175 void view_clear_selection(ViewIface *obj)
 176 {
 177         g_return_if_fail(VIEW_IS_IFACE(obj));
 178
 179         VIEW_IFACE_GET_CLASS(obj)->clear_selection(obj);
 180 }
 181
 182 /* Return the total number of items */
 183 int view_count_items(ViewIface *obj)
 184 {
 185         g_return_val_if_fail(VIEW_IS_IFACE(obj), 0);
 186
 187         return VIEW_IFACE_GET_CLASS(obj)->count_items(obj);
 188 }
 189
 190 /* Return the number of selected items */
 191 int view_count_selected(ViewIface *obj)
 192 {
 193         g_return_val_if_fail(VIEW_IS_IFACE(obj), 0);
 194
 195         return VIEW_IFACE_GET_CLASS(obj)->count_selected(obj);
 196 }
 197
 198 void view_show_cursor(ViewIface *obj)
 199 {
 200         g_return_if_fail(VIEW_IS_IFACE(obj));
 201
 202         VIEW_IFACE_GET_CLASS(obj)->show_cursor(obj);
 203 }
 204
 205 /* Create an iterator which will return each element selected by 'flags'
 206  * from successive calls to iter.next(&iter). NULL indicates the end
 207  * of the sequence.
 208  *
 209  * The iterator does not need to be freed. It becomes invalid if the
 210  * view is changed in any way.
 211  */
 212 void view_get_iter(ViewIface *obj, ViewIter *iter, IterFlags flags)
 213 {
 214         g_return_if_fail(VIEW_IS_IFACE(obj));
 215         g_return_if_fail(iter != NULL);
 216
 217         VIEW_IFACE_GET_CLASS(obj)->get_iter(obj, iter, flags);
 218 }
 219
 220 /* Make an 'iter' for the cursor item, if any. Use iter->peek() to get
 221  * the DirItem (will be NULL if the cursor isn't on an item).
 222  */
 223 void view_get_cursor(ViewIface *obj, ViewIter *iter)
 224 {
 225         g_return_if_fail(VIEW_IS_IFACE(obj));
 226         g_return_if_fail(iter != NULL);
 227
 228         VIEW_IFACE_GET_CLASS(obj)->get_iter(obj, iter,
 229                                 VIEW_ITER_FROM_CURSOR | VIEW_ITER_ONE_ONLY);
 230 }
 231
 232 /* Position cursor on the last item returned by iter.next().
 233  * If iter is NULL, remove the cursor.
 234  */
 235 void view_cursor_to_iter(ViewIface *obj, ViewIter *iter)
 236 {
 237         g_return_if_fail(VIEW_IS_IFACE(obj));
 238
 239         VIEW_IFACE_GET_CLASS(obj)->cursor_to_iter(obj, iter);
 240 }
 241
 242 /* Select the item at this iter */
 243 void view_set_selected(ViewIface *obj, ViewIter *iter, gboolean selected)
 244 {
 245         g_return_if_fail(VIEW_IS_IFACE(obj));
 246
 247         VIEW_IFACE_GET_CLASS(obj)->set_selected(obj, iter, selected);
 248 }
 249
 250 /* TRUE if this item is selected */
 251 gboolean view_get_selected(ViewIface *obj, ViewIter *iter)
 252 {
 253         g_return_val_if_fail(VIEW_IS_IFACE(obj), FALSE);
 254
 255         return VIEW_IFACE_GET_CLASS(obj)->get_selected(obj, iter);
 256 }
 257
 258 /* Flash / draw attention to this item */
 259 void view_wink_item(ViewIface *obj, ViewIter *iter)
 260 {
 261         g_return_if_fail(VIEW_IS_IFACE(obj));
 262
 263         VIEW_IFACE_GET_CLASS(obj)->wink_item(obj, iter);
 264 }
 265
 266 /* Clear the selection, then select this item. Does it atomically to avoid
 267  * problems with giving up and quickly reclaiming the primary selection.
 268  */
 269 void view_select_only(ViewIface *obj, ViewIter *iter)
 270 {
 271         g_return_if_fail(VIEW_IS_IFACE(obj));
 272
 273         VIEW_IFACE_GET_CLASS(obj)->select_only(obj, iter);
 274 }
 275
 276 void view_select_if(ViewIface *obj,
 277                     gboolean (*test)(ViewIter *iter, gpointer data),
 278                     gpointer data)
 279 {
 280         ViewIter iter;
 281         gboolean should_select_first;
 282
 283         g_return_if_fail(VIEW_IS_IFACE(obj));
 284
 285         view_get_iter(obj, &iter, 0);
 286
 287         if (!iter.next(&iter))
 288                 return;         /* No items */
 289
 290         view_freeze(obj);
 291
 292         /* If anything is currently selected then select the first item now
 293          * and set it to its correct value at the end (avoids losing the
 294          * primary and regaining it quickly). Do the test first in case it
 295          * relies on the selected state!
 296          */
 297         should_select_first = test(&iter, data);
 298         if (view_count_selected(obj))
 299                 view_set_selected(obj, &iter, TRUE);
 300
 301         while (iter.next(&iter))
 302                 view_set_selected(obj, &iter, test(&iter, data));
 303
 304         view_get_iter(obj, &iter, 0);
 305         iter.next(&iter);
 306         view_set_selected(obj, &iter, should_select_first);
 307
 308         view_thaw(obj);
 309 }
 310
 311 /* Prevent selection_changed events from being emitted */
 312 void view_freeze(ViewIface *obj)
 313 {
 314         g_return_if_fail(VIEW_IS_IFACE(obj));
 315
 316         VIEW_IFACE_GET_CLASS(obj)->set_frozen(obj, TRUE);
 317 }
 318
 319 /* Undo a view_freeze (and emit the changed signal) */
 320 void view_thaw(ViewIface *obj)
 321 {
 322         g_return_if_fail(VIEW_IS_IFACE(obj));
 323
 324         VIEW_IFACE_GET_CLASS(obj)->set_frozen(obj, FALSE);
 325 }
 326
 327 /* Resize the filer window to a sensible size.
 328  * v_border is the height of the toolbar + the minibuffer (if visible).
 329  * space is
 330  * If allow_shrink is
 331  */
 332 void view_autosize(ViewIface *obj)
 333 {
 334         g_return_if_fail(VIEW_IS_IFACE(obj));
 335
 336         VIEW_IFACE_GET_CLASS(obj)->autosize(obj);
 337 }
 338
 339 /* Return TRUE if the cursor is shown. Note that the cursor may be visible
 340  * even if their are no items (so get_cursor().peek() would return NULL).
 341  */
 342 gboolean view_cursor_visible(ViewIface *obj)
 343 {
 344         g_return_val_if_fail(VIEW_IS_IFACE(obj), FALSE);
 345
 346         return VIEW_IFACE_GET_CLASS(obj)->cursor_visible(obj);
 347 }
 348
 349 /* The 'base' position is used to record the position of the cursor
 350  * when the minibuffer is opened, for interactive searching.
 351  */
 352 void view_set_base(ViewIface *obj, ViewIter *iter)
 353 {
 354         g_return_if_fail(VIEW_IS_IFACE(obj));
 355
 356         VIEW_IFACE_GET_CLASS(obj)->set_base(obj, iter);
 357 }
 358
 359 /* Returns an interator which yields just the item under the pointer.
 360  * iter.peek() will return NULL if no item was under the pointer.
 361  * x, y is relative to the window which generates events for the widget.
 362  */
 363 void view_get_iter_at_point(ViewIface *obj, ViewIter *iter, int x, int y)
 364 {
 365         g_return_if_fail(VIEW_IS_IFACE(obj));
 366
 367         VIEW_IFACE_GET_CLASS(obj)->get_iter_at_point(obj, iter, x, y);
 368 }
 369
 370 /* Begin a drag to select a group of icons */
 371 void view_start_lasso_box(ViewIface *obj, GdkEventButton *event)
 372 {
 373         g_return_if_fail(VIEW_IS_IFACE(obj));
 374
 375         VIEW_IFACE_GET_CLASS(obj)->start_lasso_box(obj, event);
 376 }
 377
 378 /* Add anything useful to the tooltip string. Used to include the name of
 379  * items where the name is shown truncated.
 380  */
 381 void view_extend_tip(ViewIface *obj, ViewIter *iter, GString *tip)
 382 {
 383         g_return_if_fail(VIEW_IS_IFACE(obj));
 384
 385         VIEW_IFACE_GET_CLASS(obj)->extend_tip(obj, iter, tip);
 386 }