#include "gtkicontheme.h"
#include "gtkwidgetprivate.h"
#include "gtkstylecontextprivate.h"
+#include "gtktexthandleprivate.h"
+#include "gtkbubblewindowprivate.h"
+#include "gtktoolbar.h"
#include "a11y/gtkentryaccessible.h"
GdkWindow *text_area;
PangoLayout *cached_layout;
+ PangoAttrList *attrs;
gchar *im_module;
gchar *placeholder_text;
+ GtkBubbleWindow *bubble_window;
+ GtkTextHandle *text_handle;
+ GtkWidget *selection_bubble;
+ guint selection_bubble_timeout_id;
+
gfloat xalign;
gint ascent; /* font ascent in pango units */
guint select_words : 1;
guint select_lines : 1;
guint truncate_multiline : 1;
+ guint cursor_handle_dragged : 1;
+ guint selection_handle_dragged : 1;
+ guint populate_all : 1;
};
struct _EntryIconInfo
PROP_PLACEHOLDER_TEXT,
PROP_COMPLETION,
PROP_INPUT_PURPOSE,
- PROP_INPUT_HINTS
+ PROP_INPUT_HINTS,
+ PROP_ATTRIBUTES,
+ PROP_POPULATE_ALL
};
static guint signals[LAST_SIGNAL] = { 0 };
+static gboolean test_touchscreen = FALSE;
typedef enum {
CURSOR_STANDARD,
gint *y,
gint *width,
gint *height);
+static void gtk_entry_get_frame_size (GtkEntry *entry,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height);
static void get_text_area_size (GtkEntry *entry,
gint *x,
gint *y,
static void gtk_entry_update_cached_style_values(GtkEntry *entry);
static gboolean get_middle_click_paste (GtkEntry *entry);
+/* GtkTextHandle handlers */
+static void gtk_entry_handle_dragged (GtkTextHandle *handle,
+ GtkTextHandlePosition pos,
+ gint x,
+ gint y,
+ GtkEntry *entry);
+static void gtk_entry_handle_drag_finished (GtkTextHandle *handle,
+ GtkTextHandlePosition pos,
+ GtkEntry *entry);
+
+static void gtk_entry_selection_bubble_popup_set (GtkEntry *entry);
+static void gtk_entry_selection_bubble_popup_unset (GtkEntry *entry);
static void begin_change (GtkEntry *entry);
static void end_change (GtkEntry *entry);
class->toggle_overwrite = gtk_entry_toggle_overwrite;
class->activate = gtk_entry_real_activate;
class->get_text_area_size = gtk_entry_get_text_area_size;
+ class->get_frame_size = gtk_entry_get_frame_size;
quark_inner_border = g_quark_from_static_string ("gtk-entry-inner-border");
quark_password_hint = g_quark_from_static_string ("gtk-entry-password-hint");
GTK_INPUT_HINT_NONE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ /**
+ * GtkEntry:attributes:
+ *
+ * A list of Pango attributes to apply to the text of the entry.
+ *
+ * This is mainly useful to change the size or weight of the text.
+ *
+ * Since: 3.6
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_ATTRIBUTES,
+ g_param_spec_boxed ("attributes",
+ P_("Attributes"),
+ P_("A list of style attributes to apply to the text of the label"),
+ PANGO_TYPE_ATTR_LIST,
+ GTK_PARAM_READWRITE));
+ /** GtkEntry:populate-all:
+ *
+ * If ::populate-all is %TRUE, the #GtkEntry::populate-popup
+ * signal is also emitted for touch popups.
+ *
+ * Since: 3.8
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_POPULATE_ALL,
+ g_param_spec_boolean ("populate-all",
+ P_("Populate all"),
+ P_("Whether to emit ::populate-popup for touch popups"),
+ FALSE,
+ GTK_PARAM_READWRITE));
+
/**
* GtkEntry:icon-prelight:
*
/**
* GtkEntry::populate-popup:
* @entry: The entry on which the signal is emitted
- * @menu: the menu that is being populated
+ * @popup: the container that is being populated
*
- * The ::populate-popup signal gets emitted before showing the
- * context menu of the entry.
+ * The ::populate-popup signal gets emitted before showing the
+ * context menu of the entry.
*
* If you need to add items to the context menu, connect
- * to this signal and append your menuitems to the @menu.
+ * to this signal and append your items to the @widget, which
+ * will be a #GtkMenu in this case.
+ *
+ * If #GtkEntry::populate-all is %TRUE, this signal will
+ * also be emitted to populate touch popups. In this case,
+ * @widget will be a different container, e.g. a #GtkToolbar.
+ * The signal handler should not make assumptions about the
+ * type of @widget.
*/
signals[POPULATE_POPUP] =
g_signal_new (I_("populate-popup"),
NULL, NULL,
_gtk_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
- GTK_TYPE_MENU);
+ GTK_TYPE_WIDGET);
/* Action signals */
G_PARAM_DEPRECATED));
g_type_class_add_private (gobject_class, sizeof (GtkEntryPrivate));
+ test_touchscreen = g_getenv ("GTK_TEST_TOUCHSCREEN") != NULL;
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_ENTRY_ACCESSIBLE);
}
gtk_entry_set_input_hints (entry, g_value_get_flags (value));
break;
+ case PROP_ATTRIBUTES:
+ gtk_entry_set_attributes (entry, g_value_get_boxed (value));
+ break;
+
+ case PROP_POPULATE_ALL:
+ entry->priv->populate_all = g_value_get_boolean (value);
+ break;
+
case PROP_SCROLL_OFFSET:
case PROP_CURSOR_POSITION:
default:
g_value_set_flags (value, gtk_entry_get_input_hints (entry));
break;
+ case PROP_ATTRIBUTES:
+ g_value_set_boxed (value, priv->attrs);
+ break;
+
+ case PROP_POPULATE_ALL:
+ g_value_set_boolean (value, priv->populate_all);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
gtk_style_context_add_class (context, GTK_STYLE_CLASS_ENTRY);
gtk_entry_update_cached_style_values (entry);
+
+ priv->text_handle = _gtk_text_handle_new (GTK_WIDGET (entry));
+ g_signal_connect (priv->text_handle, "handle-dragged",
+ G_CALLBACK (gtk_entry_handle_dragged), entry);
+ g_signal_connect (priv->text_handle, "drag-finished",
+ G_CALLBACK (gtk_entry_handle_drag_finished), entry);
}
static void
if (priv->recompute_idle)
g_source_remove (priv->recompute_idle);
+ if (priv->selection_bubble)
+ gtk_widget_destroy (priv->selection_bubble);
+
+ g_object_unref (priv->text_handle);
g_free (priv->placeholder_text);
g_free (priv->im_module);
icon_info->window = gdk_window_new (gtk_widget_get_window (widget),
&attributes,
attributes_mask);
- gdk_window_set_user_data (icon_info->window, widget);
+ gtk_widget_register_window (widget, icon_info->window);
gtk_widget_queue_resize (widget);
}
EntryIconInfo *icon_info = NULL;
gint i;
+ _gtk_text_handle_set_mode (priv->text_handle,
+ GTK_TEXT_HANDLE_MODE_NONE);
+
for (i = 0; i < MAX_ICONS; i++)
{
if ((icon_info = priv->icons[i]) != NULL)
&attributes,
attributes_mask);
- gdk_window_set_user_data (priv->text_area, entry);
+ gtk_widget_register_window (widget, priv->text_area);
if (attributes_mask & GDK_WA_CURSOR)
g_object_unref (attributes.cursor);
gtk_entry_adjust_scroll (entry);
gtk_entry_update_primary_selection (entry);
-
+ _gtk_text_handle_set_relative_to (priv->text_handle, priv->text_area);
/* If the icon positions are already setup, create their windows.
* Otherwise if they don't exist yet, then construct_icon_info()
gtk_entry_reset_layout (entry);
gtk_im_context_set_client_window (priv->im_context, NULL);
+ _gtk_text_handle_set_relative_to (priv->text_handle, NULL);
clipboard = gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY);
if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (entry))
if (priv->text_area)
{
- gdk_window_set_user_data (priv->text_area, NULL);
+ gtk_widget_unregister_window (widget, priv->text_area);
gdk_window_destroy (priv->text_area);
priv->text_area = NULL;
}
{
if (icon_info->window != NULL)
{
+ gtk_widget_unregister_window (widget, icon_info->window);
gdk_window_destroy (icon_info->window);
icon_info->window = NULL;
}
PangoFontMetrics *metrics;
GtkBorder borders;
PangoContext *context;
- GtkStyleContext *style_context;
- GtkStateFlags state;
gint icon_widths = 0;
gint icon_width, i;
gint width;
context = gtk_widget_get_pango_context (widget);
- style_context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
-
metrics = pango_context_get_metrics (context,
- gtk_style_context_get_font (style_context, state),
+ pango_context_get_font_description (context),
pango_context_get_language (context));
_gtk_entry_get_borders (entry, &borders);
GtkEntryPrivate *priv = entry->priv;
PangoFontMetrics *metrics;
GtkBorder borders;
- GtkStyleContext *style_context;
- GtkStateFlags state;
PangoContext *context;
gint height;
+ PangoLayout *layout;
+ layout = gtk_entry_ensure_layout (entry, TRUE);
context = gtk_widget_get_pango_context (widget);
- style_context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
-
metrics = pango_context_get_metrics (context,
- gtk_style_context_get_font (style_context, state),
+ pango_context_get_font_description (context),
pango_context_get_language (context));
priv->ascent = pango_font_metrics_get_ascent (metrics);
priv->descent = pango_font_metrics_get_descent (metrics);
+ pango_font_metrics_unref (metrics);
_gtk_entry_get_borders (entry, &borders);
+ pango_layout_get_pixel_size (layout, NULL, &height);
- height = PANGO_PIXELS (priv->ascent + priv->descent) + borders.top + borders.bottom;
-
- pango_font_metrics_unref (metrics);
+ height += borders.top + borders.bottom;
*minimum = height;
*natural = height;
static void
-get_frame_size (GtkEntry *entry,
- gboolean relative_to_window,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
+gtk_entry_get_frame_size (GtkEntry *entry,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height)
{
GtkEntryPrivate *priv = entry->priv;
GtkAllocation allocation;
gtk_widget_get_allocation (widget, &allocation);
if (x)
- *x = relative_to_window ? allocation.x : 0;
+ *x = allocation.x;
if (y)
{
else
*y = (allocation.height - req_height) / 2;
- if (relative_to_window)
- *y += allocation.y;
+ *y += allocation.y;
}
if (width)
}
}
+static void
+get_frame_size (GtkEntry *entry,
+ gboolean relative_to_window,
+ gint *x,
+ gint *y,
+ gint *width,
+ gint *height)
+{
+ GtkEntryClass *class;
+ GtkWidget *widget = GTK_WIDGET (entry);
+
+ g_return_if_fail (GTK_IS_ENTRY (entry));
+
+ class = GTK_ENTRY_GET_CLASS (entry);
+
+ if (class->get_frame_size)
+ class->get_frame_size (entry, x, y, width, height);
+
+ if (!relative_to_window)
+ {
+ GtkAllocation allocation;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ if (x)
+ *x -= allocation.x;
+ if (y)
+ *y -= allocation.y;
+ }
+}
+
static void
gtk_entry_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
GtkEntryPrivate *priv = entry->priv;
int i;
- context = gtk_widget_get_style_context (widget);
+ if (gtk_cairo_should_draw_window (cr,
+ gtk_widget_get_window (widget)))
+ {
+ context = gtk_widget_get_style_context (widget);
- /* Draw entry_bg, shadow, progress and focus */
- gtk_entry_draw_frame (widget, context, cr);
+ /* Draw entry_bg, shadow, progress and focus */
+ gtk_entry_draw_frame (widget, context, cr);
- /* Draw text and cursor */
- cairo_save (cr);
+ /* Draw text and cursor */
+ cairo_save (cr);
- gtk_cairo_transform_to_window (cr, widget, priv->text_area);
+ gtk_cairo_transform_to_window (cr, widget, priv->text_area);
- if (priv->dnd_position != -1)
- gtk_entry_draw_cursor (GTK_ENTRY (widget), cr, CURSOR_DND);
-
- gtk_entry_draw_text (GTK_ENTRY (widget), cr);
+ if (priv->dnd_position != -1)
+ gtk_entry_draw_cursor (GTK_ENTRY (widget), cr, CURSOR_DND);
- /* When no text is being displayed at all, don't show the cursor */
- if (gtk_entry_get_display_mode (entry) != DISPLAY_BLANK &&
- gtk_widget_has_focus (widget) &&
- priv->selection_bound == priv->current_pos && priv->cursor_visible)
- gtk_entry_draw_cursor (GTK_ENTRY (widget), cr, CURSOR_STANDARD);
+ gtk_entry_draw_text (GTK_ENTRY (widget), cr);
- cairo_restore (cr);
+ /* When no text is being displayed at all, don't show the cursor */
+ if (gtk_entry_get_display_mode (entry) != DISPLAY_BLANK &&
+ gtk_widget_has_focus (widget) &&
+ priv->selection_bound == priv->current_pos && priv->cursor_visible)
+ gtk_entry_draw_cursor (GTK_ENTRY (widget), cr, CURSOR_STANDARD);
- /* Draw icons */
- for (i = 0; i < MAX_ICONS; i++)
- {
- EntryIconInfo *icon_info = priv->icons[i];
+ cairo_restore (cr);
- if (icon_info != NULL)
- draw_icon (widget, cr, i);
+ /* Draw icons */
+ for (i = 0; i < MAX_ICONS; i++)
+ {
+ EntryIconInfo *icon_info = priv->icons[i];
+
+ if (icon_info != NULL)
+ draw_icon (widget, cr, i);
+ }
}
return FALSE;
g_free (ranges);
return retval;
}
-
+
+static void
+gtk_entry_move_handle (GtkEntry *entry,
+ GtkTextHandlePosition pos,
+ gint x,
+ gint y,
+ gint height)
+{
+ GtkEntryPrivate *priv = entry->priv;
+
+ if (!_gtk_text_handle_get_is_dragged (priv->text_handle, pos) &&
+ (x < 0 || x > gdk_window_get_width (priv->text_area)))
+ {
+ /* Hide the handle if it's not being manipulated
+ * and fell outside of the visible text area.
+ */
+ _gtk_text_handle_set_visible (priv->text_handle, pos, FALSE);
+ }
+ else
+ {
+ GdkRectangle rect;
+
+ rect.x = CLAMP (x, 0, gdk_window_get_width (priv->text_area));
+ rect.y = y;
+ rect.width = 1;
+ rect.height = height;
+
+ _gtk_text_handle_set_visible (priv->text_handle, pos, TRUE);
+ _gtk_text_handle_set_position (priv->text_handle, pos, &rect);
+ }
+}
+
+static gint
+gtk_entry_get_selection_bound_location (GtkEntry *entry)
+{
+ GtkEntryPrivate *priv = entry->priv;
+ PangoLayout *layout;
+ PangoRectangle pos;
+ gint x;
+ const gchar *text;
+ gint index;
+
+ layout = gtk_entry_ensure_layout (entry, FALSE);
+ text = pango_layout_get_text (layout);
+ index = g_utf8_offset_to_pointer (text, priv->selection_bound) - text;
+ pango_layout_index_to_pos (layout, index, &pos);
+
+ if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_RTL)
+ x = (pos.x + pos.width) / PANGO_SCALE;
+ else
+ x = pos.x / PANGO_SCALE;
+
+ return x;
+}
+
+static void
+gtk_entry_update_handles (GtkEntry *entry,
+ GtkTextHandleMode mode)
+{
+ GtkEntryPrivate *priv = entry->priv;
+ gint strong_x, height;
+ gint cursor, bound;
+
+ _gtk_text_handle_set_mode (priv->text_handle, mode);
+
+ /* Wait for recomputation before repositioning */
+ if (priv->recompute_idle != 0)
+ return;
+
+ height = gdk_window_get_height (priv->text_area);
+
+ gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, NULL);
+ cursor = strong_x - priv->scroll_offset;
+
+ if (mode == GTK_TEXT_HANDLE_MODE_SELECTION)
+ {
+ gint start, end;
+
+ bound = gtk_entry_get_selection_bound_location (entry) - priv->scroll_offset;
+
+ if (priv->selection_bound > priv->current_pos)
+ {
+ start = cursor;
+ end = bound;
+ }
+ else
+ {
+ start = bound;
+ end = cursor;
+ }
+
+ /* Update start selection bound */
+ gtk_entry_move_handle (entry, GTK_TEXT_HANDLE_POSITION_SELECTION_START,
+ start, 0, height);
+ gtk_entry_move_handle (entry, GTK_TEXT_HANDLE_POSITION_SELECTION_END,
+ end, 0, height);
+ }
+ else
+ gtk_entry_move_handle (entry, GTK_TEXT_HANDLE_POSITION_CURSOR,
+ cursor, 0, height);
+}
+
static gint
gtk_entry_button_press (GtkWidget *widget,
GdkEventButton *event)
gint sel_start, sel_end;
gint i;
+ gtk_entry_selection_bubble_popup_unset (entry);
+
for (i = 0; i < MAX_ICONS; i++)
{
icon_info = priv->icons[i];
else if (event->button == GDK_BUTTON_PRIMARY)
{
gboolean have_selection = gtk_editable_get_selection_bounds (editable, &sel_start, &sel_end);
+ gboolean is_touchscreen;
+ GdkDevice *source;
+
+ source = gdk_event_get_source_device ((GdkEvent *) event);
+ is_touchscreen = test_touchscreen ||
+ gdk_device_get_source (source) == GDK_SOURCE_TOUCHSCREEN;
priv->select_words = FALSE;
priv->select_lines = FALSE;
priv->drag_start_y = event->y;
}
else
- gtk_editable_set_position (editable, tmp_pos);
+ {
+ gtk_editable_set_position (editable, tmp_pos);
+
+ if (is_touchscreen)
+ gtk_entry_update_handles (entry, GTK_TEXT_HANDLE_MODE_CURSOR);
+ }
break;
case GDK_2BUTTON_PRESS:
priv->in_drag = FALSE;
priv->select_words = TRUE;
gtk_entry_select_word (entry);
+
+ if (is_touchscreen)
+ gtk_entry_update_handles (entry, GTK_TEXT_HANDLE_MODE_SELECTION);
break;
case GDK_3BUTTON_PRESS:
priv->in_drag = FALSE;
priv->select_lines = TRUE;
gtk_entry_select_line (entry);
+ if (is_touchscreen)
+ gtk_entry_update_handles (entry, GTK_TEXT_HANDLE_MODE_SELECTION);
break;
default:
GtkEntry *entry = GTK_ENTRY (widget);
GtkEntryPrivate *priv = entry->priv;
EntryIconInfo *icon_info = NULL;
+ gboolean is_touchscreen;
+ GdkDevice *source;
gint i;
for (i = 0; i < MAX_ICONS; i++)
if (event->window != priv->text_area || priv->button != event->button)
return FALSE;
+ source = gdk_event_get_source_device ((GdkEvent *) event);
+ is_touchscreen = (test_touchscreen ||
+ gdk_device_get_source (source) == GDK_SOURCE_TOUCHSCREEN);
+
if (priv->in_drag)
{
gint tmp_pos = gtk_entry_find_position (entry, priv->drag_start_x);
gtk_editable_set_position (GTK_EDITABLE (entry), tmp_pos);
+ if (is_touchscreen)
+ gtk_entry_update_handles (entry, GTK_TEXT_HANDLE_MODE_CURSOR);
+
priv->in_drag = 0;
}
+ else if (is_touchscreen)
+ gtk_entry_selection_bubble_popup_set (entry);
priv->button = 0;
priv->device = NULL;
}
else
{
+ GdkInputSource input_source;
+ GdkDevice *source;
+ guint length;
+
+ length = gtk_entry_buffer_get_length (get_buffer (entry));
+
if (event->y < 0)
tmp_pos = 0;
else if (event->y >= gdk_window_get_height (priv->text_area))
- tmp_pos = gtk_entry_buffer_get_length (get_buffer (entry));
+ tmp_pos = length;
else
tmp_pos = gtk_entry_find_position (entry, event->x + priv->scroll_offset);
+ source = gdk_event_get_source_device ((GdkEvent *) event);
+ input_source = gdk_device_get_source (source);
+
if (priv->select_words)
{
gint min, max;
if (priv->current_pos != max)
pos = min;
}
-
+
gtk_entry_set_positions (entry, pos, bound);
}
else
gtk_entry_set_positions (entry, tmp_pos, -1);
+
+ /* Update touch handles' position */
+ if (test_touchscreen || input_source == GDK_SOURCE_TOUCHSCREEN)
+ gtk_entry_update_handles (entry,
+ (priv->current_pos == priv->selection_bound) ?
+ GTK_TEXT_HANDLE_MODE_CURSOR :
+ GTK_TEXT_HANDLE_MODE_SELECTION);
}
-
+
return TRUE;
}
gtk_entry_reset_blink_time (entry);
gtk_entry_pend_cursor_blink (entry);
+ gtk_entry_selection_bubble_popup_unset (entry);
+
+ if (!event->send_event)
+ _gtk_text_handle_set_mode (priv->text_handle,
+ GTK_TEXT_HANDLE_MODE_NONE);
+
if (priv->editable)
{
if (gtk_im_context_filter_keypress (priv->im_context, event))
GtkEntryCompletion *completion;
GdkKeymap *keymap;
+ gtk_entry_selection_bubble_popup_unset (entry);
+ _gtk_text_handle_set_mode (priv->text_handle,
+ GTK_TEXT_HANDLE_MODE_NONE);
+
gtk_widget_queue_draw (widget);
keymap = gdk_keymap_get_for_display (gtk_widget_get_display (widget));
gtk_entry_update_cached_style_values (entry);
- gtk_entry_recompute (entry);
-
icon_theme_changed (entry);
}
{
gtk_widget_error_bell (GTK_WIDGET (entry));
}
+
+ gtk_entry_selection_bubble_popup_unset (entry);
}
static void
if (gtk_widget_has_screen (GTK_WIDGET (entry)))
{
+ GtkTextHandleMode handle_mode;
+
gtk_entry_adjust_scroll (entry);
gtk_widget_queue_draw (GTK_WIDGET (entry));
update_im_cursor_location (entry);
+
+ handle_mode = _gtk_text_handle_get_mode (priv->text_handle);
+
+ if (handle_mode != GTK_TEXT_HANDLE_MODE_NONE)
+ gtk_entry_update_handles (entry, handle_mode);
}
return FALSE;
{
GtkEntryPrivate *priv = entry->priv;
GtkWidget *widget = GTK_WIDGET (entry);
- PangoLayout *layout = gtk_widget_create_pango_layout (widget, NULL);
- PangoAttrList *tmp_attrs = pango_attr_list_new ();
- gboolean placeholder_layout = show_placeholder_text (entry);
+ PangoLayout *layout;
+ PangoAttrList *tmp_attrs;
+ gboolean placeholder_layout;
gchar *preedit_string = NULL;
gint preedit_length = 0;
gchar *display;
guint n_bytes;
+ layout = gtk_widget_create_pango_layout (widget, NULL);
pango_layout_set_single_paragraph_mode (layout, TRUE);
+ tmp_attrs = priv->attrs ? pango_attr_list_ref (priv->attrs)
+ : pango_attr_list_new ();
+
+ placeholder_layout = show_placeholder_text (entry);
display = placeholder_layout ? g_strdup (priv->placeholder_text) : _gtk_entry_get_display_text (entry, 0, -1);
n_bytes = strlen (display);
gint cursor_index = g_utf8_offset_to_pointer (display, priv->current_pos) - display;
g_string_insert (tmp_string, cursor_index, preedit_string);
-
pango_layout_set_text (layout, tmp_string->str, tmp_string->len);
-
pango_attr_list_splice (tmp_attrs, preedit_attrs,
cursor_index, preedit_length);
-
g_string_free (tmp_string, TRUE);
}
else
layout = gtk_entry_ensure_layout (entry, TRUE);
- gtk_entry_get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
+ get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
area_height = PANGO_SCALE * area_height;
line = pango_layout_get_lines_readonly (layout)->data;
}
}
+static void
+gtk_entry_handle_dragged (GtkTextHandle *handle,
+ GtkTextHandlePosition pos,
+ gint x,
+ gint y,
+ GtkEntry *entry)
+{
+ gint cursor_pos, selection_bound_pos, tmp_pos;
+ GtkEntryPrivate *priv = entry->priv;
+ GtkTextHandleMode mode;
+ gint *min, *max;
+
+ gtk_entry_selection_bubble_popup_unset (entry);
+
+ cursor_pos = priv->current_pos;
+ selection_bound_pos = priv->selection_bound;
+ mode = _gtk_text_handle_get_mode (handle);
+ tmp_pos = gtk_entry_find_position (entry, x + priv->scroll_offset);
+
+ if (mode == GTK_TEXT_HANDLE_MODE_CURSOR ||
+ cursor_pos >= selection_bound_pos)
+ {
+ max = &cursor_pos;
+ min = &selection_bound_pos;
+ }
+ else
+ {
+ max = &selection_bound_pos;
+ min = &cursor_pos;
+ }
+
+ if (pos == GTK_TEXT_HANDLE_POSITION_SELECTION_END)
+ {
+ if (mode == GTK_TEXT_HANDLE_MODE_SELECTION)
+ {
+ gint min_pos;
+
+ min_pos = MAX (*min + 1, 0);
+ tmp_pos = MAX (tmp_pos, min_pos);
+ }
+
+ *max = tmp_pos;
+ }
+ else
+ {
+ if (mode == GTK_TEXT_HANDLE_MODE_SELECTION)
+ {
+ gint max_pos;
+
+ max_pos = *max - 1;
+ *min = MIN (tmp_pos, max_pos);
+ }
+ }
+
+ if (cursor_pos != priv->current_pos ||
+ selection_bound_pos != priv->selection_bound)
+ {
+ if (mode == GTK_TEXT_HANDLE_MODE_CURSOR)
+ gtk_entry_set_positions (entry, cursor_pos, cursor_pos);
+ else
+ gtk_entry_set_positions (entry, cursor_pos, selection_bound_pos);
+
+ gtk_entry_update_handles (entry, mode);
+ }
+}
+
+static void
+gtk_entry_handle_drag_finished (GtkTextHandle *handle,
+ GtkTextHandlePosition pos,
+ GtkEntry *entry)
+{
+ gtk_entry_selection_bubble_popup_set (entry);
+}
+
+
/**
* gtk_entry_reset_im_context:
* @entry: a #GtkEntry
}
}
+static gboolean
+gtk_entry_get_is_selection_handle_dragged (GtkEntry *entry)
+{
+ GtkEntryPrivate *priv = entry->priv;
+ GtkTextHandlePosition pos;
+
+ if (_gtk_text_handle_get_mode (priv->text_handle) != GTK_TEXT_HANDLE_MODE_SELECTION)
+ return FALSE;
+
+ if (priv->current_pos >= priv->selection_bound)
+ pos = GTK_TEXT_HANDLE_POSITION_SELECTION_START;
+ else
+ pos = GTK_TEXT_HANDLE_POSITION_SELECTION_END;
+
+ return _gtk_text_handle_get_is_dragged (priv->text_handle, pos);
+}
+
static void
gtk_entry_adjust_scroll (GtkEntry *entry)
{
PangoLayout *layout;
PangoLayoutLine *line;
PangoRectangle logical_rect;
+ GtkTextHandleMode handle_mode;
if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
return;
priv->scroll_offset = CLAMP (priv->scroll_offset, min_offset, max_offset);
- /* And make sure cursors are on screen. Note that the cursor is
- * actually drawn one pixel into the INNER_BORDER space on
- * the right, when the scroll is at the utmost right. This
- * looks better to to me than confining the cursor inside the
- * border entirely, though it means that the cursor gets one
- * pixel closer to the edge of the widget on the right than
- * on the left. This might need changing if one changed
- * INNER_BORDER from 2 to 1, as one would do on a
- * small-screen-real-estate display.
- *
- * We always make sure that the strong cursor is on screen, and
- * put the weak cursor on screen if possible.
- */
+ if (gtk_entry_get_is_selection_handle_dragged (entry))
+ {
+ /* The text handle corresponding to the selection bound is
+ * being dragged, ensure it stays onscreen even if we scroll
+ * cursors away, this is so both handles can cause content
+ * to scroll.
+ */
+ strong_x = weak_x = gtk_entry_get_selection_bound_location (entry);
+ }
+ else
+ {
+ /* And make sure cursors are on screen. Note that the cursor is
+ * actually drawn one pixel into the INNER_BORDER space on
+ * the right, when the scroll is at the utmost right. This
+ * looks better to to me than confining the cursor inside the
+ * border entirely, though it means that the cursor gets one
+ * pixel closer to the edge of the widget on the right than
+ * on the left. This might need changing if one changed
+ * INNER_BORDER from 2 to 1, as one would do on a
+ * small-screen-real-estate display.
+ *
+ * We always make sure that the strong cursor is on screen, and
+ * put the weak cursor on screen if possible.
+ */
+ gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, &weak_x);
+ }
- gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, &weak_x);
-
strong_xoffset = strong_x - priv->scroll_offset;
if (strong_xoffset < 0)
}
g_object_notify (G_OBJECT (entry), "scroll-offset");
+
+ handle_mode = _gtk_text_handle_get_mode (priv->text_handle);
+
+ if (handle_mode != GTK_TEXT_HANDLE_MODE_NONE)
+ gtk_entry_update_handles (entry, handle_mode);
}
static void
GtkAdjustment *adjustment;
PangoContext *context;
PangoFontMetrics *metrics;
- GtkStyleContext *style_context;
- GtkStateFlags state;
GtkBorder borders;
gint x, layout_x;
gint char_width;
gtk_widget_get_allocation (widget, &allocation);
- /* Cursor position, layout offset, border width, and widget allocation */
+ /* Cursor/char position, layout offset, border width, and widget allocation */
gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &x, NULL);
get_layout_position (entry, &layout_x, NULL);
_gtk_entry_get_borders (entry, &borders);
/* Approximate width of a char, so user can see what is ahead/behind */
context = gtk_widget_get_pango_context (widget);
- style_context = gtk_widget_get_style_context (widget);
- state = gtk_widget_get_state_flags (widget);
metrics = pango_context_get_metrics (context,
- gtk_style_context_get_font (style_context, state),
+ pango_context_get_font_description (context),
pango_context_get_language (context));
char_width = pango_font_metrics_get_approximate_char_width (metrics) / PANGO_SCALE;
icon_info->tooltip = tooltip ? g_markup_escape_text (tooltip, -1) : NULL;
ensure_has_tooltip (entry);
+
+ g_object_notify (G_OBJECT (entry),
+ icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-tooltip-text" : "secondary-icon-tooltip-text");
}
/**
return TRUE;
}
+static void
+activate_bubble_cb (GtkWidget *item,
+ GtkEntry *entry)
+{
+ const gchar *signal = g_object_get_data (G_OBJECT (item), "gtk-signal");
+ g_signal_emit_by_name (entry, signal);
+ _gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (entry->priv->selection_bubble));
+}
+
+static void
+append_bubble_action (GtkEntry *entry,
+ GtkWidget *toolbar,
+ const gchar *stock_id,
+ const gchar *signal,
+ gboolean sensitive)
+{
+ GtkToolItem *item = gtk_tool_button_new_from_stock (stock_id);
+ g_object_set_data (G_OBJECT (item), I_("gtk-signal"), (char *)signal);
+ g_signal_connect (item, "clicked", G_CALLBACK (activate_bubble_cb), entry);
+ gtk_widget_set_sensitive (GTK_WIDGET (item), sensitive);
+ gtk_widget_show (GTK_WIDGET (item));
+ gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+}
+
+static void
+bubble_targets_received (GtkClipboard *clipboard,
+ GtkSelectionData *data,
+ gpointer user_data)
+{
+ GtkEntry *entry = user_data;
+ GtkEntryPrivate *priv = entry->priv;
+ cairo_rectangle_int_t rect;
+ GtkAllocation allocation;
+ gint start_x, end_x;
+ gboolean has_selection;
+ gboolean has_clipboard;
+ DisplayMode mode;
+ GtkWidget *toolbar;
+
+ has_selection = gtk_editable_get_selection_bounds (GTK_EDITABLE (entry),
+ NULL, NULL);
+ if (!has_selection && !priv->editable)
+ {
+ priv->selection_bubble_timeout_id = 0;
+ return;
+ }
+
+ if (priv->selection_bubble)
+ gtk_widget_destroy (priv->selection_bubble);
+
+ priv->selection_bubble = _gtk_bubble_window_new ();
+ toolbar = GTK_WIDGET (gtk_toolbar_new ());
+ gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_TEXT);
+ gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
+ gtk_widget_show (toolbar);
+ gtk_container_add (GTK_CONTAINER (priv->selection_bubble), toolbar);
+
+ has_clipboard = gtk_selection_data_targets_include_text (data);
+ mode = gtk_entry_get_display_mode (entry);
+
+ append_bubble_action (entry, toolbar, GTK_STOCK_CUT, "cut-clipboard",
+ priv->editable && has_selection && mode == DISPLAY_NORMAL);
+
+ append_bubble_action (entry, toolbar, GTK_STOCK_COPY, "copy-clipboard",
+ has_selection && mode == DISPLAY_NORMAL);
+
+ append_bubble_action (entry, toolbar, GTK_STOCK_PASTE, "paste-clipboard",
+ priv->editable && has_clipboard);
+
+ if (priv->populate_all)
+ g_signal_emit (entry, signals[POPULATE_POPUP], 0, toolbar);
+
+ gtk_widget_get_allocation (GTK_WIDGET (entry), &allocation);
+
+ gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &start_x, NULL);
+
+ start_x -= priv->scroll_offset;
+ start_x = CLAMP (start_x, 0, gdk_window_get_width (priv->text_area));
+
+ rect.y = 0;
+ rect.height = gdk_window_get_height (priv->text_area);
+
+ if (has_selection)
+ {
+ end_x = gtk_entry_get_selection_bound_location (entry) - priv->scroll_offset;
+ end_x = CLAMP (end_x, 0, gdk_window_get_width (priv->text_area));
+
+ rect.x = MIN (start_x, end_x);
+ rect.width = MAX (start_x, end_x) - rect.x;
+ }
+ else
+ {
+ rect.x = start_x;
+ rect.width = 0;
+ }
+
+ _gtk_bubble_window_popup (GTK_BUBBLE_WINDOW (priv->selection_bubble),
+ priv->text_area, &rect, GTK_POS_TOP);
+
+ priv->selection_bubble_timeout_id = 0;
+}
+
+static gboolean
+gtk_entry_selection_bubble_popup_cb (gpointer user_data)
+{
+ GtkEntry *entry = user_data;
+
+ gtk_clipboard_request_contents (gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_CLIPBOARD),
+ gdk_atom_intern_static_string ("TARGETS"),
+ bubble_targets_received,
+ entry);
+ return G_SOURCE_REMOVE;
+}
+
+static void
+gtk_entry_selection_bubble_popup_unset (GtkEntry *entry)
+{
+ GtkEntryPrivate *priv;
+
+ priv = entry->priv;
+
+ if (priv->selection_bubble)
+ _gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (priv->selection_bubble));
+
+ if (priv->selection_bubble_timeout_id)
+ {
+ g_source_remove (priv->selection_bubble_timeout_id);
+ priv->selection_bubble_timeout_id = 0;
+ }
+}
+
+static void
+gtk_entry_selection_bubble_popup_set (GtkEntry *entry)
+{
+ GtkEntryPrivate *priv;
+
+ priv = entry->priv;
+
+ if (priv->selection_bubble_timeout_id)
+ g_source_remove (priv->selection_bubble_timeout_id);
+
+ priv->selection_bubble_timeout_id =
+ gdk_threads_add_timeout (1000, gtk_entry_selection_bubble_popup_cb, entry);
+}
+
static void
gtk_entry_drag_begin (GtkWidget *widget,
GdkDragContext *context)
return hints;
}
+
+/**
+ * gtk_entry_set_attributes:
+ * @entry: a #GtkEntry
+ * @attrs: a #PangoAttrList
+ *
+ * Sets a #PangoAttrList; the attributes in the list are applied to the
+ * entry text.
+ *
+ * Since: 3.6
+ */
+void
+gtk_entry_set_attributes (GtkEntry *entry,
+ PangoAttrList *attrs)
+{
+ GtkEntryPrivate *priv = entry->priv;
+ g_return_if_fail (GTK_IS_ENTRY (entry));
+
+ if (attrs)
+ pango_attr_list_ref (attrs);
+
+ if (priv->attrs)
+ pango_attr_list_unref (priv->attrs);
+ priv->attrs = attrs;
+
+ g_object_notify (G_OBJECT (entry), "attributes");
+
+ gtk_entry_recompute (entry);
+ gtk_widget_queue_resize (GTK_WIDGET (entry));
+}
+
+/**
+ * gtk_entry_get_attributes:
+ * @entry: a #GtkEntry
+ *
+ * Gets the attribute list that was set on the entry using
+ * gtk_entry_set_attributes(), if any.
+ *
+ * Return value: (transfer none): the attribute list, or %NULL
+ * if none was set.
+ *
+ * Since: 3.6
+ */
+PangoAttrList *
+gtk_entry_get_attributes (GtkEntry *entry)
+{
+ g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
+
+ return entry->priv->attrs;
+}
+