src/egg/eggcolumnmodel.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /* egg-column-model.c
   3  * Copyright (C) 2001 Anders Carlsson, Jonathan Blanford
   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 "eggcolumnmodel.h"
  22
  23 #include <gtk/gtk.h>
  24 #include "plugin.h"
  25 static void update_columns (GtkTreeView *tree_view, EggColumnModel *column_model);
  26
  27
  28 enum
  29 {
  30   COLUMN_VISIBLE,
  31   COLUMN_NAME,
  32   COLUMN_OBJECT,
  33   N_COLUMNS
  34 };
  35
  36
  37
  38 static GObjectClass *parent_class = NULL;
  39
  40
  41 static gint
  42 egg_column_model_get_n_columns (GtkTreeModel *tree_model)
  43 {
  44     return N_COLUMNS;
  45 }
  46
  47 static GType
  48 egg_column_model_get_column_type (GtkTreeModel *tree_model,
  49                   gint          temp_index)
  50 {
  51   switch (temp_index)
  52     {
  53     case COLUMN_VISIBLE:
  54       return G_TYPE_BOOLEAN;
  55     case COLUMN_NAME:
  56       return G_TYPE_STRING;
  57     case COLUMN_OBJECT:
  58       return GTK_TYPE_TREE_VIEW_COLUMN;
  59     default:
  60       return G_TYPE_INVALID;
  61     }
  62 }
  63
  64 static gboolean
  65 egg_column_model_get_iter (GtkTreeModel *tree_model,
  66                GtkTreeIter  *iter,
  67                GtkTreePath  *path)
  68 {
  69   EggColumnModel *column_model = (EggColumnModel *) tree_model;
  70   GList *list;
  71   gint i;
  72
  73   i = gtk_tree_path_get_indices (path)[0];
  74   list = g_list_nth (column_model->columns, i);
  75
  76   if (list == NULL)
  77   {
  78
  79       return FALSE;
  80   }
  81   iter->stamp = column_model->stamp;
  82   iter->user_data = list;
  83
  84   return TRUE;
  85 }
  86
  87 static GtkTreePath *
  88 egg_column_model_get_path (GtkTreeModel *tree_model,
  89                GtkTreeIter  *iter)
  90 {
  91   EggColumnModel *column_model = (EggColumnModel *) tree_model;
  92   GtkTreePath *path;
  93   gint i = 0;
  94   GList *list;
  95
  96   g_return_val_if_fail (EGG_IS_COLUMN_MODEL (tree_model), NULL);
  97   g_return_val_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp, NULL);
  98
  99   for (list = column_model->columns; list; list = list->next)
 100     {
 101       if (list == (GList *)iter->user_data)
 102     break;
 103       i++;
 104     }
 105
 106   if (list == NULL)
 107     return NULL;
 108
 109   path = gtk_tree_path_new ();
 110   gtk_tree_path_append_index (path, i);
 111
 112   return path;
 113 }
 114
 115
 116 static gboolean
 117 egg_column_model_iter_has_child (GtkTreeModel *tree_model,
 118                  GtkTreeIter  *iter)
 119 {
 120   g_return_val_if_fail (EGG_IS_COLUMN_MODEL (tree_model), FALSE);
 121   g_return_val_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp, FALSE);
 122
 123   return FALSE;
 124 }
 125
 126 static void
 127 egg_column_model_get_value (GtkTreeModel *tree_model,
 128                 GtkTreeIter  *iter,
 129                 gint          column,
 130                 GValue       *value)
 131 {
 132   GtkTreeViewColumn *view_column;
 133
 134   g_return_if_fail (EGG_IS_COLUMN_MODEL (tree_model));
 135   g_return_if_fail (column < N_COLUMNS);
 136   g_return_if_fail (column >= 0);
 137   g_return_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp);
 138
 139   view_column = GTK_TREE_VIEW_COLUMN (((GList *)iter->user_data)->data);
 140   switch (column)
 141     {
 142     case COLUMN_VISIBLE:
 143       g_value_init (value, G_TYPE_BOOLEAN);
 144       g_value_set_boolean (value, gtk_tree_view_column_get_visible (view_column));
 145       break;
 146     case COLUMN_NAME:
 147       g_value_init (value, G_TYPE_STRING);
 148       g_value_set_string (value, gtk_tree_view_column_get_title (view_column));
 149       break;
 150     case COLUMN_OBJECT:
 151       g_value_init (value, GTK_TYPE_TREE_VIEW_COLUMN);
 152       g_value_set_object (value, view_column);
 153       break;
 154     default:
 155       g_assert_not_reached ();
 156       break;
 157     }
 158
 159 }
 160
 161 static gboolean
 162 egg_column_model_iter_next (GtkTreeModel *tree_model,
 163                 GtkTreeIter  *iter)
 164 {
 165   EggColumnModel *column_model;
 166
 167   g_return_val_if_fail (EGG_IS_COLUMN_MODEL (tree_model), FALSE);
 168   g_return_val_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp, FALSE);
 169
 170   column_model = EGG_COLUMN_MODEL (tree_model);
 171
 172   iter->user_data = ((GList *)iter->user_data)->next;
 173
 174   return (iter->user_data != NULL);
 175 }
 176
 177 static gint
 178 egg_column_model_iter_n_children (GtkTreeModel *tree_model,
 179                   GtkTreeIter  *iter)
 180 {
 181   g_return_val_if_fail (EGG_IS_COLUMN_MODEL (tree_model), 0);
 182
 183   if (iter)
 184     {
 185       g_return_val_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp, 0);
 186       return 0;
 187     }
 188
 189   return g_list_length (EGG_COLUMN_MODEL (tree_model)->columns);
 190 }
 191
 192 static gboolean
 193 egg_column_model_iter_nth_child (GtkTreeModel *tree_model,
 194                  GtkTreeIter  *iter,
 195                  GtkTreeIter  *parent,
 196                  gint          n)
 197 {
 198   EggColumnModel *column_model;
 199
 200   g_return_val_if_fail (EGG_IS_COLUMN_MODEL (tree_model), FALSE);
 201
 202   column_model = EGG_COLUMN_MODEL (tree_model);
 203   if (parent)
 204     {
 205       g_return_val_if_fail (parent->stamp == EGG_COLUMN_MODEL (tree_model)->stamp, FALSE);
 206       return FALSE;
 207     }
 208
 209   iter->user_data = g_list_nth ((GList *)column_model->columns, n);
 210
 211   if (iter->user_data == NULL)
 212       return FALSE;
 213
 214   iter->stamp = column_model->stamp;
 215   return TRUE;
 216
 217 }
 218
 219 /**
 220  * Gtk complains withouth this function, so add a dummy one.
 221  */
 222 static gboolean
 223 egg_column_model_iter_children(GtkTreeModel * tree_model,
 224         GtkTreeIter * iter, GtkTreeIter * parent)
 225 {
 226     return FALSE;
 227 }
 228
 229 static void
 230 egg_column_model_tree_model_init (GtkTreeModelIface *iface)
 231 {
 232   iface->get_n_columns = egg_column_model_get_n_columns;
 233   iface->get_column_type = egg_column_model_get_column_type;
 234   iface->get_iter = egg_column_model_get_iter;
 235   iface->get_path = egg_column_model_get_path;
 236   iface->get_value = egg_column_model_get_value;
 237   iface->iter_has_child = egg_column_model_iter_has_child;
 238   iface->iter_next = egg_column_model_iter_next;
 239   iface->iter_nth_child = egg_column_model_iter_nth_child;
 240   iface->iter_n_children = egg_column_model_iter_n_children;
 241   iface->iter_children = egg_column_model_iter_children;
 242 }
 243
 244 static gboolean
 245 egg_column_model_drag_data_get (GtkTreeDragSource *drag_source, GtkTreePath *path, GtkSelectionData *selection_data)
 246 {
 247 #if 0
 248     if (gtk_selection_data_set_tree_row (selection_data,
 249                          GTK_TREE_MODEL (drag_source),
 250                          path)) {
 251         return TRUE;
 252     }
 253     else {
 254     }
 255 #endif
 256     return FALSE;
 257 }
 258
 259 static gboolean
 260 egg_column_model_drag_data_delete (GtkTreeDragSource *drag_source, GtkTreePath *path)
 261 {
 262   return FALSE;
 263 }
 264
 265 static void
 266 egg_column_model_drag_source_init (GtkTreeDragSourceIface *iface)
 267 {
 268   iface->drag_data_get = egg_column_model_drag_data_get;
 269   iface->drag_data_delete = egg_column_model_drag_data_delete;
 270 }
 271
 272 static gboolean
 273 egg_column_model_row_drop_possible (GtkTreeDragDest  *drag_dest,
 274                     GtkTreePath      *dest_path,
 275                     GtkSelectionData *selection_data)
 276 {
 277   gint *indices;
 278
 279   g_return_val_if_fail (EGG_IS_COLUMN_MODEL (drag_dest), FALSE);
 280
 281   if (gtk_tree_path_get_depth (dest_path) != 1)
 282     return FALSE;
 283
 284   indices = gtk_tree_path_get_indices (dest_path);
 285
 286   if ((guint)indices[0] <= g_list_length (((EggColumnModel *)drag_dest)->columns))
 287     return TRUE;
 288   else
 289     return FALSE;
 290 }
 291
 292 static void
 293 egg_column_model_drag_dest_init (GtkTreeDragDestIface *iface)
 294 {
 295   iface->row_drop_possible = egg_column_model_row_drop_possible;
 296 }
 297
 298 static void
 299 egg_column_model_init (EggColumnModel *model)
 300 {
 301   do
 302     {
 303       model->stamp = g_random_int ();
 304     }
 305   while (model->stamp == 0);
 306 }
 307
 308 static void
 309 egg_column_model_finalize (GObject *object)
 310 {
 311   EggColumnModel *model;
 312
 313   model = (EggColumnModel *)object;
 314
 315   g_list_free (model->columns);
 316
 317   g_signal_handlers_disconnect_by_func (G_OBJECT (model->tree_view), (void*)update_columns, model);
 318
 319   G_OBJECT_CLASS (parent_class)->finalize (object);
 320 }
 321
 322 static void
 323 egg_column_model_class_init (EggColumnModelClass *klass)
 324 {
 325   GObjectClass *object_class;
 326
 327   object_class = (GObjectClass *)klass;
 328
 329   parent_class = (GObjectClass *)g_type_class_peek_parent (klass);
 330
 331   object_class->finalize = egg_column_model_finalize;
 332 }
 333
 334 GType
 335 egg_column_model_get_type (void)
 336 {
 337   static GType object_type = 0;
 338
 339   if (!object_type)
 340     {
 341       static const GTypeInfo object_info =
 342     {
 343       sizeof (EggColumnModelClass),
 344       NULL,
 345       NULL,
 346       (GClassInitFunc) egg_column_model_class_init,
 347       NULL,
 348       NULL,
 349       sizeof (EggColumnModel),
 350       0,
 351       (GInstanceInitFunc) egg_column_model_init,
 352     };
 353
 354       static const GInterfaceInfo tree_model_info =
 355     {
 356       (GInterfaceInitFunc) egg_column_model_tree_model_init,
 357       NULL,
 358       NULL
 359     };
 360
 361       static const GInterfaceInfo drag_source_info =
 362     {
 363       (GInterfaceInitFunc) egg_column_model_drag_source_init,
 364       NULL,
 365       NULL
 366     };
 367
 368       static const GInterfaceInfo drag_dest_info =
 369     {
 370       (GInterfaceInitFunc) egg_column_model_drag_dest_init,
 371       NULL,
 372       NULL
 373     };
 374
 375       object_type = g_type_register_static (G_TYPE_OBJECT, "EggColumnModel", &object_info, (GTypeFlags)0);
 376       g_type_add_interface_static (object_type,
 377                    GTK_TYPE_TREE_MODEL,
 378                    &tree_model_info);
 379       g_type_add_interface_static (object_type,
 380                    GTK_TYPE_TREE_DRAG_SOURCE,
 381                    &drag_source_info);
 382       g_type_add_interface_static (object_type,
 383                    GTK_TYPE_TREE_DRAG_DEST,
 384                          &drag_dest_info);
 385     }
 386
 387   return object_type;
 388 }
 389
 390 static void
 391 update_columns (GtkTreeView    *tree_view,
 392         EggColumnModel *column_model)
 393 {
 394   GList *old_columns = column_model->columns;
 395   gint old_length, length;
 396   GList *a, *b;
 397
 398   column_model->columns = gtk_tree_view_get_columns (column_model->tree_view);
 399
 400   /* As the view tells us one change at a time, we can do this hack. */
 401   length = g_list_length (column_model->columns);
 402   old_length = g_list_length (old_columns);
 403
 404   if (length != old_length)
 405     {
 406       GtkTreePath *path;
 407       gint i = 0;
 408
 409       /* Find out where they differ */
 410       for (a = old_columns, b = column_model->columns; a && b; a = a->next, b = b->next) {
 411     if (a->data != b->data)
 412       break;
 413     i++;
 414       }
 415
 416       path = gtk_tree_path_new ();
 417       gtk_tree_path_append_index (path, i);
 418
 419       if (length < old_length)
 420     {
 421       column_model->stamp++;
 422       gtk_tree_model_row_deleted (GTK_TREE_MODEL (column_model), path);
 423     }
 424       else
 425     {
 426       GtkTreeIter iter;
 427
 428       iter.stamp = column_model->stamp;
 429       iter.user_data = b;
 430       gtk_tree_model_row_inserted (GTK_TREE_MODEL (column_model), path, &iter);
 431     }
 432
 433       gtk_tree_path_free (path);
 434     }
 435   else
 436     {
 437       gint i;
 438       gint m = 0, n = 1;
 439       gint *new_order;
 440       GtkTreePath *path;
 441
 442       new_order = g_new (int, length);
 443       a = old_columns; b = column_model->columns;
 444
 445       while (a->data == b->data) {
 446     a = a->next;
 447     b = b->next;
 448
 449     if (a == NULL)
 450     {
 451         g_free(new_order);
 452         return;
 453     }
 454     m++;
 455       }
 456
 457       if (a->next->data == b->data)
 458     {
 459       b = b->next;
 460       while (b->data != a->data)
 461         {
 462           b = b->next;
 463           n++;
 464         }
 465       for (i = 0; i < m; i++)
 466         new_order[i] = i;
 467       for (i = m; i < m+n; i++)
 468         new_order[i] = i+1;
 469       new_order[i] = m;
 470       for (i = m + n +1; i < length; i++)
 471         new_order[i] = i;
 472     }
 473       else
 474     {
 475       a = a->next;
 476       while (a->data != b->data)
 477         {
 478           a = a->next;
 479           n++;
 480         }
 481       for (i = 0; i < m; i++)
 482         new_order[i] = i;
 483       new_order[m] = m+n;
 484       for (i = m+1; i < m + n+ 1; i++)
 485         new_order[i] = i - 1;
 486       for (i = m + n + 1; i < length; i++)
 487         new_order[i] = i;
 488     }
 489
 490       path = gtk_tree_path_new ();
 491       gtk_tree_model_rows_reordered (GTK_TREE_MODEL (column_model),
 492                      path,
 493                      NULL,
 494                      new_order);
 495       gtk_tree_path_free (path);
 496       g_free (new_order);
 497     }
 498
 499   if (old_columns)
 500     g_list_free (old_columns);
 501 }
 502
 503 EggColumnModel *
 504 egg_column_model_new (GtkTreeView *tree_view)
 505 {
 506   EggColumnModel *model;
 507
 508   model = (EggColumnModel *)g_object_new (egg_column_model_get_type (), NULL);
 509
 510   model->tree_view = tree_view;
 511   model->columns = gtk_tree_view_get_columns (tree_view);
 512
 513   g_signal_connect (G_OBJECT (tree_view), "columns_changed",
 514             G_CALLBACK (update_columns), model);
 515
 516   return model;
 517 }
 518
 519 void
 520 egg_column_model_set_column_visible (EggColumnModel *model, GtkTreeIter *iter, gboolean visible)
 521 {
 522   GtkTreeViewColumn *column;
 523   GtkTreePath *path;
 524   gchar *string = NULL;
 525   gpointer data;
 526   int colid = 0;
 527   path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter);
 528
 529   column = (GtkTreeViewColumn *)((GList *)iter->user_data)->data;
 530   data = g_object_get_data(G_OBJECT(column), "colid");
 531   colid = GPOINTER_TO_INT(data);
 532
 533   gtk_tree_view_column_set_visible (column, visible);
 534   gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, iter);
 535
 536   /* custom code */
 537   string = g_strdup_printf("%i", colid);
 538   cfg_set_single_value_as_int(config, "current-playlist-column-enable",string, visible);
 539
 540   gtk_tree_path_free (path);
 541 }
 542
 543 gboolean
 544 egg_column_model_get_column_visible (EggColumnModel *model, GtkTreeIter *iter)
 545 {
 546   GtkTreeViewColumn *column;
 547
 548
 549   g_return_val_if_fail (model->stamp == iter->stamp, FALSE);
 550
 551   column = (GtkTreeViewColumn *)((GList *)iter->user_data)->data;
 552
 553   return gtk_tree_view_column_get_visible (column);
 554 }
 555
 556 gboolean
 557 egg_column_model_is_column_first (EggColumnModel *model, GtkTreeIter *iter)
 558 {
 559   g_return_val_if_fail (model->stamp == iter->stamp, FALSE);
 560
 561   return (((GList *)iter->user_data)->prev == NULL);
 562 }
 563
 564 gboolean
 565 egg_column_model_is_column_last (EggColumnModel *model, GtkTreeIter *iter)
 566 {
 567   g_return_val_if_fail (model->stamp == iter->stamp, FALSE);
 568
 569   return (((GList *)iter->user_data)->next == NULL);
 570 }
 571
 572 void
 573 egg_column_model_move_down_column (EggColumnModel *model, GtkTreeIter *iter)
 574 {
 575   GtkTreeViewColumn *column, *base_column;
 576   GList *node;
 577
 578   g_return_if_fail (model->stamp == iter->stamp);
 579   g_return_if_fail (((GList *)iter->user_data)->next != NULL);
 580
 581   node = (GList *)iter->user_data;
 582
 583   column = (GtkTreeViewColumn *)node->data;
 584   base_column = (GtkTreeViewColumn *)node->next->data;
 585
 586   gtk_tree_view_move_column_after (model->tree_view, column, base_column);
 587 }
 588
 589 void
 590 egg_column_model_move_up_column (EggColumnModel *model, GtkTreeIter *iter)
 591 {
 592   GtkTreeViewColumn *column, *base_column;
 593   GList *node;
 594
 595   g_return_if_fail (model->stamp == iter->stamp);
 596   g_return_if_fail (((GList *)iter->user_data)->prev != NULL);
 597
 598   node = (GList *)iter->user_data;
 599
 600   column = (GtkTreeViewColumn *)node->prev->data;
 601   base_column = (GtkTreeViewColumn *)node->data;
 602
 603   gtk_tree_view_move_column_after (model->tree_view, column, base_column);
 604 }