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