shell/ev-page-action-widget.c

   1 /*
   2  *  Copyright (C) 2003, 2004 Marco Pesenti Gritti
   3  *  Copyright (C) 2003, 2004 Christian Persch
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This program 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
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  *
  19  */
  20
  21 #include "config.h"
  22
  23 #include "ev-page-action.h"
  24 #include "ev-page-cache.h"
  25 #include "ev-window.h"
  26 #include "ev-document-links.h"
  27 #include "ev-page-action-widget.h"
  28 #include "ev-marshal.h"
  29
  30 #include <glib/gi18n.h>
  31 #include <gtk/gtkentry.h>
  32 #include <gtk/gtktoolitem.h>
  33 #include <gtk/gtklabel.h>
  34 #include <gtk/gtkhbox.h>
  35 #include <string.h>
  36
  37 /* Widget we pass back */
  38 static void  ev_page_action_widget_init       (EvPageActionWidget      *action_widget);
  39 static void  ev_page_action_widget_class_init (EvPageActionWidgetClass *action_widget);
  40
  41 enum
  42 {
  43         WIDGET_ACTIVATE_LINK,
  44         WIDGET_N_SIGNALS
  45 };
  46
  47 static guint widget_signals[WIDGET_N_SIGNALS] = {0, };
  48
  49 G_DEFINE_TYPE (EvPageActionWidget, ev_page_action_widget, GTK_TYPE_TOOL_ITEM)
  50
  51 static void
  52 ev_page_action_widget_init (EvPageActionWidget *action_widget)
  53 {
  54         return;
  55 }
  56
  57 void
  58 ev_page_action_widget_set_page_cache (EvPageActionWidget *action_widget,
  59                                       EvPageCache        *page_cache)
  60 {
  61         if (action_widget->page_cache != NULL) {
  62                 g_object_remove_weak_pointer (G_OBJECT (action_widget->page_cache),
  63                                               (gpointer)&action_widget->page_cache);
  64                 action_widget->page_cache = NULL;
  65         }
  66
  67         if (page_cache != NULL) {
  68                 action_widget->page_cache = page_cache;
  69                 g_object_add_weak_pointer (G_OBJECT (page_cache),
  70                                            (gpointer)&action_widget->page_cache);
  71         }
  72 }
  73
  74 static void
  75 ev_page_action_widget_finalize (GObject *object)
  76 {
  77         EvPageActionWidget *action_widget = EV_PAGE_ACTION_WIDGET (object);
  78
  79         ev_page_action_widget_set_page_cache (action_widget, NULL);
  80
  81         G_OBJECT_CLASS (ev_page_action_widget_parent_class)->finalize (object);
  82 }
  83
  84 static void
  85 ev_page_action_widget_class_init (EvPageActionWidgetClass *class)
  86 {
  87         GObjectClass *object_class = G_OBJECT_CLASS (class);
  88
  89         object_class->finalize = ev_page_action_widget_finalize;
  90
  91         widget_signals[WIDGET_ACTIVATE_LINK] = g_signal_new ("activate_link",
  92                                                G_OBJECT_CLASS_TYPE (object_class),
  93                                                G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
  94                                                G_STRUCT_OFFSET (EvPageActionClass, activate_link),
  95                                                NULL, NULL,
  96                                                g_cclosure_marshal_VOID__OBJECT,
  97                                                G_TYPE_NONE, 1,
  98                                                G_TYPE_OBJECT);
  99
 100 }
 101
 102 static gboolean
 103 match_selected_cb (GtkEntryCompletion *completion,
 104                    GtkTreeModel       *filter_model,
 105                    GtkTreeIter        *filter_iter,
 106                    EvPageActionWidget *proxy)
 107 {
 108         EvLink *link;
 109         GtkTreeIter *iter;
 110
 111         gtk_tree_model_get (filter_model, filter_iter,
 112                             0, &iter,
 113                             -1);
 114         gtk_tree_model_get (proxy->model, iter,
 115                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
 116                             -1);
 117
 118         g_signal_emit (proxy, widget_signals[WIDGET_ACTIVATE_LINK], 0, link);
 119
 120         if (link)
 121                 g_object_unref (link);
 122
 123         gtk_tree_iter_free (iter);
 124
 125         return TRUE;
 126 }
 127
 128
 129 static void
 130 display_completion_text (GtkCellLayout      *cell_layout,
 131                          GtkCellRenderer    *renderer,
 132                          GtkTreeModel       *filter_model,
 133                          GtkTreeIter        *filter_iter,
 134                          EvPageActionWidget *proxy)
 135 {
 136         EvLink *link;
 137         GtkTreeIter *iter;
 138
 139         gtk_tree_model_get (filter_model, filter_iter,
 140                             0, &iter,
 141                             -1);
 142         gtk_tree_model_get (proxy->model, iter,
 143                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
 144                             -1);
 145
 146         g_object_set (renderer, "text", ev_link_get_title (link), NULL);
 147
 148         if (link)
 149                 g_object_unref (link);
 150
 151         gtk_tree_iter_free (iter);
 152 }
 153
 154 static gboolean
 155 match_completion (GtkEntryCompletion *completion,
 156                   const gchar        *key,
 157                   GtkTreeIter        *filter_iter,
 158                   EvPageActionWidget *proxy)
 159 {
 160         EvLink *link;
 161         GtkTreeIter *iter;
 162         const gchar *text = NULL;
 163
 164         gtk_tree_model_get (gtk_entry_completion_get_model (completion),
 165                             filter_iter,
 166                             0, &iter,
 167                             -1);
 168         gtk_tree_model_get (proxy->model, iter,
 169                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
 170                             -1);
 171
 172
 173         if (link) {
 174                 text = ev_link_get_title (link);
 175                 g_object_unref (link);
 176         }
 177
 178         gtk_tree_iter_free (iter);
 179
 180         if (text && key) {
 181                 gchar *normalized_text;
 182                 gchar *normalized_key;
 183                 gchar *case_normalized_text;
 184                 gchar *case_normalized_key;
 185                 gboolean retval = FALSE;
 186
 187                 normalized_text = g_utf8_normalize (text, -1, G_NORMALIZE_ALL);
 188                 normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
 189                 case_normalized_text = g_utf8_casefold (normalized_text, -1);
 190                 case_normalized_key = g_utf8_casefold (normalized_key, -1);
 191
 192                 if (strstr (case_normalized_text, case_normalized_key))
 193                         retval = TRUE;
 194
 195                 g_free (normalized_text);
 196                 g_free (normalized_key);
 197                 g_free (case_normalized_text);
 198                 g_free (case_normalized_key);
 199
 200                 return retval;
 201         }
 202
 203         return FALSE;
 204 }
 205
 206 /* user data to set on the widget. */
 207 #define EPA_FILTER_MODEL_DATA "epa-filter-model"
 208
 209 static gboolean
 210 build_new_tree_cb (GtkTreeModel *model,
 211                    GtkTreePath  *path,
 212                    GtkTreeIter  *iter,
 213                    gpointer      data)
 214 {
 215         GtkTreeModel *filter_model = GTK_TREE_MODEL (data);
 216         EvLink *link;
 217         EvLinkAction *action;
 218         EvLinkActionType type;
 219
 220         gtk_tree_model_get (model, iter,
 221                             EV_DOCUMENT_LINKS_COLUMN_LINK, &link,
 222                             -1);
 223
 224         if (!link)
 225                 return FALSE;
 226
 227         action = ev_link_get_action (link);
 228         if (!action) {
 229                 g_object_unref (link);
 230                 return FALSE;
 231         }
 232
 233         type = ev_link_action_get_action_type (action);
 234
 235         if (type == EV_LINK_ACTION_TYPE_GOTO_DEST) {
 236                 GtkTreeIter filter_iter;
 237
 238                 gtk_list_store_append (GTK_LIST_STORE (filter_model), &filter_iter);
 239                 gtk_list_store_set (GTK_LIST_STORE (filter_model), &filter_iter,
 240                                     0, iter,
 241                                     -1);
 242         }
 243
 244         g_object_unref (link);
 245
 246         return FALSE;
 247 }
 248
 249 static GtkTreeModel *
 250 get_filter_model_from_model (GtkTreeModel *model)
 251 {
 252         GtkTreeModel *filter_model;
 253
 254         filter_model =
 255                 (GtkTreeModel *) g_object_get_data (G_OBJECT (model), EPA_FILTER_MODEL_DATA);
 256         if (filter_model == NULL) {
 257                 filter_model = (GtkTreeModel *) gtk_list_store_new (1, GTK_TYPE_TREE_ITER);
 258
 259                 gtk_tree_model_foreach (model,
 260                                         build_new_tree_cb,
 261                                         filter_model);
 262                 g_object_set_data_full (G_OBJECT (model), EPA_FILTER_MODEL_DATA, filter_model, g_object_unref);
 263         }
 264
 265         return filter_model;
 266 }
 267
 268
 269 void
 270 ev_page_action_widget_update_model (EvPageActionWidget *proxy, GtkTreeModel *model)
 271 {
 272         GtkTreeModel *filter_model;
 273
 274         if (model != NULL) {
 275                 /* Magik */
 276                 GtkEntryCompletion *completion;
 277                 GtkCellRenderer *renderer;
 278
 279                 proxy->model = model;
 280                 filter_model = get_filter_model_from_model (model);
 281
 282                 completion = gtk_entry_completion_new ();
 283
 284                 g_object_set (G_OBJECT (completion),
 285                               "popup-set-width", FALSE,
 286                               "model", filter_model,
 287                               NULL);
 288
 289                 g_signal_connect (completion, "match-selected", G_CALLBACK (match_selected_cb), proxy);
 290                 gtk_entry_completion_set_match_func (completion,
 291                                                      (GtkEntryCompletionMatchFunc) match_completion,
 292                                                      proxy, NULL);
 293
 294                 /* Set up the layout */
 295                 renderer = (GtkCellRenderer *)
 296                         g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
 297                                       "ellipsize", PANGO_ELLIPSIZE_END,
 298                                       "width_chars", 30,
 299                                       NULL);
 300                 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), renderer, TRUE);
 301                 gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (completion),
 302                                                     renderer,
 303                                                     (GtkCellLayoutDataFunc) display_completion_text,
 304                                                     proxy, NULL);
 305                 gtk_entry_set_completion (GTK_ENTRY (proxy->entry), completion);
 306
 307                 g_object_unref (completion);
 308                 g_object_unref (model);
 309         }
 310 }