gint start_y;
gchar *im_module;
+
+ GdkDevice *completion_device;
};
typedef struct _GtkEntryPasswordHint GtkEntryPasswordHint;
{
GtkEntryPrivate *priv = GTK_ENTRY_GET_PRIVATE (object);
GtkEntry *entry = GTK_ENTRY (object);
+ GtkWidget *widget;
switch (prop_id)
{
if (new_value != entry->editable)
{
+ widget = GTK_WIDGET (entry);
if (!new_value)
{
_gtk_entry_reset_im_context (entry);
- if (GTK_WIDGET_HAS_FOCUS (entry))
+ if (gtk_widget_has_focus (widget))
gtk_im_context_focus_out (entry->im_context);
entry->preedit_length = 0;
entry->editable = new_value;
- if (new_value && GTK_WIDGET_HAS_FOCUS (entry))
+ if (new_value && gtk_widget_has_focus (widget))
gtk_im_context_focus_in (entry->im_context);
gtk_entry_queue_draw (entry);
{
GtkEntryPrivate *priv = GTK_ENTRY_GET_PRIVATE (entry);
- GTK_WIDGET_SET_FLAGS (entry, GTK_CAN_FOCUS);
+ gtk_widget_set_can_focus (GTK_WIDGET (entry), TRUE);
entry->editable = TRUE;
entry->visible = TRUE;
get_text_area_size (entry, &x, &y, &width, &height);
- if (GTK_WIDGET_HAS_FOCUS (entry) && !priv->interior_focus)
+ if (gtk_widget_has_focus (GTK_WIDGET (entry)) && !priv->interior_focus)
y += priv->focus_width;
primary->y = y;
gtk_entry_dispose (GObject *object)
{
GtkEntry *entry = GTK_ENTRY (object);
+ GtkEntryPrivate *priv = GTK_ENTRY_GET_PRIVATE (entry);
gtk_entry_set_icon_from_pixbuf (entry, GTK_ENTRY_ICON_PRIMARY, NULL);
gtk_entry_set_icon_tooltip_markup (entry, GTK_ENTRY_ICON_PRIMARY, NULL);
gtk_entry_set_icon_from_pixbuf (entry, GTK_ENTRY_ICON_SECONDARY, NULL);
gtk_entry_set_icon_tooltip_markup (entry, GTK_ENTRY_ICON_SECONDARY, NULL);
+ if (priv->buffer)
+ {
+ buffer_disconnect_signals (entry);
+ g_object_unref (priv->buffer);
+ priv->buffer = NULL;
+ }
+
G_OBJECT_CLASS (gtk_entry_parent_class)->dispose (object);
}
g_free (priv->im_module);
- /* COMPAT: entry->text is a deprecated field, and the allocation
- is owned by the buffer. */
-
- gtk_entry_set_buffer (entry, NULL);
-
G_OBJECT_CLASS (gtk_entry_parent_class)->finalize (object);
}
attributes_mask);
gdk_window_set_user_data (icon_info->window, widget);
gdk_window_set_background (icon_info->window,
- &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ &widget->style->base[gtk_widget_get_state (widget)]);
gtk_widget_queue_resize (widget);
}
icon_info = g_slice_new0 (EntryIconInfo);
priv->icons[icon_pos] = icon_info;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
realize_icon_info (widget, icon_pos);
return icon_info;
EntryIconInfo *icon_info = NULL;
gint i;
- if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_realized (widget) && !gtk_widget_get_mapped (widget))
{
GTK_WIDGET_CLASS (gtk_entry_parent_class)->map (widget);
EntryIconInfo *icon_info = NULL;
gint i;
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
for (i = 0; i < MAX_ICONS; i++)
{
gint attributes_mask;
int i;
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ gtk_widget_set_realized (widget, TRUE);
entry = GTK_ENTRY (widget);
priv = GTK_ENTRY_GET_PRIVATE (entry);
widget->style = gtk_style_attach (widget->style, widget->window);
- gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
- gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (widget->window, &widget->style->base[gtk_widget_get_state (widget)]);
+ gdk_window_set_background (entry->text_area, &widget->style->base[gtk_widget_get_state (widget)]);
gdk_window_show (entry->text_area);
static void
place_windows (GtkEntry *entry)
{
+ GtkWidget *widget = GTK_WIDGET (entry);
GtkEntryPrivate *priv = GTK_ENTRY_GET_PRIVATE (entry);
gint x, y, width, height;
GtkAllocation primary;
get_text_area_size (entry, &x, &y, &width, &height);
get_icon_allocations (entry, &primary, &secondary);
- if (GTK_WIDGET_HAS_FOCUS (entry) && !priv->interior_focus)
+ if (gtk_widget_has_focus (widget) && !priv->interior_focus)
y += priv->focus_width;
- if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_RTL)
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
x += secondary.width;
else
x += primary.width;
secondary.x, secondary.y,
secondary.width, secondary.height);
- gdk_window_move_resize (GTK_ENTRY (entry)->text_area, x, y, width, height);
+ gdk_window_move_resize (entry->text_area, x, y, width, height);
}
static void
gtk_widget_get_child_requisition (widget, &requisition);
_gtk_entry_get_borders (entry, &xborder, &yborder);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_drawable_get_size (widget->window, NULL, &frame_height);
else
frame_height = requisition.height;
- if (GTK_WIDGET_HAS_FOCUS (widget) && !priv->interior_focus)
+ if (gtk_widget_has_focus (widget) && !priv->interior_focus)
frame_height -= 2 * priv->focus_width;
if (x)
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
/* We call gtk_widget_get_child_requisition, since we want (for
* backwards compatibility reasons) the realization here to
gtk_entry_recompute (entry);
completion = gtk_entry_get_completion (entry);
- if (completion && GTK_WIDGET_MAPPED (completion->priv->popup_window))
+ if (completion && gtk_widget_get_mapped (completion->priv->popup_window))
_gtk_entry_completion_resize_popup (completion);
}
}
width += xborder * 2;
}
- if (GTK_WIDGET_HAS_FOCUS (widget) && !priv->interior_focus)
+ if (gtk_widget_has_focus (widget) && !priv->interior_focus)
{
x += priv->focus_width;
y += priv->focus_width;
gtk_widget_style_get (widget, "state-hint", &state_hint, NULL);
if (state_hint)
- state = GTK_WIDGET_HAS_FOCUS (widget) ?
- GTK_STATE_ACTIVE : GTK_WIDGET_STATE (widget);
+ state = gtk_widget_has_focus (widget) ?
+ GTK_STATE_ACTIVE : gtk_widget_get_state (widget);
else
state = GTK_STATE_NORMAL;
gtk_entry_draw_progress (widget, event);
- if (GTK_WIDGET_HAS_FOCUS (widget) && !priv->interior_focus)
+ if (gtk_widget_has_focus (widget) && !priv->interior_focus)
{
x -= priv->focus_width;
y -= priv->focus_width;
width += 2 * priv->focus_width;
height += 2 * priv->focus_width;
- gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
+ gtk_paint_focus (widget->style, widget->window,
+ gtk_widget_get_state (widget),
&event->area, widget, "entry",
0, 0, width, height);
}
*width -= progress_border.left + progress_border.right;
*height -= progress_border.top + progress_border.bottom;
- if (GTK_WIDGET_HAS_FOCUS (widget) && !private->interior_focus)
+ if (gtk_widget_has_focus (widget) && !private->interior_focus)
{
*x += private->focus_width;
*y += private->focus_width;
}
state = GTK_STATE_SELECTED;
- if (!GTK_WIDGET_SENSITIVE (widget))
+ if (!gtk_widget_get_sensitive (widget))
state = GTK_STATE_INSENSITIVE;
gtk_paint_box (widget->style, event->window,
gtk_widget_style_get (widget, "state-hint", &state_hint, NULL);
if (state_hint)
- state = GTK_WIDGET_HAS_FOCUS (widget) ?
- GTK_STATE_ACTIVE : GTK_WIDGET_STATE (widget);
+ state = gtk_widget_has_focus (widget) ?
+ GTK_STATE_ACTIVE : gtk_widget_get_state (widget);
else
- state = GTK_WIDGET_STATE(widget);
+ state = gtk_widget_get_state(widget);
if (widget->window == event->window)
{
/* 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) &&
+ gtk_widget_has_focus (widget) &&
entry->selection_bound == entry->current_pos && entry->cursor_visible)
gtk_entry_draw_cursor (GTK_ENTRY (widget), CURSOR_STANDARD);
}
gdk_drawable_get_size (icon_info->window, &width, &height);
gtk_paint_flat_box (widget->style, icon_info->window,
- GTK_WIDGET_STATE (widget), GTK_SHADOW_NONE,
+ gtk_widget_get_state (widget), GTK_SHADOW_NONE,
NULL, widget, "entry_bg",
0, 0, width, height);
entry->button = event->button;
- if (!GTK_WIDGET_HAS_FOCUS (widget))
+ if (!gtk_widget_has_focus (widget))
{
entry->in_click = TRUE;
gtk_widget_grab_focus (widget);
GdkCursor *cursor;
gint i;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
- gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
- gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (widget->window, &widget->style->base[gtk_widget_get_state (widget)]);
+ gdk_window_set_background (entry->text_area, &widget->style->base[gtk_widget_get_state (widget)]);
for (i = 0; i < MAX_ICONS; i++)
{
EntryIconInfo *icon_info = priv->icons[i];
if (icon_info && icon_info->window)
- gdk_window_set_background (icon_info->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (icon_info->window, &widget->style->base[gtk_widget_get_state (widget)]);
}
if (gtk_widget_is_sensitive (widget))
gtk_entry_recompute (entry);
- if (previous_style && GTK_WIDGET_REALIZED (widget))
+ if (previous_style && gtk_widget_get_realized (widget))
{
- gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
- gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (widget->window, &widget->style->base[gtk_widget_get_state (widget)]);
+ gdk_window_set_background (entry->text_area, &widget->style->base[gtk_widget_get_state (widget)]);
for (i = 0; i < MAX_ICONS; i++)
{
EntryIconInfo *icon_info = priv->icons[i];
if (icon_info && icon_info->window)
- gdk_window_set_background (icon_info->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (icon_info->window, &widget->style->base[gtk_widget_get_state (widget)]);
}
}
if (window &&
widget != window->default_widget &&
!(widget == window->focus_widget &&
- (!window->default_widget || !GTK_WIDGET_SENSITIVE (window->default_widget))))
+ (!window->default_widget || !gtk_widget_get_sensitive (window->default_widget))))
gtk_window_activate_default (window);
}
}
if (pango_dir == PANGO_DIRECTION_NEUTRAL)
{
- if (GTK_WIDGET_HAS_FOCUS (widget))
+ if (gtk_widget_has_focus (widget))
{
GdkDisplay *display = gtk_widget_get_display (widget);
GdkKeymap *keymap = gdk_keymap_get_for_display (display);
pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
gtk_entry_get_pixel_ranges (entry, &ranges, &n_ranges);
- if (GTK_WIDGET_HAS_FOCUS (entry))
+ if (gtk_widget_has_focus (widget))
{
selection_color = &widget->style->base [GTK_STATE_SELECTED];
text_color = &widget->style->text [GTK_STATE_SELECTED];
GtkStateType state;
state = GTK_STATE_SELECTED;
- if (!GTK_WIDGET_SENSITIVE (widget))
+ if (!gtk_widget_get_sensitive (widget))
state = GTK_STATE_INSENSITIVE;
text_color = widget->style->text[widget->state];
bar_text_color = widget->style->fg[state];
}
}
+/**
+ * gtk_entry_reset_im_context:
+ * @entry: a #GtkEntry
+ *
+ * Reset the input method context of the entry if needed.
+ *
+ * This can be necessary in the case where modifying the buffer
+ * would confuse on-going input method behavior.
+ *
+ * Since: 2.22
+ */
+void
+gtk_entry_reset_im_context (GtkEntry *entry)
+{
+ g_return_if_fail (GTK_IS_ENTRY (entry));
+
+ _gtk_entry_reset_im_context (entry);
+}
+
+/**
+ * gtk_entry_im_context_filter_keypress:
+ * @entry: a #GtkEntry
+ * @event: the key event
+ *
+ * Allow the #GtkEntry input method to internally handle key press
+ * and release events. If this function returns %TRUE, then no further
+ * processing should be done for this key event. See
+ * gtk_im_context_filter_keypress().
+ *
+ * Note that you are expected to call this function from your handler
+ * when overriding key event handling. This is needed in the case when
+ * you need to insert your own key handling between the input method
+ * and the default key event handling of the #GtkEntry.
+ * See gtk_text_view_reset_im_context() for an example of use.
+ *
+ * Return value: %TRUE if the input method handled the key event.
+ *
+ * Since: 2.22
+ */
+gboolean
+gtk_entry_im_context_filter_keypress (GtkEntry *entry,
+ GdkEventKey *event)
+{
+ g_return_val_if_fail (GTK_IS_ENTRY (entry), FALSE);
+
+ return gtk_im_context_filter_keypress (entry->im_context, event);
+}
+
+
static gint
gtk_entry_find_position (GtkEntry *entry,
gint x)
PangoLayoutLine *line;
PangoRectangle logical_rect;
- if (!GTK_WIDGET_REALIZED (entry))
+ if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
return;
_gtk_entry_effective_inner_border (entry, &inner_border);
if (completion)
{
- if (GTK_WIDGET_MAPPED (completion->priv->popup_window))
+ if (gtk_widget_get_mapped (completion->priv->popup_window))
_gtk_entry_completion_popdown (completion);
if (!popup_completion && completion->priv->changed_id > 0)
gint start, end;
gint n_targets;
- if (!GTK_WIDGET_REALIZED (entry))
+ if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
return;
list = gtk_target_list_new (NULL, 0);
{
GtkEntryPrivate *priv = GTK_ENTRY_GET_PRIVATE (entry);
EntryIconInfo *icon_info = priv->icons[icon_pos];
- GdkScreen *screen;
+ GtkIconInfo *info;
GtkIconTheme *icon_theme;
GtkSettings *settings;
+ GtkStateType state;
+ GtkWidget *widget;
+ GdkScreen *screen;
gint width, height;
- GtkIconInfo *info;
- gint state;
if (!icon_info || icon_info->pixbuf)
return;
+ widget = GTK_WIDGET (entry);
+
switch (icon_info->storage_type)
{
case GTK_IMAGE_EMPTY:
case GTK_IMAGE_PIXBUF:
break;
case GTK_IMAGE_STOCK:
- state = GTK_WIDGET_STATE (entry);
- GTK_WIDGET_STATE (entry) = GTK_STATE_NORMAL;
- icon_info->pixbuf = gtk_widget_render_icon (GTK_WIDGET (entry),
+ state = gtk_widget_get_state (widget);
+ gtk_widget_set_state (widget, GTK_STATE_NORMAL);
+ icon_info->pixbuf = gtk_widget_render_icon (widget,
icon_info->stock_id,
GTK_ICON_SIZE_MENU,
NULL);
if (!icon_info->pixbuf)
- icon_info->pixbuf = gtk_widget_render_icon (GTK_WIDGET (entry),
+ icon_info->pixbuf = gtk_widget_render_icon (widget,
GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_MENU,
NULL);
- GTK_WIDGET_STATE (entry) = state;
+ gtk_widget_set_state (widget, state);
break;
case GTK_IMAGE_ICON_NAME:
- screen = gtk_widget_get_screen (GTK_WIDGET (entry));
+ screen = gtk_widget_get_screen (widget);
if (screen)
{
icon_theme = gtk_icon_theme_get_for_screen (screen);
if (icon_info->pixbuf == NULL)
{
- state = GTK_WIDGET_STATE (entry);
- GTK_WIDGET_STATE (entry) = GTK_STATE_NORMAL;
- icon_info->pixbuf = gtk_widget_render_icon (GTK_WIDGET (entry),
+ state = gtk_widget_get_state (widget);
+ gtk_widget_set_state (widget, GTK_STATE_NORMAL);
+ icon_info->pixbuf = gtk_widget_render_icon (widget,
GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_MENU,
NULL);
- GTK_WIDGET_STATE (entry) = state;
+ gtk_widget_set_state (widget, state);
}
}
break;
case GTK_IMAGE_GICON:
- screen = gtk_widget_get_screen (GTK_WIDGET (entry));
+ screen = gtk_widget_get_screen (widget);
if (screen)
{
icon_theme = gtk_icon_theme_get_for_screen (screen);
if (icon_info->pixbuf == NULL)
{
- state = GTK_WIDGET_STATE (entry);
- GTK_WIDGET_STATE (entry) = GTK_STATE_NORMAL;
- icon_info->pixbuf = gtk_widget_render_icon (GTK_WIDGET (entry),
+ state = gtk_widget_get_state (widget);
+ gtk_widget_set_state (widget, GTK_STATE_NORMAL);
+ icon_info->pixbuf = gtk_widget_render_icon (widget,
GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_MENU,
NULL);
- GTK_WIDGET_STATE (entry) = state;
+ gtk_widget_set_state (widget, state);
}
}
break;
return g_object_new (GTK_TYPE_ENTRY, "buffer", buffer, NULL);
}
-/**
- * gtk_entry_new_with_max_length:
- * @max: the maximum length of the entry, or 0 for no maximum.
- * (other than the maximum length of entries.) The value passed in will
- * be clamped to the range 0-65536.
- *
- * Creates a new #GtkEntry widget with the given maximum length.
- *
- * Return value: a new #GtkEntry
- *
- * Deprecated: 2.0: Use gtk_entry_set_max_length() instead.
- **/
-GtkWidget*
-gtk_entry_new_with_max_length (gint max)
-{
- GtkEntry *entry;
-
- max = CLAMP (max, 0, GTK_ENTRY_BUFFER_MAX_SIZE);
-
- entry = g_object_new (GTK_TYPE_ENTRY, NULL);
- gtk_entry_buffer_set_max_length (get_buffer (entry), max);
-
- return GTK_WIDGET (entry);
-}
-
-
static GtkEntryBuffer*
get_buffer (GtkEntry *entry)
{
g_object_notify (obj, "invisible-char");
g_object_notify (obj, "invisible-char-set");
g_object_thaw_notify (obj);
+
+ gtk_editable_set_position (GTK_EDITABLE (entry), 0);
+ gtk_entry_recompute (entry);
}
/**
g_signal_handler_unblock (entry, completion->priv->changed_id);
}
-/**
- * gtk_entry_append_text:
- * @entry: a #GtkEntry
- * @text: the text to append
- *
- * Appends the given text to the contents of the widget.
- *
- * Deprecated: 2.0: Use gtk_editable_insert_text() instead.
- */
-void
-gtk_entry_append_text (GtkEntry *entry,
- const gchar *text)
-{
- GtkEntryPrivate *priv;
- gint tmp_pos;
-
- g_return_if_fail (GTK_IS_ENTRY (entry));
- g_return_if_fail (text != NULL);
- priv = GTK_ENTRY_GET_PRIVATE (entry);
-
- tmp_pos = gtk_entry_buffer_get_length (get_buffer (entry));
- gtk_editable_insert_text (GTK_EDITABLE (entry), text, -1, &tmp_pos);
-}
-
-/**
- * gtk_entry_prepend_text:
- * @entry: a #GtkEntry
- * @text: the text to prepend
- *
- * Prepends the given text to the contents of the widget.
- *
- * Deprecated: 2.0: Use gtk_editable_insert_text() instead.
- */
-void
-gtk_entry_prepend_text (GtkEntry *entry,
- const gchar *text)
-{
- gint tmp_pos;
-
- g_return_if_fail (GTK_IS_ENTRY (entry));
- g_return_if_fail (text != NULL);
-
- tmp_pos = 0;
- gtk_editable_insert_text (GTK_EDITABLE (entry), text, -1, &tmp_pos);
-}
-
-/**
- * gtk_entry_set_position:
- * @entry: a #GtkEntry
- * @position: the position of the cursor. The cursor is displayed
- * before the character with the given (base 0) index in the widget.
- * The value must be less than or equal to the number of characters
- * in the widget. A value of -1 indicates that the position should
- * be set after the last character in the entry. Note that this
- * position is in characters, not in bytes.
- *
- * Sets the cursor position in an entry to the given value.
- *
- * Deprecated: 2.0: Use gtk_editable_set_position() instead.
- */
-void
-gtk_entry_set_position (GtkEntry *entry,
- gint position)
-{
- g_return_if_fail (GTK_IS_ENTRY (entry));
-
- gtk_editable_set_position (GTK_EDITABLE (entry), position);
-}
-
/**
* gtk_entry_set_visibility:
* @entry: a #GtkEntry
gtk_entry_recompute (entry);
}
-/**
- * gtk_entry_set_editable:
- * @entry: a #GtkEntry
- * @editable: %TRUE if the user is allowed to edit the text
- * in the widget
- *
- * Determines if the user can edit the text in the editable
- * widget or not.
- *
- * Deprecated: 2.0: Use gtk_editable_set_editable() instead.
- */
-void
-gtk_entry_set_editable (GtkEntry *entry,
- gboolean editable)
-{
- g_return_if_fail (GTK_IS_ENTRY (entry));
-
- gtk_editable_set_editable (GTK_EDITABLE (entry), editable);
-}
-
/**
* gtk_entry_set_overwrite_mode:
* @entry: a #GtkEntry
return gtk_entry_buffer_get_text (get_buffer (entry));
}
-/**
- * gtk_entry_select_region:
- * @entry: a #GtkEntry
- * @start: the starting position
- * @end: the end position
- *
- * Selects a region of text. The characters that are selected are
- * those characters at positions from @start_pos up to, but not
- * including @end_pos. If @end_pos is negative, then the the characters
- * selected will be those characters from @start_pos to the end of
- * the text.
- *
- * Deprecated: 2.0: Use gtk_editable_select_region() instead.
- */
-void
-gtk_entry_select_region (GtkEntry *entry,
- gint start,
- gint end)
-{
- gtk_editable_select_region (GTK_EDITABLE (entry), start, end);
-}
-
/**
* gtk_entry_set_max_length:
* @entry: a #GtkEntry
g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
}
- if (GTK_WIDGET_MAPPED (entry))
+ if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
gdk_window_show_unraised (icon_info->window);
}
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
}
- if (GTK_WIDGET_MAPPED (entry))
+ if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
gdk_window_show_unraised (icon_info->window);
}
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
}
- if (GTK_WIDGET_MAPPED (entry))
+ if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
gdk_window_show_unraised (icon_info->window);
}
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
}
- if (GTK_WIDGET_MAPPED (entry))
+ if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
gdk_window_show_unraised (icon_info->window);
}
gtk_entry_ensure_pixbuf (entry, icon_pos);
- if (GTK_WIDGET_VISIBLE (entry))
+ if (gtk_widget_get_visible (GTK_WIDGET (entry)))
gtk_widget_queue_resize (GTK_WIDGET (entry));
g_object_thaw_notify (G_OBJECT (entry));
{
icon_info->nonactivatable = !activatable;
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (entry)))
+ if (gtk_widget_get_realized (GTK_WIDGET (entry)))
update_cursors (GTK_WIDGET (entry));
g_object_notify (G_OBJECT (entry),
icon_info->pressed = FALSE;
icon_info->prelight = FALSE;
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (entry)))
+ if (gtk_widget_get_realized (GTK_WIDGET (entry)))
update_cursors (GTK_WIDGET (entry));
gtk_widget_queue_draw (GTK_WIDGET (entry));
GtkBorder inner_border;
gint monitor_num, strong_x, height;
- g_return_if_fail (GTK_WIDGET_REALIZED (entry));
+ g_return_if_fail (gtk_widget_get_realized (widget));
gdk_window_get_origin (entry->text_area, x, y);
PopupInfo *info = user_data;
GtkEntry *entry = info->entry;
- if (GTK_WIDGET_REALIZED (entry))
+ if (gtk_widget_get_realized (GTK_WIDGET (entry)))
{
DisplayMode mode;
gboolean clipboard_contains_text;
static gboolean
cursor_blinks (GtkEntry *entry)
{
- if (GTK_WIDGET_HAS_FOCUS (entry) &&
+ if (gtk_widget_has_focus (GTK_WIDGET (entry)) &&
entry->editable &&
entry->selection_bound == entry->current_pos)
{
static void
show_cursor (GtkEntry *entry)
{
+ GtkWidget *widget;
+
if (!entry->cursor_visible)
{
entry->cursor_visible = TRUE;
- if (GTK_WIDGET_HAS_FOCUS (entry) && entry->selection_bound == entry->current_pos)
- gtk_widget_queue_draw (GTK_WIDGET (entry));
+ widget = GTK_WIDGET (entry);
+ if (gtk_widget_has_focus (widget) && entry->selection_bound == entry->current_pos)
+ gtk_widget_queue_draw (widget);
}
}
static void
hide_cursor (GtkEntry *entry)
{
+ GtkWidget *widget;
+
if (entry->cursor_visible)
{
entry->cursor_visible = FALSE;
- if (GTK_WIDGET_HAS_FOCUS (entry) && entry->selection_bound == entry->current_pos)
- gtk_widget_queue_draw (GTK_WIDGET (entry));
+ widget = GTK_WIDGET (entry);
+ if (gtk_widget_has_focus (widget) && entry->selection_bound == entry->current_pos)
+ gtk_widget_queue_draw (widget);
}
}
entry = GTK_ENTRY (data);
priv = GTK_ENTRY_GET_PRIVATE (entry);
- if (!GTK_WIDGET_HAS_FOCUS (entry))
+ if (!gtk_widget_has_focus (GTK_WIDGET (entry)))
{
g_warning ("GtkEntry - did not receive focus-out-event. If you\n"
"connect a handler to this signal, it must return\n"
gtk_entry_completion_timeout (gpointer data)
{
GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (data);
+ GtkEntryPrivate *priv = GTK_ENTRY_GET_PRIVATE (completion->priv->entry);
completion->priv->completion_timeout = 0;
g_object_get (completion, "popup-single-match", &popup_single, NULL);
if ((matches > (popup_single ? 0: 1)) || actions > 0)
{
- if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_resize_popup (completion);
else
- _gtk_entry_completion_popup (completion);
+ _gtk_entry_completion_popup (completion, priv->completion_device);
}
else
_gtk_entry_completion_popdown (completion);
}
- else if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ else if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_popdown (completion);
return FALSE;
gint matches, actions = 0;
GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);
- if (!GTK_WIDGET_MAPPED (completion->priv->popup_window))
+ if (!gtk_widget_get_mapped (completion->priv->popup_window))
return FALSE;
matches = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (completion->priv->filter_model), NULL);
{
GtkTreeIter iter;
+ GtkTreeIter child_iter;
GtkTreeModel *model = NULL;
GtkTreeSelection *sel;
gboolean entry_set;
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->tree_view));
if (!gtk_tree_selection_get_selected (sel, &model, &iter))
return FALSE;
+
+ gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, &iter);
+ model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
if (completion->priv->completion_prefix == NULL)
completion->priv->completion_prefix = g_strdup (gtk_entry_get_text (GTK_ENTRY (completion->priv->entry)));
g_signal_emit_by_name (completion, "cursor-on-match", model,
- &iter, &entry_set);
+ &child_iter, &entry_set);
}
}
else if (completion->priv->current_selected - matches >= 0)
gtk_entry_completion_changed (GtkWidget *entry,
gpointer user_data)
{
+ GtkEntryPrivate *priv = GTK_ENTRY_GET_PRIVATE (entry);
GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);
+ GdkDevice *device;
/* (re)install completion timeout */
if (completion->priv->completion_timeout)
if (completion->priv->minimum_key_length > 0 &&
strcmp ("", gtk_entry_get_text (GTK_ENTRY (entry))) == 0)
{
- if (GTK_WIDGET_VISIBLE (completion->priv->popup_window))
+ if (gtk_widget_get_visible (completion->priv->popup_window))
_gtk_entry_completion_popdown (completion);
return;
}
+ device = gtk_get_current_event_device ();
+
+ if (device && device->source == GDK_SOURCE_KEYBOARD)
+ device = gdk_device_get_associated_device (device);
+
+ if (device)
+ priv->completion_device = device;
+
completion->priv->completion_timeout =
gdk_threads_add_timeout (COMPLETION_TIMEOUT,
gtk_entry_completion_timeout,
old->priv->completion_timeout = 0;
}
- if (GTK_WIDGET_MAPPED (old->priv->popup_window))
+ if (gtk_widget_get_mapped (old->priv->popup_window))
_gtk_entry_completion_popdown (old);
disconnect_completion_signals (entry, old);
if (gtk_entry_get_display_mode (entry) != DISPLAY_NORMAL && priv->caps_lock_warning)
{
- if (gdk_keymap_get_caps_lock_state (keymap))
+ if (gdk_keymap_get_num_lock_state (keymap)
+ && gdk_keymap_get_caps_lock_state (keymap))
+ text = _("Caps Lock and Num Lock are on");
+ else if (gdk_keymap_get_num_lock_state (keymap))
+ text = _("Num Lock is on");
+ else if (gdk_keymap_get_caps_lock_state (keymap))
text = _("Caps Lock is on");
}
projects / ~andy / gtk / blobdiff