/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* * Copyright © 2002 Ricardo Fernández Pascual * Copyright © 2003, 2004 Marco Pesenti Gritti * Copyright © 2003, 2004, 2005 Christian Persch * Copyright © 2008 Xan López * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "config.h" #include "ephy-location-entry.h" #include "ephy-widgets-type-builtins.h" #include "ephy-about-handler.h" #include "ephy-debug.h" #include "ephy-dnd.h" #include "ephy-gui.h" #include "ephy-lib-type-builtins.h" #include "ephy-signal-accumulator.h" #include "ephy-uri-helpers.h" #include #include #include #include #include #if 0 /* FIXME: Refactor the DNS prefetch, this is a layering violation */ #include #include #endif /** * SECTION:ephy-location-entry * @short_description: A location entry widget * @see_also: #GtkEntry * * #EphyLocationEntry implements the location bar in the main Epiphany window. */ struct _EphyLocationEntry { GtkEntry parent_instance; GdkPixbuf *favicon; GtkTreeModel *model; GSList *search_terms; GBinding *paste_binding; char *before_completion; char *saved_text; guint text_col; guint action_col; guint keywords_col; guint relevance_col; guint url_col; guint extra_col; guint favicon_col; guint hash; gulong dns_prefetch_handler; guint user_changed : 1; guint can_redo : 1; guint block_update : 1; guint original_address : 1; guint apply_colors : 1; guint needs_reset : 1; guint show_favicon : 1; GtkTargetList *drag_targets; GdkDragAction drag_actions; }; static const GtkTargetEntry url_drag_types [] = { { (char *)EPHY_DND_URL_TYPE, 0, 0 }, { (char *)EPHY_DND_URI_LIST_TYPE, 0, 1 }, { (char *)EPHY_DND_TEXT_TYPE, 0, 2 } }; static gboolean ephy_location_entry_reset_internal (EphyLocationEntry *, gboolean); static void extracell_data_func (GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data); enum { PROP_0, PROP_LOCATION, PROP_FAVICON, PROP_SECURITY_LEVEL, PROP_SHOW_FAVICON, LAST_PROP }; static GParamSpec *obj_properties[LAST_PROP]; enum signalsEnum { USER_CHANGED, LOCK_CLICKED, GET_LOCATION, GET_TITLE, LAST_SIGNAL }; static gint signals[LAST_SIGNAL] = { 0 }; G_DEFINE_TYPE (EphyLocationEntry, ephy_location_entry, GTK_TYPE_ENTRY) static void ephy_location_entry_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { EphyLocationEntry *entry = EPHY_LOCATION_ENTRY (object); switch (prop_id) { case PROP_LOCATION: ephy_location_entry_set_location (entry, g_value_get_string (value)); break; case PROP_FAVICON: ephy_location_entry_set_favicon (entry, g_value_get_object (value)); break; case PROP_SECURITY_LEVEL: ephy_location_entry_set_security_level (entry, g_value_get_enum (value)); break; case PROP_SHOW_FAVICON: ephy_location_entry_set_show_favicon (entry, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void ephy_location_entry_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { EphyLocationEntry *entry = EPHY_LOCATION_ENTRY (object); switch (prop_id) { case PROP_LOCATION: g_value_set_string (value, ephy_location_entry_get_location (entry)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void ephy_location_entry_finalize (GObject *object) { EphyLocationEntry *entry = EPHY_LOCATION_ENTRY (object); g_free (entry->saved_text); if (entry->drag_targets != NULL) { gtk_target_list_unref (entry->drag_targets); } if (entry->favicon != NULL) { g_object_unref (entry->favicon); } G_OBJECT_CLASS (ephy_location_entry_parent_class)->finalize (object); } static void ephy_location_entry_get_preferred_width (GtkWidget *widget, gint *minimum_width, gint *natural_width) { if (minimum_width) *minimum_width = -1; if (natural_width) *natural_width = 848; } static void ephy_location_entry_copy_clipboard (GtkEntry *entry) { char *text; gint start; gint end; if (!gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end)) return; text = gtk_editable_get_chars (GTK_EDITABLE (entry), start, end); if (start == 0) { char *tmp = text; text = ephy_uri_normalize (tmp); g_free (tmp); } gtk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_CLIPBOARD), text, -1); g_free (text); } static void ephy_location_entry_cut_clipboard (GtkEntry *entry) { if (!gtk_editable_get_editable (GTK_EDITABLE (entry))) { gtk_widget_error_bell (GTK_WIDGET (entry)); return; } ephy_location_entry_copy_clipboard (entry); gtk_editable_delete_selection (GTK_EDITABLE (entry)); } static void ephy_location_entry_class_init (EphyLocationEntryClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); GtkEntryClass *entry_class = GTK_ENTRY_CLASS (klass); object_class->get_property = ephy_location_entry_get_property; object_class->set_property = ephy_location_entry_set_property; object_class->finalize = ephy_location_entry_finalize; widget_class->get_preferred_width = ephy_location_entry_get_preferred_width; entry_class->copy_clipboard = ephy_location_entry_copy_clipboard; entry_class->cut_clipboard = ephy_location_entry_cut_clipboard; /** * EphyLocationEntry:location: * * The current location. */ obj_properties[PROP_LOCATION] = g_param_spec_string ("location", "Location", "The current location", "", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); /** * EphyLocationEntry:favicon: * * The icon corresponding to the current location. */ obj_properties[PROP_FAVICON] = g_param_spec_object ("favicon", "Favicon", "The icon corresponding to the current location", GDK_TYPE_PIXBUF, G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); /** * EphyLocationEntry:security-level: * * State of the security icon. */ obj_properties[PROP_SECURITY_LEVEL] = g_param_spec_enum ("security-level", "Security level", "State of the security icon", EPHY_TYPE_SECURITY_LEVEL, EPHY_SECURITY_LEVEL_TO_BE_DETERMINED, G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); obj_properties[PROP_SHOW_FAVICON] = g_param_spec_boolean ("show-favicon", "Show Favicon", "Whether to show the favicon", TRUE, G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (object_class, LAST_PROP, obj_properties); /** * EphyLocationEntry::user-changed: * @entry: the object on which the signal is emitted * * Emitted when the user changes the contents of the internal #GtkEntry * */ signals[USER_CHANGED] = g_signal_new ( "user_changed", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0, G_TYPE_NONE); /** * EphyLocationEntry::lock-clicked: * @entry: the object on which the signal is emitted * * Emitted when the user clicks the security icon inside the * #EphyLocationEntry. * */ signals[LOCK_CLICKED] = g_signal_new ( "lock-clicked", EPHY_TYPE_LOCATION_ENTRY, G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); /** * EphyLocationEntry::get-location: * @entry: the object on which the signal is emitted * Returns: the current page address as a string * * For drag and drop purposes, the location bar will request you the * real address of where it is pointing to. The signal handler for this * function should return the address of the currently loaded site. * */ signals[GET_LOCATION] = g_signal_new ( "get-location", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST, 0, ephy_signal_accumulator_string, NULL, NULL, G_TYPE_STRING, 0, G_TYPE_NONE); /** * EphyLocationEntry::get-title: * @entry: the object on which the signal is emitted * Returns: the current page title as a string * * For drag and drop purposes, the location bar will request you the * title of where it is pointing to. The signal handler for this * function should return the title of the currently loaded site. * */ signals[GET_TITLE] = g_signal_new ( "get-title", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST, 0, ephy_signal_accumulator_string, NULL, NULL, G_TYPE_STRING, 0, G_TYPE_NONE); } static void update_address_state (EphyLocationEntry *entry) { const char *text; text = gtk_entry_get_text (GTK_ENTRY (entry)); entry->original_address = text != NULL && g_str_hash (text) == entry->hash; } static void update_favicon (EphyLocationEntry *lentry) { GtkEntry *entry = GTK_ENTRY (lentry); /* Only show the favicon if the entry's text is the * address of the current page. */ if (lentry->show_favicon && lentry->favicon != NULL && lentry->original_address) { gtk_entry_set_icon_from_pixbuf (entry, GTK_ENTRY_ICON_PRIMARY, lentry->favicon); } else if (lentry->show_favicon) { const char *icon_name; /* Here we could consider using fallback favicon that matches * the page MIME type, though text/html should be good enough * most of the time. See #337140 */ if (gtk_entry_get_text_length (entry) > 0) icon_name = "text-x-generic-symbolic"; else icon_name = "edit-find-symbolic"; gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_PRIMARY, icon_name); } else { gtk_entry_set_icon_from_icon_name (entry, GTK_ENTRY_ICON_PRIMARY, NULL); } } static void editable_changed_cb (GtkEditable *editable, EphyLocationEntry *entry) { update_address_state (entry); if (entry->block_update == TRUE) return; else { entry->user_changed = TRUE; entry->can_redo = FALSE; } g_signal_emit (entry, signals[USER_CHANGED], 0); } static gboolean entry_key_press_cb (GtkEntry *entry, GdkEventKey *event, EphyLocationEntry *location_entry) { guint state = event->state & gtk_accelerator_get_default_mod_mask (); if (event->keyval == GDK_KEY_Escape && state == 0) { ephy_location_entry_reset_internal (location_entry, TRUE); /* don't return TRUE since we want to cancel the autocompletion popup too */ } if (event->keyval == GDK_KEY_l && state == GDK_CONTROL_MASK) { /* Make sure the location is activated on CTRL+l even when the * completion popup is shown and have an active keyboard grab. */ ephy_location_entry_activate (location_entry); } return FALSE; } static gboolean entry_key_press_after_cb (GtkEntry *entry, GdkEventKey *event, EphyLocationEntry *lentry) { guint state = event->state & gtk_accelerator_get_default_mod_mask (); if ((event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter || event->keyval == GDK_KEY_ISO_Enter) && (state == GDK_CONTROL_MASK || state == (GDK_CONTROL_MASK | GDK_SHIFT_MASK))) { /* gtk_im_context_reset (entry->im_context); */ lentry->needs_reset = TRUE; g_signal_emit_by_name (entry, "activate"); return TRUE; } if ((event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down) && state == 0) { /* If we are focusing the entry, with the cursor at the end of it * we emit the changed signal, so that the completion popup appears */ const char *string; string = gtk_entry_get_text (entry); if (gtk_editable_get_position (GTK_EDITABLE (entry)) == (int)strlen (string)) { g_signal_emit_by_name (entry, "changed", 0); return TRUE; } } return FALSE; } static void entry_activate_after_cb (GtkEntry *entry, EphyLocationEntry *lentry) { lentry->user_changed = FALSE; if (lentry->needs_reset) { ephy_location_entry_reset_internal (lentry, TRUE); lentry->needs_reset = FALSE; } } static gboolean match_selected_cb (GtkEntryCompletion *completion, GtkTreeModel *model, GtkTreeIter *iter, EphyLocationEntry *entry) { char *item = NULL; guint state; gtk_tree_model_get (model, iter, entry->action_col, &item, -1); if (item == NULL) return FALSE; ephy_gui_get_current_event (NULL, &state, NULL); entry->needs_reset = (state == GDK_CONTROL_MASK || state == (GDK_CONTROL_MASK | GDK_SHIFT_MASK)); ephy_location_entry_set_location (entry, item); /* gtk_im_context_reset (GTK_ENTRY (entry)->im_context); */ g_signal_emit_by_name (entry, "activate"); g_free (item); return TRUE; } static void action_activated_after_cb (GtkEntryCompletion *completion, gint index, EphyLocationEntry *lentry) { guint state, button; ephy_gui_get_current_event (NULL, &state, &button); if ((state == GDK_CONTROL_MASK || state == (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) || button == 2) { ephy_location_entry_reset_internal (lentry, TRUE); } } static gboolean entry_drag_motion_cb (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time) { return FALSE; } static gboolean entry_drag_drop_cb (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time) { return FALSE; } static void entry_clear_activate_cb (GtkMenuItem *item, EphyLocationEntry *entry) { entry->block_update = TRUE; gtk_entry_set_text (GTK_ENTRY (entry), ""); entry->block_update = FALSE; entry->user_changed = TRUE; } static void paste_received (GtkClipboard *clipboard, const gchar *text, EphyLocationEntry *entry) { if (text) { gtk_entry_set_text (GTK_ENTRY (entry), text); g_signal_emit_by_name (entry, "activate"); } } static void entry_paste_and_go_activate_cb (GtkMenuItem *item, EphyLocationEntry *entry) { GtkClipboard *clipboard; clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD); gtk_clipboard_request_text (clipboard, (GtkClipboardTextReceivedFunc)paste_received, entry); } static void entry_redo_activate_cb (GtkMenuItem *item, EphyLocationEntry *entry) { ephy_location_entry_undo_reset (entry); } static void entry_undo_activate_cb (GtkMenuItem *item, EphyLocationEntry *entry) { ephy_location_entry_reset_internal (entry, FALSE); } static void entry_populate_popup_cb (GtkEntry *entry, GtkMenu *menu, EphyLocationEntry *lentry) { GtkWidget *clear_menuitem; GtkWidget *undo_menuitem; GtkWidget *redo_menuitem; GtkWidget *paste_and_go_menuitem; GtkWidget *separator; GtkWidget *paste_menuitem; GList *children, *item; int pos = 0, sep = 0; gboolean is_editable; /* Translators: the mnemonic shouldn't conflict with any of the * standard items in the GtkEntry context menu (Cut, Copy, Paste, Delete, * Select All, Input Methods and Insert Unicode control character.) */ clear_menuitem = gtk_menu_item_new_with_mnemonic (_("Cl_ear")); g_signal_connect (clear_menuitem, "activate", G_CALLBACK (entry_clear_activate_cb), lentry); is_editable = gtk_editable_get_editable (GTK_EDITABLE (entry)); gtk_widget_set_sensitive (clear_menuitem, is_editable); gtk_widget_show (clear_menuitem); /* search for the 2nd separator (the one after Select All) in the context * menu, and insert this menu item before it. * It's a bit of a hack, but there seems to be no better way to do it :/ */ children = gtk_container_get_children (GTK_CONTAINER (menu)); for (item = children; item != NULL && sep < 2; item = item->next, pos++) { if (GTK_IS_SEPARATOR_MENU_ITEM (item->data)) sep++; } gtk_menu_shell_insert (GTK_MENU_SHELL (menu), clear_menuitem, pos - 1); paste_and_go_menuitem = gtk_menu_item_new_with_mnemonic (_("Paste and _Go")); /* Search for the Paste menu item and insert right after it. */ children = gtk_container_get_children (GTK_CONTAINER (menu)); for (item = children, pos = 0; item != NULL; item = item->next, pos++) { if (g_strcmp0 (gtk_menu_item_get_label (item->data), _("_Paste")) == 0) { paste_menuitem = item->data; break; } } g_signal_connect (paste_and_go_menuitem, "activate", G_CALLBACK (entry_paste_and_go_activate_cb), lentry); lentry->paste_binding = g_object_bind_property (paste_menuitem, "sensitive", paste_and_go_menuitem, "sensitive", G_BINDING_SYNC_CREATE); gtk_widget_show (paste_and_go_menuitem); gtk_menu_shell_insert (GTK_MENU_SHELL (menu), paste_and_go_menuitem, pos + 1); undo_menuitem = gtk_menu_item_new_with_mnemonic (_("_Undo")); gtk_widget_set_sensitive (undo_menuitem, lentry->user_changed); g_signal_connect (undo_menuitem, "activate", G_CALLBACK (entry_undo_activate_cb), lentry); gtk_widget_show (undo_menuitem); gtk_menu_shell_insert (GTK_MENU_SHELL (menu), undo_menuitem, 0); redo_menuitem = gtk_menu_item_new_with_mnemonic (_("_Redo")); gtk_widget_set_sensitive (redo_menuitem, lentry->can_redo); g_signal_connect (redo_menuitem, "activate", G_CALLBACK (entry_redo_activate_cb), lentry); gtk_widget_show (redo_menuitem); gtk_menu_shell_insert (GTK_MENU_SHELL (menu), redo_menuitem, 1); separator = gtk_separator_menu_item_new (); gtk_widget_show (separator); gtk_menu_shell_insert (GTK_MENU_SHELL (menu), separator, 2); } static void each_url_get_data_binder (EphyDragEachSelectedItemDataGet iteratee, gpointer iterator_context, gpointer return_data) { EphyLocationEntry *entry = EPHY_LOCATION_ENTRY (iterator_context); char *title = NULL, *address = NULL; g_signal_emit (entry, signals[GET_LOCATION], 0, &address); g_signal_emit (entry, signals[GET_TITLE], 0, &title); g_return_if_fail (address != NULL && title != NULL); iteratee (address, title, return_data); g_free (address); g_free (title); } static void sanitize_location (char **url) { char *str; /* Do not show internal ephy-about: protocol to users */ if (g_str_has_prefix (*url, EPHY_ABOUT_SCHEME)) { str = g_strdup_printf ("about:%s", *url + strlen (EPHY_ABOUT_SCHEME) + 1); g_free (*url); *url = str; } } #define DRAG_ICON_LAYOUT_PADDING 5 #define DRAG_ICON_ICON_PADDING 10 #define DRAG_ICON_MAX_WIDTH_CHARS 32 static cairo_surface_t * favicon_create_drag_surface (EphyLocationEntry *entry, GtkWidget *widget) { char *title = NULL, *address = NULL; GString *text; GtkStyleContext *style; const PangoFontDescription *font_desc; cairo_surface_t *surface; PangoContext *context; PangoLayout *layout; PangoFontMetrics *metrics; int surface_height, surface_width; int layout_width, layout_height; int icon_width = 0, icon_height = 0, favicon_offset_x = 0; int char_width; cairo_t *cr; GtkStateFlags state; GdkRGBA color; GdkPixbuf *favicon; g_signal_emit (entry, signals[GET_LOCATION], 0, &address); sanitize_location (&address); g_signal_emit (entry, signals[GET_TITLE], 0, &title); if (address == NULL || title == NULL) return NULL; /* Compute text */ title = g_strstrip (title); text = g_string_sized_new (strlen (address) + strlen (title) + 2); if (title[0] != '\0') { g_string_append (text, title); g_string_append (text, "\n"); } if (address[0] != '\0') { g_string_append (text, address); } if (entry->favicon != NULL) favicon = g_object_ref (entry->favicon); else favicon = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "text-x-generic-symbolic", 16, 0, NULL); if (favicon != NULL) { icon_width = gdk_pixbuf_get_width (favicon); icon_height = gdk_pixbuf_get_height (favicon); } context = gtk_widget_get_pango_context (widget); layout = pango_layout_new (context); style = gtk_widget_get_style_context (GTK_WIDGET (entry)); state = gtk_style_context_get_state (style); gtk_style_context_save (style); gtk_style_context_set_state (style, GTK_STATE_FLAG_NORMAL); gtk_style_context_get (style, GTK_STATE_FLAG_NORMAL, "font", &font_desc, NULL); gtk_style_context_restore (style); metrics = pango_context_get_metrics (context, font_desc, pango_context_get_language (context)); char_width = pango_font_metrics_get_approximate_digit_width (metrics); pango_font_metrics_unref (metrics); pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END); pango_layout_set_width (layout, char_width * DRAG_ICON_MAX_WIDTH_CHARS); pango_layout_set_text (layout, text->str, text->len); pango_layout_get_pixel_size (layout, &layout_width, &layout_height); if (favicon != NULL) { favicon_offset_x = icon_width + (2 * DRAG_ICON_ICON_PADDING); } surface_width = layout_width + favicon_offset_x + (DRAG_ICON_LAYOUT_PADDING * 3); surface_height = MAX (layout_height, icon_height) + (DRAG_ICON_LAYOUT_PADDING * 2); surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR, surface_width + 2, surface_height + 2); cr = cairo_create (surface); cairo_rectangle (cr, 1, 1, surface_width, surface_height); cairo_set_line_width (cr, 1.0); cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); cairo_stroke_preserve (cr); gtk_style_context_get_background_color (style, state, &color); gdk_cairo_set_source_rgba (cr, &color); cairo_fill (cr); if (favicon != NULL) { double x; double y; x = 1 + DRAG_ICON_LAYOUT_PADDING + DRAG_ICON_ICON_PADDING; y = (surface_height - icon_height) / 2; gdk_cairo_set_source_pixbuf (cr, favicon, x, y); cairo_rectangle (cr, x, y, icon_width, icon_height); cairo_fill (cr); } cairo_move_to (cr, 1 + DRAG_ICON_LAYOUT_PADDING + favicon_offset_x, 1 + DRAG_ICON_LAYOUT_PADDING); gtk_style_context_get_color (style, state, &color); gdk_cairo_set_source_rgba (cr, &color); pango_cairo_show_layout (cr, layout); cairo_destroy (cr); g_object_unref (layout); g_free (address); g_free (title); g_string_free (text, TRUE); g_clear_object (&favicon); return surface; } static void favicon_drag_begin_cb (GtkWidget *widget, GdkDragContext *context, EphyLocationEntry *lentry) { cairo_surface_t *surface; GtkEntry *entry; gint index; entry = GTK_ENTRY (widget); index = gtk_entry_get_current_icon_drag_source (entry); if (index != GTK_ENTRY_ICON_PRIMARY) return; surface = favicon_create_drag_surface (lentry, widget); if (surface != NULL) { gtk_drag_set_icon_surface (context, surface); cairo_surface_destroy (surface); } } static void favicon_drag_data_get_cb (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint32 time, EphyLocationEntry *lentry) { gint index; GtkEntry *entry; g_assert (widget != NULL); g_return_if_fail (context != NULL); entry = GTK_ENTRY (widget); index = gtk_entry_get_current_icon_drag_source (entry); if (index == GTK_ENTRY_ICON_PRIMARY) { ephy_dnd_drag_data_get (widget, context, selection_data, time, lentry, each_url_get_data_binder); } } static gboolean icon_button_press_event_cb (GtkWidget *entry, GtkEntryIconPosition position, GdkEventButton *event, EphyLocationEntry *lentry) { guint state = event->state & gtk_accelerator_get_default_mod_mask (); if (event->type == GDK_BUTTON_PRESS && event->button == 1 && state == 0 /* left */) { if (position == GTK_ENTRY_ICON_PRIMARY) { GtkWidget *toplevel; toplevel = gtk_widget_get_toplevel (GTK_WIDGET (entry)); gtk_window_set_focus (GTK_WINDOW (toplevel), entry); gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); } else { g_signal_emit (lentry, signals[LOCK_CLICKED], 0); } return TRUE; } return FALSE; } static void ephy_location_entry_construct_contents (EphyLocationEntry *lentry) { GtkWidget *entry = GTK_WIDGET (lentry); LOG ("EphyLocationEntry constructing contents %p", lentry); /* Favicon */ lentry->drag_targets = gtk_target_list_new (url_drag_types, G_N_ELEMENTS (url_drag_types)); lentry->drag_actions = GDK_ACTION_ASK | GDK_ACTION_COPY | GDK_ACTION_LINK; gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, lentry->drag_targets, lentry->drag_actions); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, _("Drag and drop this icon to create a link to this page")); gtk_drag_dest_set (entry, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, url_drag_types, G_N_ELEMENTS (url_drag_types), GDK_ACTION_MOVE | GDK_ACTION_COPY); g_object_connect (entry, "signal::icon-press", G_CALLBACK (icon_button_press_event_cb), lentry, "signal::populate-popup", G_CALLBACK (entry_populate_popup_cb), lentry, "signal::key-press-event", G_CALLBACK (entry_key_press_cb), lentry, "signal::changed", G_CALLBACK (editable_changed_cb), lentry, "signal::drag-motion", G_CALLBACK (entry_drag_motion_cb), lentry, "signal::drag-drop", G_CALLBACK (entry_drag_drop_cb), lentry, "signal::drag-data-get", G_CALLBACK (favicon_drag_data_get_cb), lentry, NULL); g_signal_connect_after (entry, "key-press-event", G_CALLBACK (entry_key_press_after_cb), lentry); g_signal_connect_after (entry, "activate", G_CALLBACK (entry_activate_after_cb), lentry); g_signal_connect_after (entry, "drag-begin", G_CALLBACK (favicon_drag_begin_cb), lentry); } static void ephy_location_entry_init (EphyLocationEntry *le) { LOG ("EphyLocationEntry initialising %p", le); le->user_changed = FALSE; le->block_update = FALSE; le->saved_text = NULL; le->show_favicon = TRUE; le->dns_prefetch_handler = 0; ephy_location_entry_construct_contents (le); } GtkWidget * ephy_location_entry_new (void) { return GTK_WIDGET (g_object_new (EPHY_TYPE_LOCATION_ENTRY, NULL)); } #if 0 /* FIXME: Refactor the DNS prefetch, this is a layering violation */ typedef struct { SoupURI *uri; EphyLocationEntry *entry; } PrefetchHelper; static void free_prefetch_helper (PrefetchHelper *helper) { soup_uri_free (helper->uri); g_object_unref (helper->entry); g_slice_free (PrefetchHelper, helper); } static gboolean do_dns_prefetch (PrefetchHelper *helper) { EphyEmbedShell *shell = ephy_embed_shell_get_default (); if (helper->uri) webkit_web_context_prefetch_dns (ephy_embed_shell_get_web_context (shell), helper->uri->host); helper->entry->dns_prefetch_handler = 0; return FALSE; } static void schedule_dns_prefetch (EphyLocationEntry *entry, guint interval, const gchar *url) { PrefetchHelper *helper; SoupURI *uri; uri = soup_uri_new (url); if (!uri || !uri->host) { soup_uri_free (uri); return; } if (entry->dns_prefetch_handler) g_source_remove (entry->dns_prefetch_handler); helper = g_slice_new0 (PrefetchHelper); helper->entry = g_object_ref (entry); helper->uri = uri; entry->dns_prefetch_handler = g_timeout_add_full (G_PRIORITY_DEFAULT, interval, (GSourceFunc)do_dns_prefetch, helper, (GDestroyNotify)free_prefetch_helper); g_source_set_name_by_id (entry->dns_prefetch_handler, "[epiphany] do_dns_prefetch"); } #endif static gboolean cursor_on_match_cb (GtkEntryCompletion *completion, GtkTreeModel *model, GtkTreeIter *iter, EphyLocationEntry *le) { char *url = NULL; GtkWidget *entry; gtk_tree_model_get (model, iter, le->url_col, &url, -1); entry = gtk_entry_completion_get_entry (completion); /* Prevent the update so we keep the highlight from our input. * See textcell_data_func(). */ le->block_update = TRUE; gtk_entry_set_text (GTK_ENTRY (entry), url); gtk_editable_set_position (GTK_EDITABLE (entry), -1); le->block_update = FALSE; #if 0 /* FIXME: Refactor the DNS prefetch, this is a layering violation */ schedule_dns_prefetch (le, 250, (const gchar *)url); #endif g_free (url); return TRUE; } static void extracell_data_func (GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) { EphyLocationEntry *entry = EPHY_LOCATION_ENTRY (data); gboolean is_bookmark = FALSE; GValue visible = { 0, }; gtk_tree_model_get (tree_model, iter, entry->extra_col, &is_bookmark, -1); if (is_bookmark) g_object_set (cell, "icon-name", "user-bookmarks-symbolic", NULL); g_value_init (&visible, G_TYPE_BOOLEAN); g_value_set_boolean (&visible, is_bookmark); g_object_set_property (G_OBJECT (cell), "visible", &visible); g_value_unset (&visible); } /** * ephy_location_entry_set_match_func: * @entry: an #EphyLocationEntry widget * @match_func: a #GtkEntryCompletionMatchFunc * @user_data: user_data to pass to the @match_func * @notify: a #GDestroyNotify, like the one given to * gtk_entry_completion_set_match_func * * Sets the match_func for the internal #GtkEntryCompletion to @match_func. * **/ void ephy_location_entry_set_match_func (EphyLocationEntry *entry, GtkEntryCompletionMatchFunc match_func, gpointer user_data, GDestroyNotify notify) { GtkEntryCompletion *completion; completion = gtk_entry_get_completion (GTK_ENTRY (entry)); gtk_entry_completion_set_match_func (completion, match_func, user_data, notify); } /** * ephy_location_entry_set_completion: * @entry: an #EphyLocationEntry widget * @model: the #GtkModel for the completion * @text_col: column id to access #GtkModel relevant data * @action_col: column id to access #GtkModel relevant data * @keywords_col: column id to access #GtkModel relevant data * @relevance_col: column id to access #GtkModel relevant data * @url_col: column id to access #GtkModel relevant data * @extra_col: column id to access #GtkModel relevant data * @favicon_col: column id to access #GtkModel relevant data * * Initializes @entry to have a #GtkEntryCompletion using @model as the * internal #GtkModel. The *_col arguments are for internal data retrieval from * @model, like when setting the text property of one of the #GtkCellRenderer * of the completion. * **/ void ephy_location_entry_set_completion (EphyLocationEntry *entry, GtkTreeModel *model, guint text_col, guint action_col, guint keywords_col, guint relevance_col, guint url_col, guint extra_col, guint favicon_col) { GtkEntryCompletion *completion; GtkCellRenderer *cell; entry->text_col = text_col; entry->action_col = action_col; entry->keywords_col = keywords_col; entry->relevance_col = relevance_col; entry->url_col = url_col; entry->extra_col = extra_col; entry->favicon_col = favicon_col; completion = gtk_entry_completion_new (); gtk_entry_completion_set_model (completion, model); g_signal_connect (completion, "match-selected", G_CALLBACK (match_selected_cb), entry); g_signal_connect_after (completion, "action-activated", G_CALLBACK (action_activated_after_cb), entry); cell = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), cell, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (completion), cell, "pixbuf", favicon_col); /* Pixel-perfect aligment with the location entry favicon * (16x16). Consider that this /might/ depend on the theme. * * The GtkEntryCompletion can not be themed so we work-around * that with padding and fixed sizes. * For the first cell, this is: * * ___+++++iiiiiiiiiiiiiiii++__ttt...bbb++++++__ * * _ = widget spacing, can not be handled (3 px) * + = padding (5 px) (ICON_PADDING_LEFT) * i = the icon (16 px) (ICON_CONTENT_WIDTH) * + = padding (2 px) (ICON_PADDING_RIGHT) (cut by the fixed_size) * _ = spacing between cells, can not be handled (2 px) * t = the text (expands) * b = bookmark icon (16 px) * + = padding (6 px) (BKMK_PADDING_RIGHT) * _ = widget spacing, can not be handled (2 px) * * Each character is a pixel. * * The text cell and the bookmark icon cell are much more * flexible in its aligment, because they do not have to align * with anything in the entry. */ #define ROW_PADDING_VERT 4 #define ICON_PADDING_LEFT 5 #define ICON_CONTENT_WIDTH 16 #define ICON_PADDING_RIGHT 9 #define ICON_CONTENT_HEIGHT 16 #define TEXT_PADDING_LEFT 0 #define BKMK_PADDING_RIGHT 6 gtk_cell_renderer_set_padding (cell, ICON_PADDING_LEFT, ROW_PADDING_VERT); gtk_cell_renderer_set_fixed_size (cell, (ICON_PADDING_LEFT + ICON_CONTENT_WIDTH + ICON_PADDING_RIGHT), ICON_CONTENT_HEIGHT); gtk_cell_renderer_set_alignment (cell, 0.0, 0.5); cell = gd_two_lines_renderer_new (); g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, "text-lines", 2, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (completion), cell, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (completion), cell, "text", text_col); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (completion), cell, "line-two", url_col); /* Pixel-perfect aligment with the text in the location entry. * See above. */ gtk_cell_renderer_set_padding (cell, TEXT_PADDING_LEFT, ROW_PADDING_VERT); gtk_cell_renderer_set_alignment (cell, 0.0, 0.5); /* * As the width of the entry completion is known in advance * (as big as the entry you are completing on), we can set * any fixed width (the 1 is just this random number here) * Since the height is known too, we avoid computing the actual * sizes of the cells, which takes a lot of CPU time and does * not get used anyway. */ gtk_cell_renderer_set_fixed_size (cell, 1, -1); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (cell), 2); cell = gtk_cell_renderer_pixbuf_new (); g_object_set (cell, "follow-state", TRUE, NULL); gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (completion), cell, FALSE); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (completion), cell, extracell_data_func, entry, NULL); /* Pixel-perfect aligment. This just keeps the same margin from * the border than the favicon on the other side. See above. */ gtk_cell_renderer_set_padding (cell, BKMK_PADDING_RIGHT, ROW_PADDING_VERT); g_object_set (completion, "inline-selection", TRUE, NULL); g_signal_connect (completion, "cursor-on-match", G_CALLBACK (cursor_on_match_cb), entry); gtk_entry_set_completion (GTK_ENTRY (entry), completion); g_object_unref (completion); } /** * ephy_location_entry_set_location: * @entry: an #EphyLocationEntry widget * @address: new location address * * Sets the current address of @entry to @address. **/ void ephy_location_entry_set_location (EphyLocationEntry *entry, const char *address) { GtkWidget *widget = GTK_WIDGET (entry); GtkClipboard *clipboard; const char *text; char *effective_text = NULL, *selection = NULL; int start, end; /* Setting a new text will clear the clipboard. This makes it impossible * to copy&paste from the location entry of one tab into another tab, see * bug #155824. So we save the selection iff the clipboard was owned by * the location entry. */ if (gtk_widget_get_realized (widget)) { clipboard = gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY); g_return_if_fail (clipboard != NULL); if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (widget) && gtk_editable_get_selection_bounds (GTK_EDITABLE (widget), &start, &end)) { selection = gtk_editable_get_chars (GTK_EDITABLE (widget), start, end); } } if (address != NULL) { if (g_str_has_prefix (address, EPHY_ABOUT_SCHEME)) effective_text = g_strdup_printf ("about:%s", address + strlen (EPHY_ABOUT_SCHEME) + 1); text = address; gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, entry->drag_targets, entry->drag_actions); } else { text = ""; gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, NULL, GDK_ACTION_DEFAULT); } /* First record the new hash, then update the entry text */ entry->hash = g_str_hash (effective_text ? effective_text : text); entry->block_update = TRUE; gtk_entry_set_text (GTK_ENTRY (widget), effective_text ? effective_text : text); entry->block_update = FALSE; g_free (effective_text); /* We need to call update_address_state() here, as the 'changed' signal * may not get called if the user has typed in the exact correct url */ update_address_state (entry); update_favicon (entry); /* Now restore the selection. * Note that it's not owned by the entry anymore! */ if (selection != NULL) { gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_PRIMARY), selection, strlen (selection)); g_free (selection); } } /** * ephy_location_entry_get_can_undo: * @entry: an #EphyLocationEntry widget * * Wheter @entry can restore the displayed user modified text to the unmodified * previous text. * * Return value: TRUE or FALSE indicating if the text can be restored * **/ gboolean ephy_location_entry_get_can_undo (EphyLocationEntry *entry) { return entry->user_changed; } /** * ephy_location_entry_get_can_redo: * @entry: an #EphyLocationEntry widget * * Wheter @entry can restore the displayed text to the user modified version * before the undo. * * Return value: TRUE or FALSE indicating if the text can be restored * **/ gboolean ephy_location_entry_get_can_redo (EphyLocationEntry *entry) { return entry->can_redo; } /** * ephy_location_entry_get_location: * @entry: an #EphyLocationEntry widget * * Retrieves the text displayed by the internal #GtkEntry of @entry. This is * the currently displayed text, like in any #GtkEntry. * * Return value: the text inside the inner #GtkEntry of @entry, owned by GTK+ * **/ const char * ephy_location_entry_get_location (EphyLocationEntry *entry) { return gtk_entry_get_text (GTK_ENTRY (entry)); } static gboolean ephy_location_entry_reset_internal (EphyLocationEntry *entry, gboolean notify) { const char *text, *old_text; char *url = NULL; gboolean retval; g_signal_emit (entry, signals[GET_LOCATION], 0, &url); text = url != NULL ? url : ""; old_text = gtk_entry_get_text (GTK_ENTRY (entry)); old_text = old_text != NULL ? old_text : ""; g_free (entry->saved_text); entry->saved_text = g_strdup (old_text); entry->can_redo = TRUE; retval = g_str_hash (text) != g_str_hash (old_text); ephy_location_entry_set_location (entry, text); g_free (url); if (notify) { g_signal_emit (entry, signals[USER_CHANGED], 0); } entry->user_changed = FALSE; return retval; } /** * ephy_location_entry_undo_reset: * @entry: an #EphyLocationEntry widget * * Undo a previous ephy_location_entry_reset. * **/ void ephy_location_entry_undo_reset (EphyLocationEntry *entry) { gtk_entry_set_text (GTK_ENTRY (entry), entry->saved_text); entry->can_redo = FALSE; entry->user_changed = TRUE; } /** * ephy_location_entry_reset: * @entry: an #EphyLocationEntry widget * * Restore the @entry to the text corresponding to the current location, this * does not fire the user_changed signal. This is called each time the user * presses Escape while the location entry is selected. * * Return value: TRUE on success, FALSE otherwise * **/ gboolean ephy_location_entry_reset (EphyLocationEntry *entry) { return ephy_location_entry_reset_internal (entry, FALSE); } /** * ephy_location_entry_activate: * @entry: an #EphyLocationEntry widget * * Set focus on @entry and select the text whithin. This is called when the * user hits Control+L. * **/ void ephy_location_entry_activate (EphyLocationEntry *entry) { GtkWidget *toplevel, *widget = GTK_WIDGET (entry); toplevel = gtk_widget_get_toplevel (widget); gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); gtk_window_set_focus (GTK_WINDOW (toplevel), widget); } /** * ephy_location_entry_set_favicon: * @entry: an #EphyLocationEntry widget * @pixbuf: a #GdkPixbuf to be set as the icon of the entry * * Sets the icon in the internal #EphyIconEntry of @entry * **/ void ephy_location_entry_set_favicon (EphyLocationEntry *entry, GdkPixbuf *pixbuf) { if (entry->favicon != NULL) { g_object_unref (entry->favicon); } entry->favicon = pixbuf ? g_object_ref (pixbuf) : NULL; update_favicon (entry); } void ephy_location_entry_set_show_favicon (EphyLocationEntry *entry, gboolean show_favicon) { g_return_if_fail (EPHY_IS_LOCATION_ENTRY (entry)); entry->show_favicon = show_favicon != FALSE; update_favicon (entry); } /** * ephy_location_entry_set_security_level: * @entry: an #EphyLocationEntry widget * @state: the #EphySecurityLevel * * Set the lock icon to be displayed * **/ void ephy_location_entry_set_security_level (EphyLocationEntry *entry, EphySecurityLevel security_level) { const char *icon_name; g_return_if_fail (EPHY_IS_LOCATION_ENTRY (entry)); icon_name = ephy_security_level_to_icon_name (security_level); gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, icon_name); } /** * ephy_location_entry_set_lock_tooltip: * @entry: an #EphyLocationEntry widget * @tooltip: the text to be set in the tooltip for the lock icon * * Set the text to be displayed when hovering the lock icon of @entry. * **/ void ephy_location_entry_set_lock_tooltip (EphyLocationEntry *entry, const char *tooltip) { gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, tooltip); } /** * ephy_location_entry_get_search_terms: * @entry: an #EphyLocationEntry widget * * Return the internal #GSList containing the search terms as #GRegex * instances, formed in @entry on user changes. * * Return value: the internal #GSList * **/ GSList * ephy_location_entry_get_search_terms (EphyLocationEntry *entry) { return entry->search_terms; }