src/ephy-completion-model.c

   1 /*
   2  * -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
   3  */
   4 /*
   5  *  Copyright © 2002 Jorn Baayen <jorn@nl.linux.org>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  *  $Id: ephy-completion-model.c 7020 2007-05-01 17:13:10Z xan $
  22  */
  23
  24 #include "config.h"
  25
  26 #include "ephy-completion-model.h"
  27 #include "ephy-favicon-cache.h"
  28 #include "ephy-node.h"
  29 #include "ephy-shell.h"
  30 #include "ephy-history.h"
  31
  32 //#include <stdlib.h>
  33
  34 static void ephy_completion_model_class_init (EphyCompletionModelClass *
  35                                               klass);
  36 static void ephy_completion_model_init (EphyCompletionModel * model);
  37 static void ephy_completion_model_tree_model_init (GtkTreeModelIface * iface);
  38 static void ephy_completion_model_finalize (GObject *object);
  39
  40 #define EPHY_COMPLETION_MODEL_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_COMPLETION_MODEL, EphyCompletionModelPrivate))
  41
  42 struct _EphyCompletionModelPrivate
  43 {
  44         EphyHistory *eh;
  45         GArray *history;
  46         GArray *bookmarks;
  47         int stamp;
  48 };
  49
  50 enum
  51 {
  52         HISTORY_GROUP,
  53         BOOKMARKS_GROUP
  54 };
  55
  56 typedef struct
  57 {
  58         guint64 id;
  59 } HistoryItem;
  60
  61 static GObjectClass *parent_class = NULL;
  62
  63 GType
  64 ephy_completion_model_get_type (void)
  65 {
  66         static GType type = 0;
  67
  68         if (G_UNLIKELY (type == 0))
  69         {
  70                 const GTypeInfo our_info = {
  71                         sizeof (EphyCompletionModelClass),
  72                         NULL,
  73                         NULL,
  74                         (GClassInitFunc) ephy_completion_model_class_init,
  75                         NULL,
  76                         NULL,
  77                         sizeof (EphyCompletionModel),
  78                         0,
  79                         (GInstanceInitFunc) ephy_completion_model_init
  80                 };
  81
  82                 const GInterfaceInfo tree_model_info = {
  83                         (GInterfaceInitFunc)
  84                                 ephy_completion_model_tree_model_init,
  85                         NULL,
  86                         NULL
  87                 };
  88
  89                 type = g_type_register_static (G_TYPE_OBJECT,
  90                                                "EphyCompletionModel",
  91                                                &our_info, 0);
  92
  93                 g_type_add_interface_static (type,
  94                                              GTK_TYPE_TREE_MODEL,
  95                                              &tree_model_info);
  96         }
  97
  98         return type;
  99 }
 100
 101 static void
 102 ephy_completion_model_class_init (EphyCompletionModelClass * klass)
 103 {
 104         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 105
 106         object_class->finalize = ephy_completion_model_finalize;
 107
 108         parent_class = g_type_class_peek_parent (klass);
 109
 110         g_type_class_add_private (object_class,
 111                                   sizeof (EphyCompletionModelPrivate));
 112 }
 113
 114 static void
 115 ephy_completion_model_finalize (GObject *object)
 116 {
 117         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (object);
 118
 119         if (model->priv->history)
 120                 g_array_free (model->priv->history, TRUE);
 121
 122         if (model->priv->bookmarks)
 123                 g_array_free (model->priv->bookmarks, TRUE);
 124
 125         G_OBJECT_CLASS (parent_class)->finalize (object);
 126 }
 127
 128 static int
 129 page_ids_bsearch_compare (const void *key, const void *memberp)
 130 {
 131         return (*(guint64 *) key) - (*(guint64 *) memberp);
 132 }
 133
 134 static int
 135 get_page_index (GArray * pages, guint64 id)
 136 {
 137         int index;
 138         char *ptr;
 139
 140         ptr = bsearch (&id, pages->data, pages->len, sizeof (guint64),
 141                        page_ids_bsearch_compare);
 142         if (ptr == NULL)
 143                 return -1;
 144
 145         index = (ptr - pages->data) / sizeof (guint64);
 146         if (index >= pages->len)
 147                 return -1;
 148
 149         return index;
 150 }
 151
 152 static GtkTreePath *
 153 get_path_real (EphyCompletionModel * model, GArray * pages, guint64 id)
 154 {
 155         GtkTreePath *retval;
 156         int index;
 157
 158         index = get_page_index (pages, id);
 159
 160         if (index == -1)
 161                 return NULL;
 162
 163         if (pages == model->priv->bookmarks)
 164         {
 165                 index += model->priv->history->len;
 166         }
 167
 168         retval = gtk_tree_path_new ();
 169         gtk_tree_path_append_index (retval, index);
 170
 171         return retval;
 172 }
 173
 174 static void
 175 iter_from_page (EphyCompletionModel * model,
 176                 GArray * pages, guint64 id, GtkTreeIter * iter)
 177 {
 178         /* XXX: we need to free this some place? */
 179         HistoryItem *item = g_new (HistoryItem, 1);
 180         item->id = id;
 181
 182         iter->stamp = model->priv->stamp;
 183         iter->user_data = item;
 184         iter->user_data2 = pages;
 185         iter->user_data3 = NULL;
 186 }
 187
 188 static GArray *
 189 get_pages (EphyCompletionModel * model, int *index)
 190 {
 191         if (*index >= model->priv->history->len)
 192         {
 193                 *index = *index - model->priv->history->len;
 194
 195                 if (*index < model->priv->bookmarks->len)
 196                 {
 197                         return model->priv->bookmarks;
 198                 }
 199                 else
 200                 {
 201                         return NULL;
 202                 }
 203         }
 204         else
 205         {
 206                 return model->priv->history;
 207         }
 208 }
 209
 210 static void
 211 history_page_added_cb (EphyHistory * history,
 212                        guint64 id, EphyCompletionModel * model)
 213 {
 214         GtkTreePath *path;
 215         GtkTreeIter iter;
 216
 217         iter_from_page (model, model->priv->history, id, &iter);
 218         g_array_append_val (model->priv->history, id);
 219
 220         path = gtk_tree_path_new ();
 221         gtk_tree_path_append_index (path, model->priv->history->len - 1);
 222         gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
 223         gtk_tree_path_free (path);
 224 }
 225
 226 static void
 227 history_page_removed_cb (EphyHistory * history,
 228                          guint64 id, EphyCompletionModel * model)
 229 {
 230         GtkTreePath *path;
 231         guint index;
 232
 233         index = get_page_index (model->priv->history, id);
 234         g_array_remove_index (model->priv->history, index);
 235
 236         path = gtk_tree_path_new ();
 237         gtk_tree_path_append_index (path, index);
 238         gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
 239         gtk_tree_path_free (path);
 240 }
 241
 242 static void
 243 history_page_updated_cb (EphyHistory * history,
 244                          guint64 id, EphyCompletionModel * model)
 245 {
 246         GtkTreePath *path;
 247         GtkTreeIter iter;
 248
 249         iter_from_page (model, model->priv->history, id, &iter);
 250
 251         path = get_path_real (model, model->priv->history, id);
 252         gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
 253         gtk_tree_path_free (path);
 254 }
 255
 256 static void
 257 connect_signals (EphyCompletionModel * model, EphyHistory * history)
 258 {
 259         g_signal_connect (history, "page-added",
 260                           G_CALLBACK (history_page_added_cb),
 261                           G_OBJECT (model));
 262         g_signal_connect (history, "page-removed",
 263                           G_CALLBACK (history_page_removed_cb),
 264                           G_OBJECT (model));
 265         g_signal_connect (history, "page-updated",
 266                           G_CALLBACK (history_page_updated_cb),
 267                           G_OBJECT (model));
 268 }
 269
 270 static void
 271 ephy_completion_model_init (EphyCompletionModel * model)
 272 {
 273         EphyHistory *history;
 274
 275         model->priv = EPHY_COMPLETION_MODEL_GET_PRIVATE (model);
 276         model->priv->stamp = g_random_int ();
 277
 278         history = EPHY_HISTORY (ephy_embed_shell_get_global_history
 279                                 (embed_shell));
 280         model->priv->history = ephy_history_get_page_ids (history);
 281         model->priv->eh = history;
 282         connect_signals (model, model->priv->eh);
 283
 284         /*
 285          * XXX: Bookmarks
 286          */
 287         model->priv->bookmarks = g_array_new (FALSE, FALSE, sizeof (guint64));
 288 }
 289
 290
 291
 292 EphyCompletionModel *
 293 ephy_completion_model_new (void)
 294 {
 295         EphyCompletionModel *model;
 296
 297         model = EPHY_COMPLETION_MODEL (g_object_new
 298                                        (EPHY_TYPE_COMPLETION_MODEL, NULL));
 299
 300         g_return_val_if_fail (model->priv != NULL, NULL);
 301
 302         return model;
 303 }
 304
 305 static int
 306 ephy_completion_model_get_n_columns (GtkTreeModel * tree_model)
 307 {
 308         return N_COL;
 309 }
 310
 311 static GType
 312 ephy_completion_model_get_column_type (GtkTreeModel * tree_model, int index)
 313 {
 314         GType type = 0;
 315
 316         switch (index)
 317         {
 318         case EPHY_COMPLETION_TEXT_COL:
 319         case EPHY_COMPLETION_ACTION_COL:
 320         case EPHY_COMPLETION_KEYWORDS_COL:
 321         case EPHY_COMPLETION_EXTRA_COL:
 322                 type = G_TYPE_STRING;
 323                 break;
 324         case EPHY_COMPLETION_FAVICON_COL:
 325                 type = GDK_TYPE_PIXBUF;
 326                 break;
 327         case EPHY_COMPLETION_RELEVANCE_COL:
 328                 type = G_TYPE_INT;
 329                 break;
 330         }
 331
 332         return type;
 333 }
 334
 335 static void
 336 init_text_col (GValue * value, EphyHistoryPageNode * page, int group)
 337 {
 338         const char *text;
 339
 340         switch (group)
 341         {
 342         case BOOKMARKS_GROUP:
 343                 text = "";
 344                 break;
 345         case HISTORY_GROUP:
 346                 g_object_get (G_OBJECT (page), "url", &text, NULL);
 347                 break;
 348         default:
 349                 text = "";
 350         }
 351
 352         g_value_set_string (value, text);
 353 }
 354
 355 static void
 356 init_action_col (GValue * value, EphyHistoryPageNode * page, int group)
 357 {
 358         const char *text;
 359
 360         switch (group)
 361         {
 362         case BOOKMARKS_GROUP:
 363                 text = "";
 364                 break;
 365         case HISTORY_GROUP:
 366                 g_object_get (G_OBJECT (page), "url", &text, NULL);
 367                 break;
 368         default:
 369                 text = "";
 370         }
 371
 372         g_value_set_string (value, text);
 373 }
 374
 375 static void
 376 init_keywords_col (GValue * value, EphyHistoryPageNode * node, int group)
 377 {
 378         const char *text = NULL;
 379
 380         switch (group)
 381         {
 382         case BOOKMARKS_GROUP:
 383                 break;
 384         }
 385
 386         if (text == NULL)
 387         {
 388                 text = "";
 389         }
 390
 391         g_value_set_string (value, text);
 392 }
 393
 394 static void
 395 init_favicon_col (GValue * value, EphyHistoryPageNode * page, int group)
 396 {
 397         const char *icon_location;
 398         EphyFaviconCache *cache;
 399         GdkPixbuf *pixbuf = NULL;
 400
 401         cache = EPHY_FAVICON_CACHE
 402                 (ephy_embed_shell_get_favicon_cache
 403                  (EPHY_EMBED_SHELL (ephy_shell)));
 404
 405         switch (group)
 406         {
 407         case BOOKMARKS_GROUP:
 408                 break;
 409         case HISTORY_GROUP:
 410                 g_object_get (G_OBJECT (page), "favicon-url",
 411                               &icon_location, NULL);
 412                 break;
 413         default:
 414                 icon_location = NULL;
 415         }
 416
 417         if (icon_location)
 418         {
 419                 pixbuf = ephy_favicon_cache_get (cache, icon_location);
 420         }
 421
 422         g_value_take_object (value, pixbuf);
 423 }
 424
 425 static gboolean
 426 is_base_address (const char *address)
 427 {
 428         int slashes = 0;
 429
 430         if (address == NULL)
 431                 return FALSE;
 432
 433         while (*address != '\0')
 434         {
 435                 if (*address == '/')
 436                         slashes++;
 437
 438                 address++;
 439
 440                 /*
 441                  * Base uris has 3 slashes like http://www.gnome.org/
 442                  */
 443                 if (slashes == 3)
 444                 {
 445                         return (*address == '\0');
 446                 }
 447         }
 448
 449         return FALSE;
 450 }
 451
 452 static void
 453 init_relevance_col (GValue * value, EphyHistoryPageNode * page, int group)
 454 {
 455         int relevance = 0;
 456
 457         /*
 458          * We have three ordered groups: history's base addresses,
 459          * bookmarks, deep history addresses
 460          */
 461
 462         if (group == BOOKMARKS_GROUP)
 463         {
 464                 relevance = 1 << 5;
 465         }
 466         else if (group == HISTORY_GROUP)
 467         {
 468                 char *url;
 469                 guint visits;
 470
 471                 g_object_get (G_OBJECT (page), "url", &url, "visit-count",
 472                               &visits, NULL);
 473
 474                 visits = MIN (visits, (1 << 5) - 1);
 475
 476                 if (is_base_address (url))
 477                 {
 478                         relevance = visits << 10;
 479                 }
 480                 else
 481                 {
 482                         relevance = visits;
 483                 }
 484                 //g_print("url: %s visits: %u rel: %d\n", url, visits, relevance);
 485         }
 486         g_value_set_int (value, relevance);
 487 }
 488
 489 static void
 490 init_url_col (GValue * value, EphyHistoryPageNode * page, int group)
 491 {
 492         const char *url = NULL;
 493
 494         if (group == BOOKMARKS_GROUP)
 495         {
 496                 url = "";
 497         }
 498         else if (group == HISTORY_GROUP)
 499         {
 500                 g_object_get (G_OBJECT (page), "url", &url, NULL);
 501         }
 502         else
 503         {
 504                 url = "";
 505         }
 506         g_value_set_string (value, url);
 507 }
 508
 509 static void
 510 ephy_completion_model_get_value (GtkTreeModel * tree_model,
 511                                  GtkTreeIter * iter,
 512                                  int column, GValue * value)
 513 {
 514         int group;
 515         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (tree_model);
 516         EphyHistoryPageNode *page;
 517         guint64 id;
 518
 519         g_return_if_fail (EPHY_IS_COMPLETION_MODEL (tree_model));
 520         g_return_if_fail (iter != NULL);
 521         g_return_if_fail (iter->stamp == model->priv->stamp);
 522
 523         id = ((HistoryItem *) iter->user_data)->id;
 524         group = (iter->user_data2 == model->priv->history) ?
 525                 HISTORY_GROUP : BOOKMARKS_GROUP;
 526
 527         /* XXX: use a better approach to cache the page info */
 528         page = iter->user_data3;
 529         if (page == NULL)
 530         {
 531                 /* g_debug ("querying page info"); */
 532                 page = ephy_history_get_page_by_id (model->priv->eh, id);
 533                 iter->user_data3 = page;
 534         }
 535         else
 536         {
 537                 /* g_debug ("using cached page info"); */
 538         }
 539
 540         switch (column)
 541         {
 542         case EPHY_COMPLETION_EXTRA_COL:
 543                 g_value_init (value, G_TYPE_STRING);
 544                 /*
 545                  * We set an additional text for the item title only for
 546                  * history, since we assume that people know the url of
 547                  * their bookmarks
 548                  */
 549                 if (group == HISTORY_GROUP)
 550                 {
 551                         char *title;
 552                         g_object_get (G_OBJECT (page), "title", &title, NULL);
 553                         g_value_set_string (value, title);
 554                 }
 555                 break;
 556         case EPHY_COMPLETION_TEXT_COL:
 557                 g_value_init (value, G_TYPE_STRING);
 558                 init_text_col (value, page, group);
 559                 break;
 560         case EPHY_COMPLETION_FAVICON_COL:
 561                 g_value_init (value, GDK_TYPE_PIXBUF);
 562                 init_favicon_col (value, page, group);
 563                 break;
 564         case EPHY_COMPLETION_ACTION_COL:
 565                 g_value_init (value, G_TYPE_STRING);
 566                 init_action_col (value, page, group);
 567                 break;
 568         case EPHY_COMPLETION_KEYWORDS_COL:
 569                 g_value_init (value, G_TYPE_STRING);
 570                 init_keywords_col (value, page, group);
 571                 break;
 572         case EPHY_COMPLETION_RELEVANCE_COL:
 573                 g_value_init (value, G_TYPE_INT);
 574                 init_relevance_col (value, page, group);
 575                 break;
 576         case EPHY_COMPLETION_URL_COL:
 577                 g_value_init (value, G_TYPE_STRING);
 578                 init_url_col (value, page, group);
 579                 break;
 580         }
 581 }
 582
 583 static GtkTreeModelFlags
 584 ephy_completion_model_get_flags (GtkTreeModel * tree_model)
 585 {
 586         return GTK_TREE_MODEL_ITERS_PERSIST | GTK_TREE_MODEL_LIST_ONLY;
 587 }
 588
 589 static gboolean
 590 ephy_completion_model_get_iter (GtkTreeModel * tree_model,
 591                                 GtkTreeIter * iter, GtkTreePath * path)
 592 {
 593         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (tree_model);
 594         GArray *pages;
 595         int index;
 596         guint64 id;
 597
 598         g_return_val_if_fail (EPHY_IS_COMPLETION_MODEL (model), FALSE);
 599         g_return_val_if_fail (gtk_tree_path_get_depth (path) == 1, FALSE);
 600
 601         index = gtk_tree_path_get_indices (path)[0];
 602
 603         pages = get_pages (model, &index);
 604         if (pages == NULL)
 605                 return FALSE;
 606
 607         id = g_array_index (pages, guint64, index);
 608         iter_from_page (model, pages, id, iter);
 609
 610         return TRUE;
 611 }
 612
 613 static GtkTreePath *
 614 ephy_completion_model_get_path (GtkTreeModel * tree_model, GtkTreeIter * iter)
 615 {
 616         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (tree_model);
 617         guint64 id;
 618
 619         g_return_val_if_fail (iter != NULL, NULL);
 620         g_return_val_if_fail (iter->user_data != NULL, NULL);
 621         g_return_val_if_fail (iter->user_data2 != NULL, NULL);
 622         g_return_val_if_fail (iter->stamp == model->priv->stamp, NULL);
 623
 624         id = ((HistoryItem *) iter->user_data)->id;
 625         return get_path_real (model, iter->user_data2, id);
 626 }
 627
 628 static gboolean
 629 ephy_completion_model_iter_next (GtkTreeModel * tree_model,
 630                                  GtkTreeIter * iter)
 631 {
 632         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (tree_model);
 633         GArray *pages;
 634         guint64 id;
 635         gint index, next;
 636
 637         g_return_val_if_fail (iter != NULL, FALSE);
 638         g_return_val_if_fail (iter->user_data != NULL, FALSE);
 639         g_return_val_if_fail (iter->user_data2 != NULL, FALSE);
 640         g_return_val_if_fail (iter->stamp == model->priv->stamp, FALSE);
 641
 642         id = ((HistoryItem *) iter->user_data)->id;
 643         pages = (GArray *) iter->user_data2;
 644
 645         index = get_page_index (pages, id);
 646         if (index == -1)
 647                 return FALSE;
 648
 649         next = index + 1;
 650         if (next >= pages->len)
 651         {
 652                 if (pages == model->priv->history
 653                     && model->priv->bookmarks->len > 0)
 654                 {
 655                         pages = model->priv->bookmarks;
 656                         next = 0;
 657                 }
 658                 else
 659                 {
 660                         return FALSE;
 661                 }
 662         }
 663
 664         id = g_array_index (pages, guint64, next);
 665
 666         iter_from_page (model, pages, id, iter);
 667
 668         return TRUE;
 669 }
 670
 671 static gboolean
 672 ephy_completion_model_iter_children (GtkTreeModel * tree_model,
 673                                      GtkTreeIter * iter, GtkTreeIter * parent)
 674 {
 675         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (tree_model);
 676         GArray *pages;
 677         guint64 id;
 678
 679         if (parent != NULL)
 680         {
 681                 return FALSE;
 682         }
 683
 684         if (model->priv->history->len > 0)
 685         {
 686                 pages = model->priv->history;
 687                 id = g_array_index (pages, guint64, 0);
 688         }
 689         else if (model->priv->bookmarks->len > 0)
 690         {
 691                 pages = model->priv->bookmarks;
 692                 id = g_array_index (pages, guint64, 0);
 693         }
 694         else
 695         {
 696                 return FALSE;
 697         }
 698
 699         iter_from_page (model, pages, id, iter);
 700
 701         return TRUE;
 702 }
 703
 704 static gboolean
 705 ephy_completion_model_iter_has_child (GtkTreeModel * tree_model,
 706                                       GtkTreeIter * iter)
 707 {
 708         return FALSE;
 709 }
 710
 711 static int
 712 ephy_completion_model_iter_n_children (GtkTreeModel * tree_model,
 713                                        GtkTreeIter * iter)
 714 {
 715         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (tree_model);
 716
 717         g_return_val_if_fail (EPHY_IS_COMPLETION_MODEL (tree_model), -1);
 718
 719         if (iter == NULL)
 720         {
 721                 return model->priv->history->len +
 722                         model->priv->bookmarks->len;
 723         }
 724
 725         g_return_val_if_fail (model->priv->stamp == iter->stamp, -1);
 726
 727         return 0;
 728 }
 729
 730 static gboolean
 731 ephy_completion_model_iter_nth_child (GtkTreeModel * tree_model,
 732                                       GtkTreeIter * iter,
 733                                       GtkTreeIter * parent, int n)
 734 {
 735         EphyCompletionModel *model = EPHY_COMPLETION_MODEL (tree_model);
 736         GArray *pages;
 737         guint64 id;
 738
 739         g_return_val_if_fail (EPHY_IS_COMPLETION_MODEL (tree_model), FALSE);
 740
 741         if (parent != NULL)
 742         {
 743                 return FALSE;
 744         }
 745
 746         pages = get_pages (model, &n);
 747         if (pages == NULL)
 748                 return FALSE;
 749
 750         id = g_array_index (pages, guint64, n);
 751         iter_from_page (model, pages, id, iter);
 752
 753         return TRUE;
 754 }
 755
 756 static gboolean
 757 ephy_completion_model_iter_parent (GtkTreeModel * tree_model,
 758                                    GtkTreeIter * iter, GtkTreeIter * child)
 759 {
 760         return FALSE;
 761 }
 762
 763 static void
 764 ephy_completion_model_tree_model_init (GtkTreeModelIface * iface)
 765 {
 766         iface->get_flags = ephy_completion_model_get_flags;
 767         iface->get_iter = ephy_completion_model_get_iter;
 768         iface->get_path = ephy_completion_model_get_path;
 769         iface->iter_next = ephy_completion_model_iter_next;
 770         iface->iter_children = ephy_completion_model_iter_children;
 771         iface->iter_has_child = ephy_completion_model_iter_has_child;
 772         iface->iter_n_children = ephy_completion_model_iter_n_children;
 773         iface->iter_nth_child = ephy_completion_model_iter_nth_child;
 774         iface->iter_parent = ephy_completion_model_iter_parent;
 775         iface->get_n_columns = ephy_completion_model_get_n_columns;
 776         iface->get_column_type = ephy_completion_model_get_column_type;
 777         iface->get_value = ephy_completion_model_get_value;
 778 }