e-util/e-table-subset.c

   1 /*
   2  *
   3  * This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the GNU Lesser General Public License as published by
   5  * the Free Software Foundation.
   6  *
   7  * This program is distributed in the hope that it will be useful, but
   8  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   9  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  10  * for more details.
  11  *
  12  * You should have received a copy of the GNU Lesser General Public License
  13  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  14  *
  15  *
  16  * Authors:
  17  *              Chris Lahey <clahey@ximian.com>
  18  *              Miguel de Icaza <miguel@ximian.com>
  19  *
  20  * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <stdlib.h>
  29
  30 #include "e-table-subset.h"
  31
  32 #define E_TABLE_SUBSET_GET_PRIVATE(obj) \
  33         (G_TYPE_INSTANCE_GET_PRIVATE \
  34         ((obj), E_TYPE_TABLE_SUBSET, ETableSubsetPrivate))
  35
  36 #define VALID_ROW(table_subset, row) \
  37         (row >= -1 && row < table_subset->n_map)
  38 #define MAP_ROW(table_subset, row) \
  39         (row == -1 ? -1 : table_subset->map_table[row])
  40
  41 #define d(x)
  42
  43 struct _ETableSubsetPrivate {
  44         ETableModel *source_model;
  45         gulong table_model_pre_change_handler_id;
  46         gulong table_model_no_change_handler_id;
  47         gulong table_model_changed_handler_id;
  48         gulong table_model_row_changed_handler_id;
  49         gulong table_model_cell_changed_handler_id;
  50         gulong table_model_rows_inserted_handler_id;
  51         gulong table_model_rows_deleted_handler_id;
  52
  53         gint last_access;
  54 };
  55
  56 /* Forward Declarations */
  57 static void     e_table_subset_table_model_init
  58                                         (ETableModelInterface *iface);
  59
  60 G_DEFINE_TYPE_WITH_CODE (
  61         ETableSubset,
  62         e_table_subset,
  63         G_TYPE_OBJECT,
  64         G_IMPLEMENT_INTERFACE (
  65                 E_TYPE_TABLE_MODEL,
  66                 e_table_subset_table_model_init))
  67
  68 static gint
  69 table_subset_get_view_row (ETableSubset *table_subset,
  70                            gint row)
  71 {
  72         const gint n = table_subset->n_map;
  73         const gint * const map_table = table_subset->map_table;
  74         gint i;
  75
  76         gint end = MIN (
  77                 table_subset->n_map,
  78                 table_subset->priv->last_access + 10);
  79         gint start = MAX (0, table_subset->priv->last_access - 10);
  80         gint initial = MAX (MIN (table_subset->priv->last_access, end), start);
  81
  82         for (i = initial; i < end; i++) {
  83                 if (map_table[i] == row) {
  84                         table_subset->priv->last_access = i;
  85                         return i;
  86                 }
  87         }
  88
  89         for (i = initial - 1; i >= start; i--) {
  90                 if (map_table[i] == row) {
  91                         table_subset->priv->last_access = i;
  92                         return i;
  93                 }
  94         }
  95
  96         for (i = 0; i < n; i++) {
  97                 if (map_table[i] == row) {
  98                         table_subset->priv->last_access = i;
  99                         return i;
 100                 }
 101         }
 102         return -1;
 103 }
 104
 105 static void
 106 table_subset_dispose (GObject *object)
 107 {
 108         ETableSubsetPrivate *priv;
 109
 110         priv = E_TABLE_SUBSET_GET_PRIVATE (object);
 111
 112         if (priv->table_model_pre_change_handler_id > 0) {
 113                 g_signal_handler_disconnect (
 114                         priv->source_model,
 115                         priv->table_model_pre_change_handler_id);
 116                 priv->table_model_pre_change_handler_id = 0;
 117         }
 118
 119         if (priv->table_model_no_change_handler_id > 0) {
 120                 g_signal_handler_disconnect (
 121                         priv->source_model,
 122                         priv->table_model_no_change_handler_id);
 123                 priv->table_model_no_change_handler_id = 0;
 124         }
 125
 126         if (priv->table_model_changed_handler_id > 0) {
 127                 g_signal_handler_disconnect (
 128                         priv->source_model,
 129                         priv->table_model_changed_handler_id);
 130                 priv->table_model_changed_handler_id = 0;
 131         }
 132
 133         if (priv->table_model_row_changed_handler_id > 0) {
 134                 g_signal_handler_disconnect (
 135                         priv->source_model,
 136                         priv->table_model_row_changed_handler_id);
 137                 priv->table_model_row_changed_handler_id = 0;
 138         }
 139
 140         if (priv->table_model_cell_changed_handler_id > 0) {
 141                 g_signal_handler_disconnect (
 142                         priv->source_model,
 143                         priv->table_model_cell_changed_handler_id);
 144                 priv->table_model_cell_changed_handler_id = 0;
 145         }
 146
 147         if (priv->table_model_rows_inserted_handler_id > 0) {
 148                 g_signal_handler_disconnect (
 149                         priv->source_model,
 150                         priv->table_model_rows_inserted_handler_id);
 151                 priv->table_model_rows_inserted_handler_id = 0;
 152         }
 153
 154         if (priv->table_model_rows_deleted_handler_id > 0) {
 155                 g_signal_handler_disconnect (
 156                         priv->source_model,
 157                         priv->table_model_rows_deleted_handler_id);
 158                 priv->table_model_rows_deleted_handler_id = 0;
 159         }
 160
 161         g_clear_object (&priv->source_model);
 162
 163         /* Chain up to parent's dispose() method. */
 164         G_OBJECT_CLASS (e_table_subset_parent_class)->dispose (object);
 165 }
 166
 167 static void
 168 table_subset_finalize (GObject *object)
 169 {
 170         ETableSubset *table_subset;
 171
 172         table_subset = E_TABLE_SUBSET (object);
 173
 174         g_free (table_subset->map_table);
 175
 176         /* Chain up to parent's finalize() method. */
 177         G_OBJECT_CLASS (e_table_subset_parent_class)->finalize (object);
 178 }
 179
 180 static void
 181 table_subset_proxy_model_pre_change_real (ETableSubset *table_subset,
 182                                           ETableModel *source_model)
 183 {
 184         e_table_model_pre_change (E_TABLE_MODEL (table_subset));
 185 }
 186
 187 static void
 188 table_subset_proxy_model_no_change_real (ETableSubset *table_subset,
 189                                          ETableModel *source_model)
 190 {
 191         e_table_model_no_change (E_TABLE_MODEL (table_subset));
 192 }
 193
 194 static void
 195 table_subset_proxy_model_changed_real (ETableSubset *table_subset,
 196                                        ETableModel *source_model)
 197 {
 198         e_table_model_changed (E_TABLE_MODEL (table_subset));
 199 }
 200
 201 static void
 202 table_subset_proxy_model_row_changed_real (ETableSubset *table_subset,
 203                                            ETableModel *source_model,
 204                                            gint row)
 205 {
 206         gint view_row = table_subset_get_view_row (table_subset, row);
 207
 208         if (view_row != -1)
 209                 e_table_model_row_changed (
 210                         E_TABLE_MODEL (table_subset), view_row);
 211         else
 212                 e_table_model_no_change (E_TABLE_MODEL (table_subset));
 213 }
 214
 215 static void
 216 table_subset_proxy_model_cell_changed_real (ETableSubset *table_subset,
 217                                             ETableModel *source_model,
 218                                             gint col,
 219                                             gint row)
 220 {
 221         gint view_row = table_subset_get_view_row (table_subset, row);
 222
 223         if (view_row != -1)
 224                 e_table_model_cell_changed (
 225                         E_TABLE_MODEL (table_subset), col, view_row);
 226         else
 227                 e_table_model_no_change (E_TABLE_MODEL (table_subset));
 228 }
 229
 230 static void
 231 table_subset_proxy_model_rows_inserted_real (ETableSubset *table_subset,
 232                                              ETableModel *source_model,
 233                                              gint row,
 234                                              gint count)
 235 {
 236         e_table_model_no_change (E_TABLE_MODEL (table_subset));
 237 }
 238
 239 static void
 240 table_subset_proxy_model_rows_deleted_real (ETableSubset *table_subset,
 241                                             ETableModel *source_model,
 242                                             gint row,
 243                                             gint count)
 244 {
 245         e_table_model_no_change (E_TABLE_MODEL (table_subset));
 246 }
 247
 248 static gint
 249 table_subset_column_count (ETableModel *table_model)
 250 {
 251         ETableSubset *table_subset = (ETableSubset *) table_model;
 252
 253         return e_table_model_column_count (table_subset->priv->source_model);
 254 }
 255
 256 static gint
 257 table_subset_row_count (ETableModel *table_model)
 258 {
 259         ETableSubset *table_subset = (ETableSubset *) table_model;
 260
 261         return table_subset->n_map;
 262 }
 263
 264 static gpointer
 265 table_subset_value_at (ETableModel *table_model,
 266                        gint col,
 267                        gint row)
 268 {
 269         ETableSubset *table_subset = (ETableSubset *) table_model;
 270
 271         g_return_val_if_fail (VALID_ROW (table_subset, row), NULL);
 272
 273         table_subset->priv->last_access = row;
 274
 275         return e_table_model_value_at (
 276                 table_subset->priv->source_model,
 277                 col, MAP_ROW (table_subset, row));
 278 }
 279
 280 static void
 281 table_subset_set_value_at (ETableModel *table_model,
 282                            gint col,
 283                            gint row,
 284                            gconstpointer val)
 285 {
 286         ETableSubset *table_subset = (ETableSubset *) table_model;
 287
 288         g_return_if_fail (VALID_ROW (table_subset, row));
 289
 290         table_subset->priv->last_access = row;
 291
 292         e_table_model_set_value_at (
 293                 table_subset->priv->source_model,
 294                 col, MAP_ROW (table_subset, row), val);
 295 }
 296
 297 static gboolean
 298 table_subset_is_cell_editable (ETableModel *table_model,
 299                                gint col,
 300                                gint row)
 301 {
 302         ETableSubset *table_subset = (ETableSubset *) table_model;
 303
 304         g_return_val_if_fail (VALID_ROW (table_subset, row), FALSE);
 305
 306         return e_table_model_is_cell_editable (
 307                 table_subset->priv->source_model,
 308                 col, MAP_ROW (table_subset, row));
 309 }
 310
 311 static gboolean
 312 table_subset_has_save_id (ETableModel *table_model)
 313 {
 314         return TRUE;
 315 }
 316
 317 static gchar *
 318 table_subset_get_save_id (ETableModel *table_model,
 319                           gint row)
 320 {
 321         ETableSubset *table_subset = (ETableSubset *) table_model;
 322
 323         g_return_val_if_fail (VALID_ROW (table_subset, row), NULL);
 324
 325         if (e_table_model_has_save_id (table_subset->priv->source_model))
 326                 return e_table_model_get_save_id (
 327                         table_subset->priv->source_model,
 328                         MAP_ROW (table_subset, row));
 329         else
 330                 return g_strdup_printf ("%d", MAP_ROW (table_subset, row));
 331 }
 332
 333 static void
 334 table_subset_append_row (ETableModel *table_model,
 335                          ETableModel *source,
 336                          gint row)
 337 {
 338         ETableSubset *table_subset = (ETableSubset *) table_model;
 339
 340         e_table_model_append_row (
 341                 table_subset->priv->source_model, source, row);
 342 }
 343
 344 static gpointer
 345 table_subset_duplicate_value (ETableModel *table_model,
 346                               gint col,
 347                               gconstpointer value)
 348 {
 349         ETableSubset *table_subset = (ETableSubset *) table_model;
 350
 351         return e_table_model_duplicate_value (
 352                 table_subset->priv->source_model, col, value);
 353 }
 354
 355 static void
 356 table_subset_free_value (ETableModel *table_model,
 357                          gint col,
 358                          gpointer value)
 359 {
 360         ETableSubset *table_subset = (ETableSubset *) table_model;
 361
 362         e_table_model_free_value (
 363                 table_subset->priv->source_model, col, value);
 364 }
 365
 366 static gpointer
 367 table_subset_initialize_value (ETableModel *table_model,
 368                                gint col)
 369 {
 370         ETableSubset *table_subset = (ETableSubset *) table_model;
 371
 372         return e_table_model_initialize_value (
 373                 table_subset->priv->source_model, col);
 374 }
 375
 376 static gboolean
 377 table_subset_value_is_empty (ETableModel *table_model,
 378                              gint col,
 379                              gconstpointer value)
 380 {
 381         ETableSubset *table_subset = (ETableSubset *) table_model;
 382
 383         return e_table_model_value_is_empty (
 384                 table_subset->priv->source_model, col, value);
 385 }
 386
 387 static gchar *
 388 table_subset_value_to_string (ETableModel *table_model,
 389                               gint col,
 390                               gconstpointer value)
 391 {
 392         ETableSubset *table_subset = (ETableSubset *) table_model;
 393
 394         return e_table_model_value_to_string (
 395                 table_subset->priv->source_model, col, value);
 396 }
 397
 398 static void
 399 e_table_subset_class_init (ETableSubsetClass *class)
 400 {
 401         GObjectClass *object_class;
 402
 403         g_type_class_add_private (class, sizeof (ETableSubsetPrivate));
 404
 405         object_class = G_OBJECT_CLASS (class);
 406         object_class->dispose = table_subset_dispose;
 407         object_class->finalize = table_subset_finalize;
 408
 409         class->proxy_model_pre_change = table_subset_proxy_model_pre_change_real;
 410         class->proxy_model_no_change = table_subset_proxy_model_no_change_real;
 411         class->proxy_model_changed = table_subset_proxy_model_changed_real;
 412         class->proxy_model_row_changed = table_subset_proxy_model_row_changed_real;
 413         class->proxy_model_cell_changed = table_subset_proxy_model_cell_changed_real;
 414         class->proxy_model_rows_inserted = table_subset_proxy_model_rows_inserted_real;
 415         class->proxy_model_rows_deleted = table_subset_proxy_model_rows_deleted_real;
 416 }
 417
 418 static void
 419 e_table_subset_table_model_init (ETableModelInterface *iface)
 420 {
 421         iface->column_count = table_subset_column_count;
 422         iface->row_count = table_subset_row_count;
 423         iface->append_row = table_subset_append_row;
 424
 425         iface->value_at = table_subset_value_at;
 426         iface->set_value_at = table_subset_set_value_at;
 427         iface->is_cell_editable = table_subset_is_cell_editable;
 428
 429         iface->has_save_id = table_subset_has_save_id;
 430         iface->get_save_id = table_subset_get_save_id;
 431
 432         iface->duplicate_value = table_subset_duplicate_value;
 433         iface->free_value = table_subset_free_value;
 434         iface->initialize_value = table_subset_initialize_value;
 435         iface->value_is_empty = table_subset_value_is_empty;
 436         iface->value_to_string = table_subset_value_to_string;
 437 }
 438
 439 static void
 440 e_table_subset_init (ETableSubset *table_subset)
 441 {
 442         table_subset->priv = E_TABLE_SUBSET_GET_PRIVATE (table_subset);
 443 }
 444
 445 static void
 446 table_subset_proxy_model_pre_change (ETableModel *source_model,
 447                                      ETableSubset *table_subset)
 448 {
 449         ETableSubsetClass *class;
 450
 451         class = E_TABLE_SUBSET_GET_CLASS (table_subset);
 452
 453         if (class->proxy_model_pre_change != NULL)
 454                 class->proxy_model_pre_change (table_subset, source_model);
 455 }
 456
 457 static void
 458 table_subset_proxy_model_no_change (ETableModel *source_model,
 459                                     ETableSubset *table_subset)
 460 {
 461         ETableSubsetClass *class;
 462
 463         class = E_TABLE_SUBSET_GET_CLASS (table_subset);
 464
 465         if (class->proxy_model_no_change != NULL)
 466                 class->proxy_model_no_change (table_subset, source_model);
 467 }
 468
 469 static void
 470 table_subset_proxy_model_changed (ETableModel *source_model,
 471                                   ETableSubset *table_subset)
 472 {
 473         ETableSubsetClass *class;
 474
 475         class = E_TABLE_SUBSET_GET_CLASS (table_subset);
 476
 477         if (class->proxy_model_changed != NULL)
 478                 class->proxy_model_changed (table_subset, source_model);
 479 }
 480
 481 static void
 482 table_subset_proxy_model_row_changed (ETableModel *source_model,
 483                                       gint row,
 484                                       ETableSubset *table_subset)
 485 {
 486         ETableSubsetClass *class;
 487
 488         class = E_TABLE_SUBSET_GET_CLASS (table_subset);
 489
 490         if (class->proxy_model_row_changed != NULL)
 491                 class->proxy_model_row_changed (
 492                         table_subset, source_model, row);
 493 }
 494
 495 static void
 496 table_subset_proxy_model_cell_changed (ETableModel *source_model,
 497                                        gint col,
 498                                        gint row,
 499                                        ETableSubset *table_subset)
 500 {
 501         ETableSubsetClass *class;
 502
 503         class = E_TABLE_SUBSET_GET_CLASS (table_subset);
 504
 505         if (class->proxy_model_cell_changed != NULL)
 506                 class->proxy_model_cell_changed (
 507                         table_subset, source_model, col, row);
 508 }
 509
 510 static void
 511 table_subset_proxy_model_rows_inserted (ETableModel *source_model,
 512                                         gint row,
 513                                         gint col,
 514                                         ETableSubset *table_subset)
 515 {
 516         ETableSubsetClass *class;
 517
 518         class = E_TABLE_SUBSET_GET_CLASS (table_subset);
 519
 520         if (class->proxy_model_rows_inserted != NULL)
 521                 class->proxy_model_rows_inserted (
 522                         table_subset, source_model, row, col);
 523 }
 524
 525 static void
 526 table_subset_proxy_model_rows_deleted (ETableModel *source_model,
 527                                        gint row,
 528                                        gint col,
 529                                        ETableSubset *table_subset)
 530 {
 531         ETableSubsetClass *class;
 532
 533         class = E_TABLE_SUBSET_GET_CLASS (table_subset);
 534
 535         if (class->proxy_model_rows_deleted != NULL)
 536                 class->proxy_model_rows_deleted (
 537                         table_subset, source_model, row, col);
 538 }
 539
 540 ETableModel *
 541 e_table_subset_construct (ETableSubset *table_subset,
 542                           ETableModel *source_model,
 543                           gint nvals)
 544 {
 545         gulong handler_id;
 546         guint *buffer = NULL;
 547         gint i;
 548
 549         if (nvals > 0)
 550                 buffer = (guint *) g_malloc (sizeof (guint) * nvals);
 551         table_subset->map_table = (gint *) buffer;
 552         table_subset->n_map = nvals;
 553         table_subset->priv->source_model = g_object_ref (source_model);
 554
 555         /* Init */
 556         for (i = 0; i < nvals; i++)
 557                 table_subset->map_table[i] = i;
 558
 559         handler_id = g_signal_connect (
 560                 source_model, "model_pre_change",
 561                 G_CALLBACK (table_subset_proxy_model_pre_change),
 562                 table_subset);
 563         table_subset->priv->table_model_pre_change_handler_id = handler_id;
 564
 565         handler_id = g_signal_connect (
 566                 source_model, "model_no_change",
 567                 G_CALLBACK (table_subset_proxy_model_no_change),
 568                 table_subset);
 569         table_subset->priv->table_model_no_change_handler_id = handler_id;
 570
 571         handler_id = g_signal_connect (
 572                 source_model, "model_changed",
 573                 G_CALLBACK (table_subset_proxy_model_changed),
 574                 table_subset);
 575         table_subset->priv->table_model_changed_handler_id = handler_id;
 576
 577         handler_id = g_signal_connect (
 578                 source_model, "model_row_changed",
 579                 G_CALLBACK (table_subset_proxy_model_row_changed),
 580                 table_subset);
 581         table_subset->priv->table_model_row_changed_handler_id = handler_id;
 582
 583         handler_id = g_signal_connect (
 584                 source_model, "model_cell_changed",
 585                 G_CALLBACK (table_subset_proxy_model_cell_changed),
 586                 table_subset);
 587         table_subset->priv->table_model_cell_changed_handler_id = handler_id;
 588
 589         handler_id = g_signal_connect (
 590                 source_model, "model_rows_inserted",
 591                 G_CALLBACK (table_subset_proxy_model_rows_inserted),
 592                 table_subset);
 593         table_subset->priv->table_model_rows_inserted_handler_id = handler_id;
 594
 595         handler_id = g_signal_connect (
 596                 source_model, "model_rows_deleted",
 597                 G_CALLBACK (table_subset_proxy_model_rows_deleted),
 598                 table_subset);
 599         table_subset->priv->table_model_rows_deleted_handler_id = handler_id;
 600
 601         return E_TABLE_MODEL (table_subset);
 602 }
 603
 604 ETableModel *
 605 e_table_subset_new (ETableModel *source_model,
 606                     const gint nvals)
 607 {
 608         ETableSubset *table_subset;
 609
 610         g_return_val_if_fail (E_IS_TABLE_MODEL (source_model), NULL);
 611
 612         table_subset = g_object_new (E_TYPE_TABLE_SUBSET, NULL);
 613
 614         if (e_table_subset_construct (table_subset, source_model, nvals) == NULL) {
 615                 g_object_unref (table_subset);
 616                 return NULL;
 617         }
 618
 619         return (ETableModel *) table_subset;
 620 }
 621
 622 ETableModel *
 623 e_table_subset_get_source_model (ETableSubset *table_subset)
 624 {
 625         g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), NULL);
 626
 627         return table_subset->priv->source_model;
 628 }
 629
 630 gint
 631 e_table_subset_model_to_view_row (ETableSubset *table_subset,
 632                                   gint model_row)
 633 {
 634         gint i;
 635
 636         g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), -1);
 637
 638         for (i = 0; i < table_subset->n_map; i++) {
 639                 if (table_subset->map_table[i] == model_row)
 640                         return i;
 641         }
 642         return -1;
 643 }
 644
 645 gint
 646 e_table_subset_view_to_model_row (ETableSubset *table_subset,
 647                                   gint view_row)
 648 {
 649         g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), -1);
 650
 651         if (view_row >= 0 && view_row < table_subset->n_map)
 652                 return table_subset->map_table[view_row];
 653         else
 654                 return -1;
 655 }
 656
 657 ETableModel *
 658 e_table_subset_get_toplevel (ETableSubset *table_subset)
 659 {
 660         g_return_val_if_fail (E_IS_TABLE_SUBSET (table_subset), NULL);
 661
 662         if (E_IS_TABLE_SUBSET (table_subset->priv->source_model))
 663                 return e_table_subset_get_toplevel (
 664                         E_TABLE_SUBSET (table_subset->priv->source_model));
 665         else
 666                 return table_subset->priv->source_model;
 667 }
 668
 669 void
 670 e_table_subset_print_debugging (ETableSubset *table_subset)
 671 {
 672         gint i;
 673
 674         g_return_if_fail (E_IS_TABLE_SUBSET (table_subset));
 675
 676         for (i = 0; i < table_subset->n_map; i++) {
 677                 g_print ("%8d\n", table_subset->map_table[i]);
 678         }
 679 }