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