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