/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "config.h"
#include "ephy-location-entry.h"
#include "ephy-about-handler.h"
#include "ephy-debug.h"
#include "ephy-dnd.h"
#include "ephy-gui.h"
#include "ephy-signal-accumulator.h"
#include <libsoup/soup.h>
#include <gdk/gdkkeysyms.h>
#include <glib/gi18n.h>
#include <gtk/gtk.h>
#include <string.h>
#ifdef HAVE_WEBKIT2
#include <webkit2/webkit2.h>
#else
#include <webkit/webkit.h>
#endif
/**
* SECTION:ephy-location-entry
* @short_description: A location entry widget
* @see_also: #GtkEntry
*
* #EphyLocationEntry implements the location bar in the main Epiphany window.
*/
#define EPHY_LOCATION_ENTRY_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_LOCATION_ENTRY, EphyLocationEntryPrivate))
struct _EphyLocationEntryPrivate
{
GIcon *lock_gicon;
GdkPixbuf *favicon;
GtkTreeModel *model;
GtkEntryCompletion *completion;
GSList *search_terms;
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_lock : 1;
guint show_favicon : 1;
};
static const GtkTargetEntry url_drag_types [] =
{
{ EPHY_DND_URL_TYPE, 0, 0 },
{ EPHY_DND_URI_LIST_TYPE, 0, 1 },
{ EPHY_DND_TEXT_TYPE, 0, 2 }
};
static gboolean ephy_location_entry_reset_internal (EphyLocationEntry *, gboolean);
static void textcell_data_func (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data);
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_LOCK_STOCK,
PROP_SHOW_LOCK,
PROP_SHOW_FAVICON
};
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_LOCK_STOCK:
ephy_location_entry_set_lock_stock (entry,
g_value_get_string (value));
break;
case PROP_SHOW_LOCK:
ephy_location_entry_set_show_lock (entry,
g_value_get_boolean (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);
EphyLocationEntryPrivate *priv = entry->priv;
g_free (priv->saved_text);
if (priv->favicon != NULL)
{
g_object_unref (priv->favicon);
}
if (priv->lock_gicon)
{
g_object_unref (priv->lock_gicon);
}
G_OBJECT_CLASS (ephy_location_entry_parent_class)->finalize (object);
}
static void
ephy_location_entry_class_init (EphyLocationEntryClass *klass)
{
GObjectClass *object_class = G_OBJECT_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;
/**
* EphyLocationEntry:location:
*
* The current location.
*/
g_object_class_install_property (object_class,
PROP_LOCATION,
g_param_spec_string ("location",
"Location",
"The current location",
"",
G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
/**
* EphyLocationEntry:favicon:
*
* The icon corresponding to the current location.
*/
g_object_class_install_property (object_class,
PROP_FAVICON,
g_param_spec_object ("favicon",
"Favicon",
"The icon corresponding to the current location",
GDK_TYPE_PIXBUF,
G_PARAM_WRITABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
/**
* EphyLocationEntry:lock-stock-id:
*
* Stock id of the security icon.
*/
g_object_class_install_property (object_class,
PROP_LOCK_STOCK,
g_param_spec_string ("lock-stock-id",
"Lock Stock ID",
"Stock id of the security icon",
NULL,
G_PARAM_WRITABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
/**
* EphyLocationEntry:show-lock:
*
* If we should show the security icon.
*/
g_object_class_install_property (object_class,
PROP_SHOW_LOCK,
g_param_spec_boolean ("show-lock",
"Show Lock",
"If we should show the security icon",
FALSE,
G_PARAM_WRITABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
g_object_class_install_property (object_class,
PROP_SHOW_FAVICON,
g_param_spec_boolean ("show-favicon",
"Show Favicon",
"Whether to show the favicon",
TRUE,
G_PARAM_WRITABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
/**
* 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,
G_STRUCT_OFFSET (EphyLocationEntryClass, user_changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
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,
G_STRUCT_OFFSET (EphyLocationEntryClass, lock_clicked),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
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,
G_STRUCT_OFFSET (EphyLocationEntryClass, get_location),
ephy_signal_accumulator_string, NULL,
g_cclosure_marshal_generic,
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,
G_STRUCT_OFFSET (EphyLocationEntryClass, get_title),
ephy_signal_accumulator_string, NULL,
g_cclosure_marshal_generic,
G_TYPE_STRING,
0,
G_TYPE_NONE);
g_type_class_add_private (object_class, sizeof (EphyLocationEntryPrivate));
}
static void
update_address_state (EphyLocationEntry *entry)
{
EphyLocationEntryPrivate *priv = entry->priv;
const char *text;
text = gtk_entry_get_text (GTK_ENTRY (entry));
priv->original_address = text != NULL &&
g_str_hash (text) == priv->hash;
}
static void
update_favicon (EphyLocationEntry *lentry)
{
EphyLocationEntryPrivate *priv = lentry->priv;
GtkEntry *entry = GTK_ENTRY (lentry);
/* Only show the favicon if the entry's text is the
* address of the current page.
*/
if (priv->show_favicon && priv->favicon != NULL && priv->original_address)
{
gtk_entry_set_icon_from_pixbuf (entry,
GTK_ENTRY_ICON_PRIMARY,
priv->favicon);
}
else if (priv->show_favicon)
{
/* 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
*/
gtk_entry_set_icon_from_icon_name (entry,
GTK_ENTRY_ICON_PRIMARY,
"text-html");
}
else
{
gtk_entry_set_icon_from_icon_name (entry,
GTK_ENTRY_ICON_PRIMARY,
NULL);
}
}
static void
editable_changed_cb (GtkEditable *editable,
EphyLocationEntry *entry)
{
EphyLocationEntryPrivate *priv = entry->priv;
update_address_state (entry);
if (priv->block_update == TRUE)
return;
else
{
priv->user_changed = TRUE;
priv->can_redo = FALSE;
}
g_signal_emit (entry, signals[USER_CHANGED], 0);
}
static gboolean
entry_key_press_cb (GtkEntry *entry,
GdkEventKey *event,
EphyLocationEntry *lentry)
{
guint state = event->state & gtk_accelerator_get_default_mod_mask ();
if (event->keyval == GDK_KEY_Escape && state == 0)
{
ephy_location_entry_reset_internal (lentry, TRUE);
/* don't return TRUE since we want to cancel the autocompletion popup too */
}
return FALSE;
}
static gboolean
entry_key_press_after_cb (GtkEntry *entry,
GdkEventKey *event,
EphyLocationEntry *lentry)
{
EphyLocationEntryPrivate *priv = lentry->priv;
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);
priv->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)) == strlen (string))
{
g_signal_emit_by_name (entry, "changed", 0);
return TRUE;
}
}
return FALSE;
}
static void
entry_activate_after_cb (GtkEntry *entry,
EphyLocationEntry *lentry)
{
EphyLocationEntryPrivate *priv = lentry->priv;
priv->user_changed = FALSE;
if (priv->needs_reset)
{
ephy_location_entry_reset_internal (lentry, TRUE);
priv->needs_reset = FALSE;
}
}
static gboolean
match_selected_cb (GtkEntryCompletion *completion,
GtkTreeModel *model,
GtkTreeIter *iter,
EphyLocationEntry *entry)
{
EphyLocationEntryPrivate *priv = entry->priv;
char *item = NULL;
guint state;
gtk_tree_model_get (model, iter,
priv->action_col, &item, -1);
if (item == NULL) return FALSE;
ephy_gui_get_current_event (NULL, &state, NULL);
priv->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)
{
EphyLocationEntryPrivate *priv = entry->priv;
priv->block_update = TRUE;
gtk_entry_set_text (GTK_ENTRY (entry), "");
priv->block_update = FALSE;
priv->user_changed = TRUE;
}
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)
{
EphyLocationEntryPrivate *priv = lentry->priv;
GtkWidget *clear_menuitem, *undo_menuitem, *redo_menuitem, *separator;
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);
undo_menuitem = gtk_menu_item_new_with_mnemonic (_("_Undo"));
gtk_widget_set_sensitive (undo_menuitem, priv->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, priv->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);
}
#define DRAG_ICON_LAYOUT_PADDING 2
#define DRAG_ICON_ICON_PADDING 4
#define DRAG_ICON_MAX_WIDTH_CHARS 32
static cairo_surface_t *
favicon_create_drag_surface (EphyLocationEntry *entry,
GtkWidget *widget)
{
EphyLocationEntryPrivate *priv = entry->priv;
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;
state = gtk_widget_get_state_flags (widget);
g_signal_emit (entry, signals[GET_LOCATION], 0, &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 (priv->favicon != NULL)
{
icon_width = gdk_pixbuf_get_width (priv->favicon);
icon_height = gdk_pixbuf_get_height (priv->favicon);
}
context = gtk_widget_get_pango_context (widget);
layout = pango_layout_new (context);
style = gtk_widget_get_style_context (GTK_WIDGET (entry));
gtk_style_context_get (style, GTK_STATE_FLAG_NORMAL,
"font", &font_desc, NULL);
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 (priv->favicon != NULL)
{
favicon_offset_x = icon_width + (2 * DRAG_ICON_ICON_PADDING);
}
surface_width = layout_width + favicon_offset_x +
(DRAG_ICON_LAYOUT_PADDING * 2);
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 (priv->favicon != NULL)
{
double x;
double y;
x = 1 + DRAG_ICON_LAYOUT_PADDING + DRAG_ICON_ICON_PADDING;
y = 1 + DRAG_ICON_LAYOUT_PADDING + (surface_height - icon_height) / 2;
gdk_cairo_set_source_pixbuf (cr, priv->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);
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);
GtkTargetList *targetlist;
LOG ("EphyLocationEntry constructing contents %p", lentry);
/* Favicon */
targetlist = gtk_target_list_new (url_drag_types,
G_N_ELEMENTS (url_drag_types));
gtk_entry_set_icon_drag_source (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
targetlist,
GDK_ACTION_ASK | GDK_ACTION_COPY | GDK_ACTION_LINK);
gtk_target_list_unref (targetlist);
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_entry_set_icon_activatable (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
TRUE);
gtk_entry_set_icon_activatable (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
TRUE);
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)
{
EphyLocationEntryPrivate *p;
LOG ("EphyLocationEntry initialising %p", le);
p = EPHY_LOCATION_ENTRY_GET_PRIVATE (le);
le->priv = p;
p->user_changed = FALSE;
p->block_update = FALSE;
p->saved_text = NULL;
p->show_lock = FALSE;
p->show_favicon = TRUE;
p->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));
}
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)
{
#ifdef HAVE_WEBKIT2
WebKitWebContext *context = webkit_web_context_get_default ();
if (helper->uri)
webkit_web_context_prefetch_dns (context, helper->uri->host);
#else
SoupSession *session = webkit_get_default_session ();
if (helper->uri)
soup_session_prefetch_dns (session, helper->uri->host, NULL, NULL, NULL);
#endif
helper->entry->priv->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->priv->dns_prefetch_handler)
g_source_remove (entry->priv->dns_prefetch_handler);
helper = g_slice_new0 (PrefetchHelper);
helper->entry = g_object_ref (entry);
helper->uri = uri;
entry->priv->dns_prefetch_handler =
g_timeout_add_full (G_PRIORITY_DEFAULT, interval,
(GSourceFunc) do_dns_prefetch, helper,
(GDestroyNotify) free_prefetch_helper);
}
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->priv->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->priv->block_update = TRUE;
gtk_entry_set_text (GTK_ENTRY (entry), url);
gtk_editable_set_position (GTK_EDITABLE (entry), -1);
le->priv->block_update = FALSE;
schedule_dns_prefetch (le, 250, (const gchar*) url);
g_free (url);
return TRUE;
}
static void
textcell_data_func (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
GtkWidget *entry;
EphyLocationEntryPrivate *priv;
PangoAttrList *list;
PangoAttribute *att;
char *ctext;
char *title;
char *url;
GtkStyleContext *style;
GdkRGBA color;
GValue text = { 0, };
entry = GTK_WIDGET (data);
priv = EPHY_LOCATION_ENTRY (data)->priv;
gtk_tree_model_get (tree_model, iter,
priv->text_col, &title,
priv->url_col, &url,
-1);
list = pango_attr_list_new ();
if (url)
{
/* Do not show internal ephy-about: protocol to users */
if (g_str_has_prefix (url, EPHY_ABOUT_SCHEME)) {
g_free (url);
url = g_strdup_printf ("about:%s", url + strlen (EPHY_ABOUT_SCHEME) + 1);
}
ctext = g_strdup_printf ("%s\n%s", title, url);
style = gtk_widget_get_style_context (entry);
gtk_style_context_get_color (style, GTK_STATE_FLAG_INSENSITIVE,
&color);
att = pango_attr_foreground_new
(color.red * 65535, color.green * 65535, color.blue * 65535);
att->start_index = strlen (title)+1;
pango_attr_list_insert (list, att);
g_free (title);
}
else
{
ctext = title;
}
g_object_set (cell, "attributes", list, NULL);
g_value_init (&text, G_TYPE_STRING);
g_value_take_string (&text, ctext);
g_object_set_property (G_OBJECT (cell), "text", &text);
g_value_unset (&text);
pango_attr_list_unref (list);
g_free (url);
}
static void
extracell_data_func (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
EphyLocationEntryPrivate *priv;
gboolean is_bookmark = FALSE;
GValue visible = { 0, };
priv = EPHY_LOCATION_ENTRY (data)->priv;
gtk_tree_model_get (tree_model, iter,
priv->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;
EphyLocationEntryPrivate *priv = entry->priv;
priv->text_col = text_col;
priv->action_col = action_col;
priv->keywords_col = keywords_col;
priv->relevance_col = relevance_col;
priv->url_col = url_col;
priv->extra_col = extra_col;
priv->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 2
#define ICON_PADDING_LEFT 5
#define ICON_CONTENT_WIDTH 16
#define ICON_PADDING_RIGHT 2
#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 = gtk_cell_renderer_text_new ();
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, 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);
/* 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);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (completion),
cell, textcell_data_func,
entry,
NULL);
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);
priv->completion = 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);
EphyLocationEntryPrivate *priv = entry->priv;
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;
}
else
{
text = "";
}
/* First record the new hash, then update the entry text */
priv->hash = g_str_hash (effective_text ? effective_text : text);
priv->block_update = TRUE;
gtk_entry_set_text (GTK_ENTRY (widget), effective_text ? effective_text : text);
priv->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)
{
EphyLocationEntryPrivate *priv = entry->priv;
return priv->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)
{
EphyLocationEntryPrivate *priv = entry->priv;
return priv->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)
{
EphyLocationEntryPrivate *priv = entry->priv;
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 (priv->saved_text);
priv->saved_text = g_strdup (old_text);
priv->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);
}
priv->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)
{
EphyLocationEntryPrivate *priv = entry->priv;
gtk_entry_set_text (GTK_ENTRY (entry), priv->saved_text);
priv->can_redo = FALSE;
priv->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)
{
EphyLocationEntryPrivate *priv = entry->priv;
if (priv->favicon != NULL)
{
g_object_unref (priv->favicon);
}
priv->favicon = pixbuf ? g_object_ref (pixbuf) : NULL;
update_favicon (entry);
}
void
ephy_location_entry_set_show_favicon (EphyLocationEntry *entry,
gboolean show_favicon)
{
EphyLocationEntryPrivate *priv;
g_return_if_fail (EPHY_IS_LOCATION_ENTRY (entry));
priv = entry->priv;
priv->show_favicon = show_favicon != FALSE;
update_favicon (entry);
}
/**
* ephy_location_entry_set_show_lock:
* @entry: an #EphyLocationEntry widget
* @show_lock: if @entry should show a lock icon indicating the security level
* of the page
*
* If @show_lock is TRUE, the location bar will show an icon reflecting the
* security level of the page, by default it's shown only in secure and
* insecure pages (insecure meaning secure pages with something broken in such
* security)
*
**/
void
ephy_location_entry_set_show_lock (EphyLocationEntry *entry,
gboolean show_lock)
{
EphyLocationEntryPrivate *priv;
g_return_if_fail (EPHY_IS_LOCATION_ENTRY (entry));
priv = entry->priv;
priv->show_lock = show_lock != FALSE;
gtk_entry_set_icon_from_gicon (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
show_lock ? priv->lock_gicon : NULL);
}
/**
* ephy_location_entry_set_lock_stock:
* @entry: an #EphyLocationEntry widget
* @stock_id: a stock_id from GTK+ stock icons
*
* Set the lock icon to be displayed, to actually show the icon see
* ephy_location_entry_set_show_lock.
*
**/
void
ephy_location_entry_set_lock_stock (EphyLocationEntry *entry,
const char *stock_id)
{
EphyLocationEntryPrivate *priv;
g_return_if_fail (EPHY_IS_LOCATION_ENTRY (entry));
priv = entry->priv;
if (priv->lock_gicon)
g_object_unref (priv->lock_gicon);
/* At the moment we basically only show two kinds of
* locks. Full/green for secure sites, Broken/red for sites
* that are supposed to be secure but have some issues in
* their security infrastructure (broken cert, etc). For
* everything else, nothing is shown.
*/
if (!stock_id || g_str_equal (stock_id, STOCK_LOCK_BROKEN))
priv->lock_gicon = g_themed_icon_new_with_default_fallbacks ("channel-insecure-symbolic");
else
priv->lock_gicon = g_themed_icon_new_with_default_fallbacks ("channel-secure-symbolic");
if (priv->show_lock)
gtk_entry_set_icon_from_gicon (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
priv->lock_gicon);
}
/**
* 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)
{
EphyLocationEntryPrivate *priv = entry->priv;
return priv->search_terms;
}