2012-06-01 14:04:31 +00:00
|
|
|
|
/* GTK - The GIMP Toolkit
|
|
|
|
|
* Copyright (C) 2012 Red Hat, Inc.
|
|
|
|
|
*
|
|
|
|
|
* Authors:
|
|
|
|
|
* - Bastien Nocera <bnocera@redhat.com>
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This library 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
|
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Modified by the GTK+ Team and others 2012. See the AUTHORS
|
|
|
|
|
* file for a list of people on the GTK+ Team. See the ChangeLog
|
|
|
|
|
* files for a list of changes. These files are distributed with
|
|
|
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
2016-10-15 20:22:48 +00:00
|
|
|
|
#include "gtksearchentryprivate.h"
|
2015-10-29 14:55:28 +00:00
|
|
|
|
|
2020-10-13 01:17:31 +00:00
|
|
|
|
#include "gtkaccessibleprivate.h"
|
2019-02-17 04:57:18 +00:00
|
|
|
|
#include "gtkeditable.h"
|
2019-09-24 04:18:40 +00:00
|
|
|
|
#include "gtkboxlayout.h"
|
2019-05-29 17:10:46 +00:00
|
|
|
|
#include "gtkgestureclick.h"
|
2019-02-17 04:57:18 +00:00
|
|
|
|
#include "gtktextprivate.h"
|
|
|
|
|
#include "gtkimage.h"
|
2015-10-29 14:55:28 +00:00
|
|
|
|
#include "gtkintl.h"
|
2019-02-17 04:57:18 +00:00
|
|
|
|
#include "gtkprivate.h"
|
2015-10-29 14:55:28 +00:00
|
|
|
|
#include "gtkmarshalers.h"
|
|
|
|
|
#include "gtkstylecontext.h"
|
2018-03-11 12:53:17 +00:00
|
|
|
|
#include "gtkeventcontrollerkey.h"
|
2020-06-15 17:45:57 +00:00
|
|
|
|
#include "gtkwidgetprivate.h"
|
2019-02-22 20:50:45 +00:00
|
|
|
|
|
2012-06-01 14:04:31 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* SECTION:gtksearchentry
|
|
|
|
|
* @Short_description: An entry which shows a search icon
|
|
|
|
|
* @Title: GtkSearchEntry
|
|
|
|
|
*
|
2020-06-25 18:14:33 +00:00
|
|
|
|
* #GtkSearchEntry is an entry widget that has been tailored for use
|
|
|
|
|
* as a search entry. The main aPI for interacting with a GtkSearchEntry
|
|
|
|
|
* as entry is the #GtkEditable interface.
|
2012-06-01 14:04:31 +00:00
|
|
|
|
*
|
2014-11-25 03:40:45 +00:00
|
|
|
|
* It will show an inactive symbolic “find” icon when the search
|
|
|
|
|
* entry is empty, and a symbolic “clear” icon when there is text.
|
|
|
|
|
* Clicking on the “clear” icon will empty the search entry.
|
2012-06-01 14:04:31 +00:00
|
|
|
|
*
|
2013-07-29 01:49:37 +00:00
|
|
|
|
* To make filtering appear more reactive, it is a good idea to
|
|
|
|
|
* not react to every change in the entry text immediately, but
|
|
|
|
|
* only after a short delay. To support this, #GtkSearchEntry
|
|
|
|
|
* emits the #GtkSearchEntry::search-changed signal which can
|
|
|
|
|
* be used instead of the #GtkEditable::changed signal.
|
|
|
|
|
*
|
2014-11-25 03:40:45 +00:00
|
|
|
|
* The #GtkSearchEntry::previous-match, #GtkSearchEntry::next-match
|
2017-01-31 09:39:39 +00:00
|
|
|
|
* and #GtkSearchEntry::stop-search signals can be used to implement
|
2014-11-25 03:40:45 +00:00
|
|
|
|
* moving between search results and ending the search.
|
|
|
|
|
*
|
|
|
|
|
* Often, GtkSearchEntry will be fed events by means of being
|
2015-04-26 21:49:28 +00:00
|
|
|
|
* placed inside a #GtkSearchBar. If that is not the case,
|
2018-03-11 12:53:17 +00:00
|
|
|
|
* you can use gtk_search_entry_set_key_capture_widget() to let it
|
|
|
|
|
* capture key input from another widget.
|
2020-06-26 15:56:27 +00:00
|
|
|
|
*
|
|
|
|
|
* # CSS Nodes
|
|
|
|
|
*
|
|
|
|
|
* |[<!-- language="plain" -->
|
|
|
|
|
* entry.search
|
|
|
|
|
* ╰── text
|
|
|
|
|
* ]|
|
|
|
|
|
*
|
|
|
|
|
* GtkSearchEntry has a single CSS node with name entry that carries
|
2021-03-04 15:05:19 +00:00
|
|
|
|
* a .search style class, and the text node is a child of that.
|
2020-07-28 22:15:01 +00:00
|
|
|
|
*
|
|
|
|
|
* # Accessibility
|
|
|
|
|
*
|
|
|
|
|
* GtkSearchEntry uses the #GTK_ACCESSIBLE_ROLE_SEARCH_BOX role.
|
2012-06-01 14:04:31 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2013-07-29 01:49:37 +00:00
|
|
|
|
enum {
|
2019-02-17 04:57:18 +00:00
|
|
|
|
ACTIVATE,
|
2013-07-29 01:49:37 +00:00
|
|
|
|
SEARCH_CHANGED,
|
2014-11-25 03:40:45 +00:00
|
|
|
|
NEXT_MATCH,
|
|
|
|
|
PREVIOUS_MATCH,
|
|
|
|
|
STOP_SEARCH,
|
2019-04-03 11:08:53 +00:00
|
|
|
|
SEARCH_STARTED,
|
2013-07-29 01:49:37 +00:00
|
|
|
|
LAST_SIGNAL
|
|
|
|
|
};
|
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
enum {
|
|
|
|
|
PROP_0,
|
|
|
|
|
PROP_PLACEHOLDER_TEXT,
|
|
|
|
|
PROP_ACTIVATES_DEFAULT,
|
|
|
|
|
NUM_PROPERTIES,
|
|
|
|
|
};
|
|
|
|
|
|
2013-07-29 01:49:37 +00:00
|
|
|
|
static guint signals[LAST_SIGNAL] = { 0 };
|
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
static GParamSpec *props[NUM_PROPERTIES] = { NULL, };
|
|
|
|
|
|
2019-05-27 03:21:07 +00:00
|
|
|
|
typedef struct _GtkSearchEntryClass GtkSearchEntryClass;
|
|
|
|
|
|
|
|
|
|
struct _GtkSearchEntry
|
|
|
|
|
{
|
|
|
|
|
GtkWidget parent;
|
2020-03-28 14:28:22 +00:00
|
|
|
|
|
|
|
|
|
GtkWidget *capture_widget;
|
|
|
|
|
GtkEventController *capture_widget_controller;
|
|
|
|
|
|
|
|
|
|
GtkWidget *entry;
|
|
|
|
|
GtkWidget *icon;
|
|
|
|
|
|
|
|
|
|
guint delayed_changed_id;
|
|
|
|
|
gboolean content_changed;
|
|
|
|
|
gboolean search_stopped;
|
2019-05-27 03:21:07 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _GtkSearchEntryClass
|
|
|
|
|
{
|
|
|
|
|
GtkWidgetClass parent_class;
|
|
|
|
|
|
|
|
|
|
void (* activate) (GtkSearchEntry *entry);
|
|
|
|
|
void (* search_changed) (GtkSearchEntry *entry);
|
|
|
|
|
void (* next_match) (GtkSearchEntry *entry);
|
|
|
|
|
void (* previous_match) (GtkSearchEntry *entry);
|
|
|
|
|
void (* stop_search) (GtkSearchEntry *entry);
|
|
|
|
|
};
|
|
|
|
|
|
2013-07-29 01:49:37 +00:00
|
|
|
|
static void gtk_search_entry_editable_init (GtkEditableInterface *iface);
|
2020-10-13 01:17:31 +00:00
|
|
|
|
static void gtk_search_entry_accessible_init (GtkAccessibleInterface *iface);
|
2013-07-29 01:49:37 +00:00
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkSearchEntry, gtk_search_entry, GTK_TYPE_WIDGET,
|
2020-10-13 01:17:31 +00:00
|
|
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_ACCESSIBLE,
|
|
|
|
|
gtk_search_entry_accessible_init)
|
2013-07-29 01:49:37 +00:00
|
|
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,
|
|
|
|
|
gtk_search_entry_editable_init))
|
2013-06-27 19:02:52 +00:00
|
|
|
|
|
2013-05-16 16:20:19 +00:00
|
|
|
|
/* 150 mseconds of delay */
|
|
|
|
|
#define DELAYED_TIMEOUT_ID 150
|
|
|
|
|
|
2014-11-25 03:40:45 +00:00
|
|
|
|
static void
|
2019-02-17 04:57:18 +00:00
|
|
|
|
text_changed (GtkSearchEntry *entry)
|
2014-11-25 03:40:45 +00:00
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
entry->content_changed = TRUE;
|
2014-11-25 03:40:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2019-02-17 04:57:18 +00:00
|
|
|
|
gtk_search_entry_finalize (GObject *object)
|
2014-11-25 03:40:45 +00:00
|
|
|
|
{
|
2019-02-17 04:57:18 +00:00
|
|
|
|
GtkSearchEntry *entry = GTK_SEARCH_ENTRY (object);
|
2014-11-25 03:40:45 +00:00
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
gtk_editable_finish_delegate (GTK_EDITABLE (entry));
|
2014-11-25 03:40:45 +00:00
|
|
|
|
|
2020-10-23 16:19:31 +00:00
|
|
|
|
gtk_widget_unparent (gtk_widget_get_first_child (GTK_WIDGET (entry)));
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_clear_pointer (&entry->entry, gtk_widget_unparent);
|
|
|
|
|
g_clear_pointer (&entry->icon, gtk_widget_unparent);
|
2013-05-16 16:20:19 +00:00
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
if (entry->delayed_changed_id > 0)
|
|
|
|
|
g_source_remove (entry->delayed_changed_id);
|
2013-05-16 16:20:19 +00:00
|
|
|
|
|
2018-03-11 12:53:17 +00:00
|
|
|
|
gtk_search_entry_set_key_capture_widget (GTK_SEARCH_ENTRY (object), NULL);
|
|
|
|
|
|
2013-05-16 16:20:19 +00:00
|
|
|
|
G_OBJECT_CLASS (gtk_search_entry_parent_class)->finalize (object);
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-25 03:40:45 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_search_entry_stop_search (GtkSearchEntry *entry)
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
entry->search_stopped = TRUE;
|
2014-11-25 03:40:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_search_entry_set_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
const GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
GtkSearchEntry *entry = GTK_SEARCH_ENTRY (object);
|
2020-07-28 22:15:01 +00:00
|
|
|
|
const char *text;
|
2019-02-17 04:57:18 +00:00
|
|
|
|
|
|
|
|
|
if (gtk_editable_delegate_set_property (object, prop_id, value, pspec))
|
2020-07-28 22:15:01 +00:00
|
|
|
|
{
|
|
|
|
|
if (prop_id == NUM_PROPERTIES + GTK_EDITABLE_PROP_EDITABLE)
|
|
|
|
|
{
|
|
|
|
|
gtk_accessible_update_property (GTK_ACCESSIBLE (entry),
|
|
|
|
|
GTK_ACCESSIBLE_PROPERTY_READ_ONLY, !g_value_get_boolean (value),
|
|
|
|
|
-1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-02-17 04:57:18 +00:00
|
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
|
{
|
|
|
|
|
case PROP_PLACEHOLDER_TEXT:
|
2020-07-28 22:15:01 +00:00
|
|
|
|
text = g_value_get_string (value);
|
|
|
|
|
gtk_text_set_placeholder_text (GTK_TEXT (entry->entry), text);
|
|
|
|
|
gtk_accessible_update_property (GTK_ACCESSIBLE (entry),
|
|
|
|
|
GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER, text,
|
|
|
|
|
-1);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PROP_ACTIVATES_DEFAULT:
|
2020-03-28 14:28:22 +00:00
|
|
|
|
if (gtk_text_get_activates_default (GTK_TEXT (entry->entry)) != g_value_get_boolean (value))
|
2019-03-17 00:57:50 +00:00
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_text_set_activates_default (GTK_TEXT (entry->entry), g_value_get_boolean (value));
|
2019-03-17 00:57:50 +00:00
|
|
|
|
g_object_notify_by_pspec (object, pspec);
|
|
|
|
|
}
|
2019-02-17 04:57:18 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_search_entry_get_property (GObject *object,
|
|
|
|
|
guint prop_id,
|
|
|
|
|
GValue *value,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
GtkSearchEntry *entry = GTK_SEARCH_ENTRY (object);
|
|
|
|
|
|
|
|
|
|
if (gtk_editable_delegate_get_property (object, prop_id, value, pspec))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
switch (prop_id)
|
|
|
|
|
{
|
|
|
|
|
case PROP_PLACEHOLDER_TEXT:
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_value_set_string (value, gtk_text_get_placeholder_text (GTK_TEXT (entry->entry)));
|
2019-02-17 04:57:18 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PROP_ACTIVATES_DEFAULT:
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_value_set_boolean (value, gtk_text_get_activates_default (GTK_TEXT (entry->entry)));
|
2019-02-17 04:57:18 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-15 13:34:16 +00:00
|
|
|
|
static gboolean
|
2019-02-17 04:57:18 +00:00
|
|
|
|
gtk_search_entry_grab_focus (GtkWidget *widget)
|
|
|
|
|
{
|
|
|
|
|
GtkSearchEntry *entry = GTK_SEARCH_ENTRY (widget);
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
return gtk_text_grab_focus_without_selecting (GTK_TEXT (entry->entry));
|
2019-02-17 04:57:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-03-04 03:55:34 +00:00
|
|
|
|
static gboolean
|
2019-03-04 03:14:19 +00:00
|
|
|
|
gtk_search_entry_mnemonic_activate (GtkWidget *widget,
|
|
|
|
|
gboolean group_cycling)
|
|
|
|
|
{
|
|
|
|
|
GtkSearchEntry *entry = GTK_SEARCH_ENTRY (widget);
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_widget_grab_focus (entry->entry);
|
2019-03-04 03:14:19 +00:00
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-01 14:04:31 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_search_entry_class_init (GtkSearchEntryClass *klass)
|
|
|
|
|
{
|
2013-05-16 16:20:19 +00:00
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
2013-05-16 16:20:19 +00:00
|
|
|
|
|
|
|
|
|
object_class->finalize = gtk_search_entry_finalize;
|
2019-02-17 04:57:18 +00:00
|
|
|
|
object_class->get_property = gtk_search_entry_get_property;
|
|
|
|
|
object_class->set_property = gtk_search_entry_set_property;
|
|
|
|
|
|
|
|
|
|
widget_class->grab_focus = gtk_search_entry_grab_focus;
|
2020-06-15 17:45:57 +00:00
|
|
|
|
widget_class->focus = gtk_widget_focus_child;
|
2019-03-04 03:14:19 +00:00
|
|
|
|
widget_class->mnemonic_activate = gtk_search_entry_mnemonic_activate;
|
2014-11-25 03:40:45 +00:00
|
|
|
|
|
|
|
|
|
klass->stop_search = gtk_search_entry_stop_search;
|
2012-06-01 14:04:31 +00:00
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
props[PROP_PLACEHOLDER_TEXT] =
|
|
|
|
|
g_param_spec_string ("placeholder-text",
|
|
|
|
|
P_("Placeholder text"),
|
|
|
|
|
P_("Show text in the entry when it’s empty and unfocused"),
|
|
|
|
|
NULL,
|
2019-03-17 00:57:50 +00:00
|
|
|
|
GTK_PARAM_READWRITE);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
|
|
|
|
|
props[PROP_ACTIVATES_DEFAULT] =
|
|
|
|
|
g_param_spec_boolean ("activates-default",
|
|
|
|
|
P_("Activates default"),
|
|
|
|
|
P_("Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed"),
|
|
|
|
|
FALSE,
|
|
|
|
|
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
|
|
|
|
|
|
|
|
|
|
g_object_class_install_properties (object_class, NUM_PROPERTIES, props);
|
|
|
|
|
gtk_editable_install_properties (object_class, NUM_PROPERTIES);
|
|
|
|
|
|
2020-09-29 02:52:35 +00:00
|
|
|
|
/**
|
2020-12-16 16:07:30 +00:00
|
|
|
|
* GtkSearchEntry::activate:
|
2020-09-29 02:52:35 +00:00
|
|
|
|
* @self: The widget on which the signal is emitted
|
|
|
|
|
*
|
|
|
|
|
* The ::activate signal is forwarded from the
|
|
|
|
|
* #GtkText::activated signal, which is a keybinding
|
|
|
|
|
* signal for all forms of the Enter key.
|
|
|
|
|
*/
|
2019-02-17 04:57:18 +00:00
|
|
|
|
signals[ACTIVATE] =
|
|
|
|
|
g_signal_new (I_("activate"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkSearchEntryClass, activate),
|
|
|
|
|
NULL, NULL,
|
|
|
|
|
NULL,
|
|
|
|
|
G_TYPE_NONE, 0);
|
2013-07-29 01:49:37 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkSearchEntry::search-changed:
|
|
|
|
|
* @entry: the entry on which the signal was emitted
|
|
|
|
|
*
|
|
|
|
|
* The #GtkSearchEntry::search-changed signal is emitted with a short
|
|
|
|
|
* delay of 150 milliseconds after the last change to the entry text.
|
|
|
|
|
*/
|
|
|
|
|
signals[SEARCH_CHANGED] =
|
|
|
|
|
g_signal_new (I_("search-changed"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
|
G_STRUCT_OFFSET (GtkSearchEntryClass, search_changed),
|
|
|
|
|
NULL, NULL,
|
2016-08-29 14:00:17 +00:00
|
|
|
|
NULL,
|
2013-07-29 01:49:37 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
2014-11-25 03:40:45 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkSearchEntry::next-match:
|
|
|
|
|
* @entry: the entry on which the signal was emitted
|
|
|
|
|
*
|
2020-11-17 03:58:53 +00:00
|
|
|
|
* The ::next-match signal is a [keybinding signal][GtkSignalAction]
|
2014-11-25 03:40:45 +00:00
|
|
|
|
* which gets emitted when the user initiates a move to the next match
|
|
|
|
|
* for the current search string.
|
|
|
|
|
*
|
|
|
|
|
* Applications should connect to it, to implement moving between
|
|
|
|
|
* matches.
|
|
|
|
|
*
|
|
|
|
|
* The default bindings for this signal is Ctrl-g.
|
|
|
|
|
*/
|
|
|
|
|
signals[NEXT_MATCH] =
|
|
|
|
|
g_signal_new (I_("next-match"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkSearchEntryClass, next_match),
|
|
|
|
|
NULL, NULL,
|
2016-08-29 14:00:17 +00:00
|
|
|
|
NULL,
|
2014-11-25 03:40:45 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkSearchEntry::previous-match:
|
|
|
|
|
* @entry: the entry on which the signal was emitted
|
|
|
|
|
*
|
2020-11-17 03:58:53 +00:00
|
|
|
|
* The ::previous-match signal is a [keybinding signal][GtkSignalAction]
|
2014-11-25 03:40:45 +00:00
|
|
|
|
* which gets emitted when the user initiates a move to the previous match
|
|
|
|
|
* for the current search string.
|
|
|
|
|
*
|
|
|
|
|
* Applications should connect to it, to implement moving between
|
|
|
|
|
* matches.
|
|
|
|
|
*
|
|
|
|
|
* The default bindings for this signal is Ctrl-Shift-g.
|
|
|
|
|
*/
|
|
|
|
|
signals[PREVIOUS_MATCH] =
|
|
|
|
|
g_signal_new (I_("previous-match"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkSearchEntryClass, previous_match),
|
|
|
|
|
NULL, NULL,
|
2016-08-29 14:00:17 +00:00
|
|
|
|
NULL,
|
2014-11-25 03:40:45 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkSearchEntry::stop-search:
|
|
|
|
|
* @entry: the entry on which the signal was emitted
|
|
|
|
|
*
|
2020-11-17 03:58:53 +00:00
|
|
|
|
* The ::stop-search signal is a [keybinding signal][GtkSignalAction]
|
2014-11-25 03:40:45 +00:00
|
|
|
|
* which gets emitted when the user stops a search via keyboard input.
|
|
|
|
|
*
|
|
|
|
|
* Applications should connect to it, to implement hiding the search
|
|
|
|
|
* entry in this case.
|
|
|
|
|
*
|
|
|
|
|
* The default bindings for this signal is Escape.
|
|
|
|
|
*/
|
|
|
|
|
signals[STOP_SEARCH] =
|
|
|
|
|
g_signal_new (I_("stop-search"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
|
G_STRUCT_OFFSET (GtkSearchEntryClass, stop_search),
|
|
|
|
|
NULL, NULL,
|
2016-08-29 14:00:17 +00:00
|
|
|
|
NULL,
|
2014-11-25 03:40:45 +00:00
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
2019-04-03 11:08:53 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkSearchEntry::search-started:
|
|
|
|
|
* @entry: the entry on which the signal was emitted
|
|
|
|
|
*
|
|
|
|
|
* The ::search-started signal gets emitted when the user initiated
|
|
|
|
|
* a search on the entry.
|
|
|
|
|
*/
|
|
|
|
|
signals[SEARCH_STARTED] =
|
|
|
|
|
g_signal_new (I_("search-started"),
|
|
|
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
|
|
|
G_SIGNAL_RUN_LAST, 0,
|
|
|
|
|
NULL, NULL,
|
|
|
|
|
NULL,
|
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
2018-08-12 13:44:45 +00:00
|
|
|
|
gtk_widget_class_add_binding_signal (widget_class,
|
|
|
|
|
GDK_KEY_g, GDK_CONTROL_MASK,
|
|
|
|
|
"next-match",
|
|
|
|
|
NULL);
|
|
|
|
|
gtk_widget_class_add_binding_signal (widget_class,
|
|
|
|
|
GDK_KEY_g, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
|
|
|
|
|
"previous-match",
|
|
|
|
|
NULL);
|
|
|
|
|
gtk_widget_class_add_binding_signal (widget_class,
|
|
|
|
|
GDK_KEY_Escape, 0,
|
|
|
|
|
"stop-search",
|
|
|
|
|
NULL);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
|
2019-09-24 04:18:40 +00:00
|
|
|
|
gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BOX_LAYOUT);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
gtk_widget_class_set_css_name (widget_class, I_("entry"));
|
2020-07-28 22:15:01 +00:00
|
|
|
|
gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_SEARCH_BOX);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GtkEditable *
|
|
|
|
|
gtk_search_entry_get_delegate (GtkEditable *editable)
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
return GTK_EDITABLE (GTK_SEARCH_ENTRY (editable)->entry);
|
2013-07-29 01:49:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_search_entry_editable_init (GtkEditableInterface *iface)
|
|
|
|
|
{
|
2019-02-17 04:57:18 +00:00
|
|
|
|
iface->get_delegate = gtk_search_entry_get_delegate;
|
2013-07-29 01:49:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-10-13 01:17:31 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_search_entry_accessible_get_platform_state (GtkAccessible *self,
|
|
|
|
|
GtkAccessiblePlatformState state)
|
|
|
|
|
{
|
|
|
|
|
GtkSearchEntry *entry = GTK_SEARCH_ENTRY (self);
|
|
|
|
|
|
|
|
|
|
switch (state)
|
|
|
|
|
{
|
|
|
|
|
case GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE:
|
|
|
|
|
return gtk_widget_get_focusable (GTK_WIDGET (entry->entry));
|
|
|
|
|
case GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED:
|
|
|
|
|
return gtk_widget_has_focus (GTK_WIDGET (entry->entry));
|
|
|
|
|
default:
|
|
|
|
|
g_assert_not_reached ();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_search_entry_accessible_init (GtkAccessibleInterface *iface)
|
|
|
|
|
{
|
|
|
|
|
GtkAccessibleInterface *parent_iface = g_type_interface_peek_parent (iface);
|
|
|
|
|
iface->get_at_context = parent_iface->get_at_context;
|
|
|
|
|
iface->get_platform_state = gtk_search_entry_accessible_get_platform_state;
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-29 01:49:37 +00:00
|
|
|
|
static void
|
2019-05-29 17:10:46 +00:00
|
|
|
|
gtk_search_entry_icon_release (GtkGestureClick *press,
|
|
|
|
|
int n_press,
|
|
|
|
|
double x,
|
|
|
|
|
double y,
|
|
|
|
|
GtkSearchEntry *entry)
|
2013-07-29 01:49:37 +00:00
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_editable_set_text (GTK_EDITABLE (entry->entry), "");
|
2012-06-01 14:04:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-05-16 16:20:19 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_search_entry_changed_timeout_cb (gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GtkSearchEntry *entry = user_data;
|
|
|
|
|
|
2013-07-29 01:49:37 +00:00
|
|
|
|
g_signal_emit (entry, signals[SEARCH_CHANGED], 0);
|
2020-03-28 14:28:22 +00:00
|
|
|
|
entry->delayed_changed_id = 0;
|
2013-05-16 16:20:19 +00:00
|
|
|
|
|
|
|
|
|
return G_SOURCE_REMOVE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
reset_timeout (GtkSearchEntry *entry)
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
if (entry->delayed_changed_id > 0)
|
|
|
|
|
g_source_remove (entry->delayed_changed_id);
|
|
|
|
|
entry->delayed_changed_id = g_timeout_add (DELAYED_TIMEOUT_ID,
|
2013-05-16 16:20:19 +00:00
|
|
|
|
gtk_search_entry_changed_timeout_cb,
|
|
|
|
|
entry);
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_source_set_name_by_id (entry->delayed_changed_id, "[gtk] gtk_search_entry_changed_timeout_cb");
|
2013-05-16 16:20:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-06-01 14:04:31 +00:00
|
|
|
|
static void
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_search_entry_changed (GtkEditable *editable,
|
2019-02-17 04:57:18 +00:00
|
|
|
|
GtkSearchEntry *entry)
|
2012-06-01 14:04:31 +00:00
|
|
|
|
{
|
2019-02-17 04:57:18 +00:00
|
|
|
|
const char *str;
|
2012-06-01 14:04:31 +00:00
|
|
|
|
|
2013-05-16 16:20:19 +00:00
|
|
|
|
/* Update the icons first */
|
2020-03-28 14:28:22 +00:00
|
|
|
|
str = gtk_editable_get_text (GTK_EDITABLE (entry->entry));
|
2012-06-01 14:04:31 +00:00
|
|
|
|
|
|
|
|
|
if (str == NULL || *str == '\0')
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_widget_set_child_visible (entry->icon, FALSE);
|
2013-05-16 16:20:19 +00:00
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
if (entry->delayed_changed_id > 0)
|
2013-07-29 01:49:37 +00:00
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_source_remove (entry->delayed_changed_id);
|
|
|
|
|
entry->delayed_changed_id = 0;
|
2013-07-29 01:49:37 +00:00
|
|
|
|
}
|
|
|
|
|
g_signal_emit (entry, signals[SEARCH_CHANGED], 0);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_widget_set_child_visible (entry->icon, TRUE);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
|
2013-07-29 01:49:37 +00:00
|
|
|
|
/* Queue up the timeout */
|
|
|
|
|
reset_timeout (entry);
|
|
|
|
|
}
|
2012-06-01 14:04:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
static void
|
|
|
|
|
notify_cb (GObject *object,
|
|
|
|
|
GParamSpec *pspec,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
/* The editable interface properties are already forwarded by the editable delegate setup */
|
|
|
|
|
if (g_str_equal (pspec->name, "placeholder-text") ||
|
|
|
|
|
g_str_equal (pspec->name, "activates-default"))
|
|
|
|
|
g_object_notify (data, pspec->name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
activate_cb (GtkText *text,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
g_signal_emit (data, signals[ACTIVATE], 0);
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-01 14:04:31 +00:00
|
|
|
|
static void
|
|
|
|
|
gtk_search_entry_init (GtkSearchEntry *entry)
|
|
|
|
|
{
|
2020-10-23 16:19:31 +00:00
|
|
|
|
GtkWidget *icon;
|
2019-02-17 04:57:18 +00:00
|
|
|
|
GtkGesture *press;
|
|
|
|
|
|
2020-11-12 16:04:30 +00:00
|
|
|
|
/* The search icon is purely presentational */
|
2020-10-23 16:19:31 +00:00
|
|
|
|
icon = g_object_new (GTK_TYPE_IMAGE,
|
2020-11-12 16:04:30 +00:00
|
|
|
|
"accessible-role", GTK_ACCESSIBLE_ROLE_PRESENTATION,
|
2020-10-23 16:19:31 +00:00
|
|
|
|
"icon-name", "system-search-symbolic",
|
|
|
|
|
NULL);
|
|
|
|
|
gtk_widget_set_parent (icon, GTK_WIDGET (entry));
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
entry->entry = gtk_text_new ();
|
|
|
|
|
gtk_widget_set_parent (entry->entry, GTK_WIDGET (entry));
|
|
|
|
|
gtk_widget_set_hexpand (entry->entry, TRUE);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
gtk_editable_init_delegate (GTK_EDITABLE (entry));
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_signal_connect_swapped (entry->entry, "changed", G_CALLBACK (text_changed), entry);
|
|
|
|
|
g_signal_connect_after (entry->entry, "changed", G_CALLBACK (gtk_search_entry_changed), entry);
|
|
|
|
|
g_signal_connect_swapped (entry->entry, "preedit-changed", G_CALLBACK (text_changed), entry);
|
|
|
|
|
g_signal_connect (entry->entry, "notify", G_CALLBACK (notify_cb), entry);
|
|
|
|
|
g_signal_connect (entry->entry, "activate", G_CALLBACK (activate_cb), entry);
|
2019-02-17 04:57:18 +00:00
|
|
|
|
|
2020-11-12 16:04:30 +00:00
|
|
|
|
entry->icon = g_object_new (GTK_TYPE_IMAGE,
|
|
|
|
|
"accessible-role", GTK_ACCESSIBLE_ROLE_PRESENTATION,
|
|
|
|
|
"icon-name", "edit-clear-symbolic",
|
|
|
|
|
NULL);
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_widget_set_tooltip_text (entry->icon, _("Clear entry"));
|
|
|
|
|
gtk_widget_set_parent (entry->icon, GTK_WIDGET (entry));
|
|
|
|
|
gtk_widget_set_child_visible (entry->icon, FALSE);
|
2013-08-15 13:20:19 +00:00
|
|
|
|
|
2019-05-29 17:10:46 +00:00
|
|
|
|
press = gtk_gesture_click_new ();
|
2019-02-17 04:57:18 +00:00
|
|
|
|
g_signal_connect (press, "released", G_CALLBACK (gtk_search_entry_icon_release), entry);
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_widget_add_controller (entry->icon, GTK_EVENT_CONTROLLER (press));
|
2013-08-15 13:20:19 +00:00
|
|
|
|
|
2020-02-06 16:32:26 +00:00
|
|
|
|
gtk_widget_add_css_class (GTK_WIDGET (entry), I_("search"));
|
2012-06-01 14:04:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_search_entry_new:
|
|
|
|
|
*
|
|
|
|
|
* Creates a #GtkSearchEntry, with a find icon when the search field is
|
|
|
|
|
* empty, and a clear icon when it isn't.
|
|
|
|
|
*
|
2014-02-19 23:49:43 +00:00
|
|
|
|
* Returns: a new #GtkSearchEntry
|
2012-06-01 14:04:31 +00:00
|
|
|
|
*/
|
|
|
|
|
GtkWidget *
|
|
|
|
|
gtk_search_entry_new (void)
|
|
|
|
|
{
|
|
|
|
|
return GTK_WIDGET (g_object_new (GTK_TYPE_SEARCH_ENTRY, NULL));
|
|
|
|
|
}
|
2014-11-25 03:40:45 +00:00
|
|
|
|
|
2014-12-27 23:29:07 +00:00
|
|
|
|
gboolean
|
2018-03-11 12:53:17 +00:00
|
|
|
|
gtk_search_entry_is_keynav (guint keyval,
|
|
|
|
|
GdkModifierType state)
|
2014-11-25 03:40:45 +00:00
|
|
|
|
{
|
|
|
|
|
if (keyval == GDK_KEY_Tab || keyval == GDK_KEY_KP_Tab ||
|
|
|
|
|
keyval == GDK_KEY_Up || keyval == GDK_KEY_KP_Up ||
|
|
|
|
|
keyval == GDK_KEY_Down || keyval == GDK_KEY_KP_Down ||
|
|
|
|
|
keyval == GDK_KEY_Left || keyval == GDK_KEY_KP_Left ||
|
|
|
|
|
keyval == GDK_KEY_Right || keyval == GDK_KEY_KP_Right ||
|
|
|
|
|
keyval == GDK_KEY_Home || keyval == GDK_KEY_KP_Home ||
|
|
|
|
|
keyval == GDK_KEY_End || keyval == GDK_KEY_KP_End ||
|
|
|
|
|
keyval == GDK_KEY_Page_Up || keyval == GDK_KEY_KP_Page_Up ||
|
|
|
|
|
keyval == GDK_KEY_Page_Down || keyval == GDK_KEY_KP_Page_Down ||
|
2020-04-05 13:39:03 +00:00
|
|
|
|
((state & (GDK_CONTROL_MASK | GDK_ALT_MASK)) != 0))
|
2014-11-25 03:40:45 +00:00
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
|
|
/* Other navigation events should get automatically
|
|
|
|
|
* ignored as they will not change the content of the entry
|
|
|
|
|
*/
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-11 12:53:17 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
capture_widget_key_handled (GtkEventControllerKey *controller,
|
|
|
|
|
guint keyval,
|
|
|
|
|
guint keycode,
|
|
|
|
|
GdkModifierType state,
|
2020-03-28 14:28:22 +00:00
|
|
|
|
GtkWidget *widget)
|
2018-03-11 12:53:17 +00:00
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
GtkSearchEntry *entry = GTK_SEARCH_ENTRY (widget);
|
2019-04-03 11:08:53 +00:00
|
|
|
|
gboolean handled, was_empty;
|
2018-03-11 12:53:17 +00:00
|
|
|
|
|
|
|
|
|
if (gtk_search_entry_is_keynav (keyval, state) ||
|
|
|
|
|
keyval == GDK_KEY_space ||
|
|
|
|
|
keyval == GDK_KEY_Menu)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
entry->content_changed = FALSE;
|
|
|
|
|
entry->search_stopped = FALSE;
|
|
|
|
|
was_empty = (gtk_text_get_text_length (GTK_TEXT (entry->entry)) == 0);
|
2018-03-11 12:53:17 +00:00
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
handled = gtk_event_controller_key_forward (controller, entry->entry);
|
2018-03-11 12:53:17 +00:00
|
|
|
|
|
2020-09-10 02:26:27 +00:00
|
|
|
|
if (handled)
|
2019-04-03 11:08:53 +00:00
|
|
|
|
{
|
2020-09-10 02:26:27 +00:00
|
|
|
|
if (was_empty && entry->content_changed && !entry->search_stopped)
|
2019-04-03 11:08:53 +00:00
|
|
|
|
g_signal_emit (entry, signals[SEARCH_STARTED], 0);
|
|
|
|
|
|
|
|
|
|
return GDK_EVENT_STOP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return GDK_EVENT_PROPAGATE;
|
2018-03-11 12:53:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_search_entry_set_key_capture_widget:
|
2018-04-06 14:20:48 +00:00
|
|
|
|
* @entry: a #GtkSearchEntry
|
2018-03-11 12:53:17 +00:00
|
|
|
|
* @widget: (nullable) (transfer none): a #GtkWidget
|
|
|
|
|
*
|
|
|
|
|
* Sets @widget as the widget that @entry will capture key events from.
|
|
|
|
|
*
|
|
|
|
|
* Key events are consumed by the search entry to start or
|
|
|
|
|
* continue a search.
|
|
|
|
|
*
|
|
|
|
|
* If the entry is part of a #GtkSearchBar, it is preferable
|
|
|
|
|
* to call gtk_search_bar_set_key_capture_widget() instead, which
|
|
|
|
|
* will reveal the entry in addition to triggering the search entry.
|
2021-01-27 03:17:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Note that despite the name of this function, the events
|
|
|
|
|
* are only 'captured' in the bubble phase, which means that
|
|
|
|
|
* editable child widgets of @widget will receive text input
|
|
|
|
|
* before it gets captured. If that is not desired, you can
|
|
|
|
|
* capture and forward the events yourself with
|
|
|
|
|
* gtk_event_controller_key_forward().
|
|
|
|
|
|
2018-03-11 12:53:17 +00:00
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_search_entry_set_key_capture_widget (GtkSearchEntry *entry,
|
|
|
|
|
GtkWidget *widget)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_SEARCH_ENTRY (entry));
|
|
|
|
|
g_return_if_fail (!widget || GTK_IS_WIDGET (widget));
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
if (entry->capture_widget)
|
2018-03-11 12:53:17 +00:00
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_widget_remove_controller (entry->capture_widget,
|
|
|
|
|
entry->capture_widget_controller);
|
|
|
|
|
g_object_remove_weak_pointer (G_OBJECT (entry->capture_widget),
|
|
|
|
|
(gpointer *) &entry->capture_widget);
|
2018-03-11 12:53:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
entry->capture_widget = widget;
|
2018-03-11 12:53:17 +00:00
|
|
|
|
|
|
|
|
|
if (widget)
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_object_add_weak_pointer (G_OBJECT (entry->capture_widget),
|
|
|
|
|
(gpointer *) &entry->capture_widget);
|
2018-03-11 12:53:17 +00:00
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
entry->capture_widget_controller = gtk_event_controller_key_new ();
|
|
|
|
|
gtk_event_controller_set_propagation_phase (entry->capture_widget_controller,
|
2021-01-27 03:17:57 +00:00
|
|
|
|
GTK_PHASE_BUBBLE);
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_signal_connect (entry->capture_widget_controller, "key-pressed",
|
2018-03-11 12:53:17 +00:00
|
|
|
|
G_CALLBACK (capture_widget_key_handled), entry);
|
2020-03-28 14:28:22 +00:00
|
|
|
|
g_signal_connect (entry->capture_widget_controller, "key-released",
|
2018-03-11 12:53:17 +00:00
|
|
|
|
G_CALLBACK (capture_widget_key_handled), entry);
|
2020-03-28 14:28:22 +00:00
|
|
|
|
gtk_widget_add_controller (widget, entry->capture_widget_controller);
|
2018-03-11 12:53:17 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_search_entry_get_key_capture_widget:
|
|
|
|
|
* @entry: a #GtkSearchEntry
|
|
|
|
|
*
|
|
|
|
|
* Gets the widget that @entry is capturing key events from.
|
|
|
|
|
*
|
2018-04-06 14:20:48 +00:00
|
|
|
|
* Returns: (transfer none): The key capture widget.
|
2018-03-11 12:53:17 +00:00
|
|
|
|
**/
|
|
|
|
|
GtkWidget *
|
|
|
|
|
gtk_search_entry_get_key_capture_widget (GtkSearchEntry *entry)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_SEARCH_ENTRY (entry), NULL);
|
|
|
|
|
|
2020-03-28 14:28:22 +00:00
|
|
|
|
return entry->capture_widget;
|
2018-03-11 12:53:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-02-17 04:57:18 +00:00
|
|
|
|
GtkEventController *
|
|
|
|
|
gtk_search_entry_get_key_controller (GtkSearchEntry *entry)
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
return gtk_text_get_key_controller (GTK_TEXT (entry->entry));
|
2019-02-17 04:57:18 +00:00
|
|
|
|
}
|
2019-02-20 15:29:26 +00:00
|
|
|
|
|
|
|
|
|
GtkText *
|
|
|
|
|
gtk_search_entry_get_text_widget (GtkSearchEntry *entry)
|
|
|
|
|
{
|
2020-03-28 14:28:22 +00:00
|
|
|
|
return GTK_TEXT (entry->entry);
|
2019-02-20 15:29:26 +00:00
|
|
|
|
}
|