AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
823e00dec9
gtk2/gtk/gtktexthandle.c

799 lines
25 KiB
C
Raw Normal View History

Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
/* GTK - The GIMP Toolkit
* Copyright © 2012 Carlos Garnacho <carlosg@gnome.org>
*
* 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/>.
*/
#include "config.h"
#include "gtkprivatetypebuiltins.h"
#include "gtktexthandleprivate.h"
#include "gtkmarshalers.h"
#include "gtkprivate.h"
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
#include "gtkwindowprivate.h"
text handle: Port to CSS nodes Use cursor-handle as the element name for the CSS node that is used to render text the selection handles.
2015-11-10 04:33:54 +00:00
#include "gtkcssnodeprivate.h"
#include "gtkwidgetprivate.h"
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
#include "gtkgizmoprivate.h"
#include "gtkrendericonprivate.h"
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
#include "gtkintl.h"
#include <gtk/gtk.h>
typedef struct _GtkTextHandlePrivate GtkTextHandlePrivate;
typedef struct _HandleWindow HandleWindow;
enum {
GtkTextHandle: add a drag-started signal This will be used to discriminate drags from taps.
2015-06-07 16:45:34 +00:00
DRAG_STARTED,
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
HANDLE_DRAGGED,
DRAG_FINISHED,
LAST_SIGNAL
};
enum {
PROP_0,
texthandle: Remove relative_to API It's unused now, GtkTextHandle uses widget coordinates.
2013-12-23 18:15:30 +00:00
PROP_PARENT
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
};
struct _HandleWindow
{
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
GtkWidget *widget;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
GdkRectangle pointing_to;
GtkTextHandle: Improve handle positioning When we are close the window edge, we need to shrink the 'invisible border' around the handle to avoid mispositioning it. A fiddly calculation, but it works.
2015-06-10 01:19:17 +00:00
GtkBorder border;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
gint dx;
gint dy;
texthandle: Handle ltr/rtl positioning This setting is per handle, as is dependent on the selected text, rather than the locale.
2015-06-10 18:52:02 +00:00
GtkTextDirection dir;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
guint dragged : 1;
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
guint mode_visible : 1;
guint user_visible : 1;
guint has_point : 1;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
};
struct _GtkTextHandlePrivate
{
HandleWindow windows[2];
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
GtkWidget *toplevel;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
GtkWidget *parent;
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
GtkScrollable *parent_scrollable;
GtkAdjustment *vadj;
GtkAdjustment *hadj;
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
guint hierarchy_changed_id;
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
guint scrollable_notify_id;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
guint mode : 2;
};
gtk: Use new macros for defining private data https://bugzilla.gnome.org/show_bug.cgi?id=702996
2013-06-27 19:02:52 +00:00
G_DEFINE_TYPE_WITH_PRIVATE (GtkTextHandle, _gtk_text_handle, G_TYPE_OBJECT)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
static guint signals[LAST_SIGNAL] = { 0 };
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
static void _gtk_text_handle_update (GtkTextHandle *handle,
GtkTextHandlePosition pos);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
static void
GtkTextHandle: Use min-width/min-height instead of GtkWidget's text-handle-width/text-handle-height style properties
2016-10-04 19:13:29 +00:00
_gtk_text_handle_get_size (GtkTextHandle *handle,
GtkTextHandlePosition pos,
gint *width,
gint *height)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
GtkTextHandle: Use min-width/min-height instead of GtkWidget's text-handle-width/text-handle-height style properties
2016-10-04 19:13:29 +00:00
GtkTextHandlePrivate *priv = handle->priv;
GtkWidget *widget = priv->windows[pos].widget;
GtkStyleContext *context;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
GtkTextHandle: Use min-width/min-height instead of GtkWidget's text-handle-width/text-handle-height style properties
2016-10-04 19:13:29 +00:00
context = gtk_widget_get_style_context (widget);
gtk_style_context_get (context,
API: stylecontext: Remove state argument from getters The argument must always be the current state.
2016-10-08 03:07:23 +00:00
"min-width", width,
"min-height", height,
NULL);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
static gint
_text_handle_pos_from_widget (GtkTextHandle *handle,
GtkWidget *widget)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
GtkTextHandlePrivate *priv = handle->priv;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (widget == priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget)
return GTK_TEXT_HANDLE_POSITION_SELECTION_START;
else if (widget == priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget)
return GTK_TEXT_HANDLE_POSITION_SELECTION_END;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
else
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
return -1;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
static void
handle_drag_begin (GtkGestureDrag *gesture,
gdouble x,
gdouble y,
GtkTextHandle *handle)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
GtkTextHandlePrivate *priv = handle->priv;
GtkWidget *widget;
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
gint pos;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
pos = _text_handle_pos_from_widget (handle, widget);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
if (pos == GTK_TEXT_HANDLE_POSITION_CURSOR &&
priv->mode == GTK_TEXT_HANDLE_MODE_CURSOR)
x -= gtk_widget_get_width (widget) / 2;
else if ((pos == GTK_TEXT_HANDLE_POSITION_CURSOR &&
priv->windows[pos].dir == GTK_TEXT_DIR_RTL) ||
(pos == GTK_TEXT_HANDLE_POSITION_SELECTION_START &&
priv->windows[pos].dir != GTK_TEXT_DIR_RTL))
x -= gtk_widget_get_width (widget);
y += priv->windows[pos].border.top / 2;
priv->windows[pos].dx = x;
priv->windows[pos].dy = y;
priv->windows[pos].dragged = TRUE;
g_signal_emit (handle, signals[DRAG_STARTED], 0, pos);
}
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
static void
handle_drag_update (GtkGestureDrag *gesture,
gdouble offset_x,
gdouble offset_y,
GtkTextHandle *handle)
{
GtkTextHandlePrivate *priv = handle->priv;
gdouble start_x, start_y;
gint pos, x, y;
pos = _text_handle_pos_from_widget (handle,
gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)));
gtk_gesture_drag_get_start_point (gesture, &start_x, &start_y);
gtk_widget_translate_coordinates (priv->windows[pos].widget, priv->parent,
start_x + offset_x - priv->windows[pos].dx,
start_y + offset_y - priv->windows[pos].dy,
&x, &y);
g_signal_emit (handle, signals[HANDLE_DRAGGED], 0, pos, x, y);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
static void
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
handle_drag_end (GtkGestureDrag *gesture,
gdouble offset_x,
gdouble offset_y,
GtkTextHandle *handle)
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
{
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
GtkTextHandlePrivate *priv = handle->priv;
gint pos;
texthandle: Use the handle widget style context for rendering Using the parent widget context is a leftover of the pre-popover implementation, which used GdkWindows directly. This will make the context reflect widget state, at the expense of changing the selector paths that used to match the handles.
2014-11-20 12:41:24 +00:00
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
pos = _text_handle_pos_from_widget (handle,
gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)));
g_signal_emit (handle, signals[DRAG_FINISHED], 0, pos);
priv->windows[pos].dragged = FALSE;
}
gizmo: return void from snapshot func This boolean return was from the old gadget code and we weren't using it in the new gizmo code.
2019-01-18 07:01:40 +00:00
static void
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
snapshot_func (GtkGizmo *gizmo,
GtkSnapshot *snapshot)
{
GtkCssStyle *style = gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (gizmo)));
texthandle: Use the handle widget style context for rendering Using the parent widget context is a leftover of the pre-popover implementation, which used GdkWindows directly. This will make the context reflect widget state, at the expense of changing the selector paths that used to match the handles.
2014-11-20 12:41:24 +00:00
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
gtk_css_style_snapshot_icon (style,
snapshot,
gtk_widget_get_width (GTK_WIDGET (gizmo)),
Remove builtin icons altogether This removes support for GtkCssImageBuiltin and GtkCssImageBuiltinType from everywhere.
2020-01-10 18:11:59 +00:00
gtk_widget_get_height (GTK_WIDGET (gizmo)));
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
}
static GtkWidget *
_gtk_text_handle_ensure_widget (GtkTextHandle *handle,
GtkTextHandlePosition pos)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
GtkTextHandlePrivate *priv;
priv = handle->priv;
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (!priv->windows[pos].widget)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
GtkWidget *widget, *window;
text handle: Port to CSS nodes Use cursor-handle as the element name for the CSS node that is used to render text the selection handles.
2015-11-10 04:33:54 +00:00
GtkStyleContext *context;
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
GtkEventController *controller;
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
gizmo: Add a contains_func Let GtkGizmo override the contains() implementation. Update all callers to pass NULL for the contains_func.
2019-04-07 15:47:24 +00:00
widget = gtk_gizmo_new (I_("cursor-handle"), NULL, NULL, snapshot_func, NULL);
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
texthandle: Handle ltr/rtl positioning This setting is per handle, as is dependent on the selected text, rather than the locale.
2015-06-10 18:52:02 +00:00
gtk_widget_set_direction (widget, priv->windows[pos].dir);
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
controller = GTK_EVENT_CONTROLLER (gtk_gesture_drag_new ());
g_signal_connect (controller, "drag-begin",
G_CALLBACK (handle_drag_begin), handle);
g_signal_connect (controller, "drag-update",
G_CALLBACK (handle_drag_update), handle);
g_signal_connect (controller, "drag-end",
G_CALLBACK (handle_drag_end), handle);
gtk_widget_add_controller (widget, controller);
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
popover: Fix memory management of popovers Popovers are strange in the sense that they aren't attached to a parent directly, they rely on the relative_to widget so the toplevel is shared, and when they have a parent, it is the toplevel itself, not relative_to. This also means that there are conditions where the popover loses it's parent, so they must survive unparenting. The previous code would be floating the last reference as soon as the parent is gone, but it was non-obvious who'd own that reference. So fix this situation by granting the ownership of popovers to their relative_to widget, an extra reference may be held by the toplevel when the popover has a parent, but the popover object will be guaranteed to be alive as long as the parent lives. This way, memory management of popovers is as hidden from the user as regular widgets within containers are, users are free to call gtk_widget_destroy() on a popover, but it'd eventually become destructed when relative_to is.
2014-01-09 16:21:43 +00:00
priv->windows[pos].widget = g_object_ref_sink (widget);
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
priv->toplevel = window = gtk_widget_get_ancestor (priv->parent, GTK_TYPE_WINDOW);
gtkwindow: Only allow unrestricted positioning to text handle popovers This behavior has been made optional on add_popover() time, text handles will keep being able to overflow the window, in order to allow text selection on views too close to the window edge. Regular GtkPopovers are reinstaurated to the previous size positioning logic though, that is, limited by the visible area of the window.
2015-07-06 14:39:06 +00:00
_gtk_window_add_popover (GTK_WINDOW (window), widget, priv->parent, FALSE);
texthandle: Use the handle widget style context for rendering Using the parent widget context is a leftover of the pre-popover implementation, which used GdkWindows directly. This will make the context reflect widget state, at the expense of changing the selector paths that used to match the handles.
2014-11-20 12:41:24 +00:00
text handle: Port to CSS nodes Use cursor-handle as the element name for the CSS node that is used to render text the selection handles.
2015-11-10 04:33:54 +00:00
context = gtk_widget_get_style_context (widget);
gtk_style_context_set_parent (context, gtk_widget_get_style_context (priv->parent));
if (pos == GTK_TEXT_HANDLE_POSITION_SELECTION_END)
{
gtk_style_context_add_class (context, GTK_STYLE_CLASS_BOTTOM);
if (priv->mode == GTK_TEXT_HANDLE_MODE_CURSOR)
gtk_style_context_add_class (context, GTK_STYLE_CLASS_INSERTION_CURSOR);
}
else
gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOP);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
return priv->windows[pos].widget;
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
}
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
texthandle: Update child visibility of handles within scrollables If the rect a handle points to starts falling outside of the parent scrollable allocation, the handle will be automatically hidden, and shown again when the rectangle is visible too.
2014-01-22 15:41:00 +00:00
static void
_handle_update_child_visible (GtkTextHandle *handle,
GtkTextHandlePosition pos)
{
HandleWindow *handle_window;
GtkTextHandlePrivate *priv;
cairo_rectangle_int_t rect;
GtkAllocation allocation;
GtkWidget *parent;
priv = handle->priv;
handle_window = &priv->windows[pos];
if (!priv->parent_scrollable)
{
gtk_widget_set_child_visible (handle_window->widget, TRUE);
return;
}
parent = gtk_widget_get_parent (GTK_WIDGET (priv->parent_scrollable));
rect = handle_window->pointing_to;
gtk_widget_translate_coordinates (priv->parent, parent,
rect.x, rect.y, &rect.x, &rect.y);
gtk_widget_get_allocation (GTK_WIDGET (parent), &allocation);
if (rect.x < 0 || rect.x + rect.width > allocation.width ||
rect.y < 0 || rect.y + rect.height > allocation.height)
gtk_widget_set_child_visible (handle_window->widget, FALSE);
else
gtk_widget_set_child_visible (handle_window->widget, TRUE);
}
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
static void
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
_gtk_text_handle_update (GtkTextHandle *handle,
GtkTextHandlePosition pos)
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
{
GtkTextHandlePrivate *priv;
HandleWindow *handle_window;
GtkTextHandle: Improve handle positioning When we are close the window edge, we need to shrink the 'invisible border' around the handle to avoid mispositioning it. A fiddly calculation, but it works.
2015-06-10 01:19:17 +00:00
GtkBorder *border;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
priv = handle->priv;
handle_window = &priv->windows[pos];
GtkTextHandle: Improve handle positioning When we are close the window edge, we need to shrink the 'invisible border' around the handle to avoid mispositioning it. A fiddly calculation, but it works.
2015-06-10 01:19:17 +00:00
border = &handle_window->border;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (!priv->parent || !gtk_widget_is_drawable (priv->parent))
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
return;
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (handle_window->has_point &&
handle_window->mode_visible && handle_window->user_visible)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
cairo_rectangle_int_t rect;
gint width, height;
GtkWidget *window;
GtkTextHandle: Improve handle positioning When we are close the window edge, we need to shrink the 'invisible border' around the handle to avoid mispositioning it. A fiddly calculation, but it works.
2015-06-10 01:19:17 +00:00
GtkAllocation alloc;
gint w, h;
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
_gtk_text_handle_ensure_widget (handle, pos);
GtkTextHandle: Use min-width/min-height instead of GtkWidget's text-handle-width/text-handle-height style properties
2016-10-04 19:13:29 +00:00
_gtk_text_handle_get_size (handle, pos, &width, &height);
texthandle: Update child visibility of handles within scrollables If the rect a handle points to starts falling outside of the parent scrollable allocation, the handle will be automatically hidden, and shown again when the rectangle is visible too.
2014-01-22 15:41:00 +00:00
texthandle: Fix Y positioning of text handles It is assumed that border.top is the same than pointing_to.height (which equals the strong cursor position), which is not since some time ago. The border calculation has been move on top too, it is now used in the Y position one, and doesn't depend on anything we calculate later.
2015-10-14 15:21:25 +00:00
border->top = height;
border->bottom = height;
GtkTextHandle: Improve handle positioning When we are close the window edge, we need to shrink the 'invisible border' around the handle to avoid mispositioning it. A fiddly calculation, but it works.
2015-06-10 01:19:17 +00:00
border->left = width;
border->right = width;
texthandle: Make a bigger hit area around texthandles The hit area now extends to all sides around the handle, instead of just towards where the text is. This makes it easier to grab handles once shown.
2014-05-16 17:59:31 +00:00
texthandle: Fix Y positioning of text handles It is assumed that border.top is the same than pointing_to.height (which equals the strong cursor position), which is not since some time ago. The border calculation has been move on top too, it is now used in the Y position one, and doesn't depend on anything we calculate later.
2015-10-14 15:21:25 +00:00
rect.x = handle_window->pointing_to.x;
rect.y = handle_window->pointing_to.y + handle_window->pointing_to.height - handle_window->border.top;
rect.width = width;
rect.height = 0;
texthandle: Update child visibility of handles within scrollables If the rect a handle points to starts falling outside of the parent scrollable allocation, the handle will be automatically hidden, and shown again when the rectangle is visible too.
2014-01-22 15:41:00 +00:00
_handle_update_child_visible (handle, pos);
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
window = gtk_widget_get_parent (handle_window->widget);
gtk_widget_translate_coordinates (priv->parent, window,
rect.x, rect.y, &rect.x, &rect.y);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
texthandles: Move start handle to bottom The asset is going to change to point upwards, so physically place the handle below the text position. https://bugzilla.gnome.org/show_bug.cgi?id=750692
2015-06-10 17:54:34 +00:00
if (pos == GTK_TEXT_HANDLE_POSITION_CURSOR &&
priv->mode == GTK_TEXT_HANDLE_MODE_CURSOR)
rect.x -= rect.width / 2;
texthandle: Handle ltr/rtl positioning This setting is per handle, as is dependent on the selected text, rather than the locale.
2015-06-10 18:52:02 +00:00
else if ((pos == GTK_TEXT_HANDLE_POSITION_CURSOR &&
handle_window->dir == GTK_TEXT_DIR_RTL) ||
(pos == GTK_TEXT_HANDLE_POSITION_SELECTION_START &&
handle_window->dir != GTK_TEXT_DIR_RTL))
texthandles: Move start handle to bottom The asset is going to change to point upwards, so physically place the handle below the text position. https://bugzilla.gnome.org/show_bug.cgi?id=750692
2015-06-10 17:54:34 +00:00
rect.x -= rect.width;
GtkTextHandle: Improve handle positioning When we are close the window edge, we need to shrink the 'invisible border' around the handle to avoid mispositioning it. A fiddly calculation, but it works.
2015-06-10 01:19:17 +00:00
/* The goal is to make the window 3 times as wide and high. The handle
* will be rendered in the center, making the rest an invisible border.
* If we hit the edge of the toplevel, we shrink the border to avoid
* mispositioning the handle, if at all possible. This calculation uses
* knowledge about how popover_get_rect() works.
*/
gtk_widget_get_allocation (window, &alloc);
w = width + border->left + border->right;
h = height + border->top + border->bottom;
if (rect.x + rect.width/2 - w/2 < alloc.x)
border->left = MAX (0, border->left - (alloc.x - (rect.x + rect.width/2 - w/2)));
if (rect.y + rect.height/2 - h/2 < alloc.y)
border->top = MAX (0, border->top - (alloc.y - (rect.y + rect.height/2 - h/2)));
if (rect.x + rect.width/2 + w/2 > alloc.x + alloc.width)
border->right = MAX (0, border->right - (rect.x + rect.width/2 + w/2 - (alloc.x + alloc.width)));
if (rect.y + rect.height/2 + h/2 > alloc.y + alloc.height)
border->bottom = MAX (0, border->bottom - (rect.y + rect.height/2 + h/2 - (alloc.y + alloc.height)));
width += border->left + border->right;
height += border->top + border->bottom;
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
gtk_widget_set_size_request (handle_window->widget, width, height);
gtk_widget_show (handle_window->widget);
texthandle: Request raising of text handle popovers. https://bugzilla.gnome.org/show_bug.cgi?id=756670
2015-10-22 16:14:01 +00:00
_gtk_window_raise_popover (GTK_WINDOW (window), handle_window->widget);
texthandle: Use GtkWindow private popover API.
2014-01-17 17:12:57 +00:00
_gtk_window_set_popover_position (GTK_WINDOW (window),
handle_window->widget,
texthandles: Move start handle to bottom The asset is going to change to point upwards, so physically place the handle below the text position. https://bugzilla.gnome.org/show_bug.cgi?id=750692
2015-06-10 17:54:34 +00:00
GTK_POS_BOTTOM, &rect);
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
}
else if (handle_window->widget)
gtk_widget_hide (handle_window->widget);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
static void
adjustment_changed_cb (GtkAdjustment *adjustment,
GtkTextHandle *handle)
{
_gtk_text_handle_update (handle, GTK_TEXT_HANDLE_POSITION_SELECTION_START);
_gtk_text_handle_update (handle, GTK_TEXT_HANDLE_POSITION_SELECTION_END);
}
static void
_gtk_text_handle_set_scrollable (GtkTextHandle *handle,
GtkScrollable *scrollable)
{
GtkTextHandlePrivate *priv;
priv = handle->priv;
text handle: Don't leak adjustments This can happen if the weak pointer is triggered before the adjustments are unset. Pointed out in https://bugzilla.gnome.org/show_bug.cgi?id=774790
2016-11-23 18:55:28 +00:00
if (priv->vadj)
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
{
text handle: Don't leak adjustments This can happen if the weak pointer is triggered before the adjustments are unset. Pointed out in https://bugzilla.gnome.org/show_bug.cgi?id=774790
2016-11-23 18:55:28 +00:00
g_signal_handlers_disconnect_by_data (priv->vadj, handle);
g_clear_object (&priv->vadj);
}
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
text handle: Don't leak adjustments This can happen if the weak pointer is triggered before the adjustments are unset. Pointed out in https://bugzilla.gnome.org/show_bug.cgi?id=774790
2016-11-23 18:55:28 +00:00
if (priv->hadj)
{
g_signal_handlers_disconnect_by_data (priv->hadj, handle);
g_clear_object (&priv->hadj);
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
}
text handle: Don't leak adjustments This can happen if the weak pointer is triggered before the adjustments are unset. Pointed out in https://bugzilla.gnome.org/show_bug.cgi?id=774790
2016-11-23 18:55:28 +00:00
if (priv->parent_scrollable)
g_object_remove_weak_pointer (G_OBJECT (priv->parent_scrollable), (gpointer *) &priv->parent_scrollable);
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
priv->parent_scrollable = scrollable;
if (scrollable)
{
GtkTextHandle: Deal with parent_scrollable going away Use a weak reference to notice when parent_scrollable is going away. https://bugzilla.gnome.org/show_bug.cgi?id=724392
2014-02-18 03:27:35 +00:00
g_object_add_weak_pointer (G_OBJECT (priv->parent_scrollable), (gpointer *) &priv->parent_scrollable);
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
priv->vadj = gtk_scrollable_get_vadjustment (scrollable);
priv->hadj = gtk_scrollable_get_hadjustment (scrollable);
if (priv->vadj)
{
g_object_ref (priv->vadj);
g_signal_connect (priv->vadj, "changed",
G_CALLBACK (adjustment_changed_cb), handle);
g_signal_connect (priv->vadj, "value-changed",
G_CALLBACK (adjustment_changed_cb), handle);
}
if (priv->hadj)
{
g_object_ref (priv->hadj);
g_signal_connect (priv->hadj, "changed",
G_CALLBACK (adjustment_changed_cb), handle);
g_signal_connect (priv->hadj, "value-changed",
G_CALLBACK (adjustment_changed_cb), handle);
}
}
}
static void
_gtk_text_handle_scrollable_notify (GObject *object,
GParamSpec *pspec,
GtkTextHandle *handle)
{
if (pspec->value_type == GTK_TYPE_ADJUSTMENT)
_gtk_text_handle_set_scrollable (handle, GTK_SCROLLABLE (object));
}
static void
_gtk_text_handle_update_scrollable (GtkTextHandle *handle,
GtkScrollable *scrollable)
{
GtkTextHandlePrivate *priv;
priv = handle->priv;
if (priv->parent_scrollable == scrollable)
return;
if (priv->parent_scrollable && priv->scrollable_notify_id &&
g_signal_handler_is_connected (priv->parent_scrollable,
priv->scrollable_notify_id))
g_signal_handler_disconnect (priv->parent_scrollable,
priv->scrollable_notify_id);
_gtk_text_handle_set_scrollable (handle, scrollable);
if (priv->parent_scrollable)
priv->scrollable_notify_id =
g_signal_connect (priv->parent_scrollable, "notify",
G_CALLBACK (_gtk_text_handle_scrollable_notify),
handle);
}
GtkTextHandle: Look up for the first child of a scrolled window found Text handles use to connect to the first GtkScrollable up the hierarchy so they can be repositioned when scrolling. It makes more sense to look up the first child of a GtkScrolledWindow, it must be an scrollable too, and will be the scrollable that can actually change the position of the text handles. https://bugzilla.gnome.org/show_bug.cgi?id=761676
2016-02-24 16:19:48 +00:00
static GtkWidget *
gtk_text_handle_lookup_scrollable (GtkTextHandle *handle)
{
GtkTextHandlePrivate *priv;
GtkWidget *scrolled_window;
priv = handle->priv;
scrolled_window = gtk_widget_get_ancestor (priv->parent,
GTK_TYPE_SCROLLED_WINDOW);
if (!scrolled_window)
return NULL;
return gtk_bin_get_child (GTK_BIN (scrolled_window));
}
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
static void
_gtk_text_handle_parent_hierarchy_changed (GtkWidget *widget,
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
GParamSpec *pspec,
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
GtkTextHandle *handle)
{
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
GtkWidget *toplevel, *scrollable;
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
GtkTextHandlePrivate *priv;
priv = handle->priv;
toplevel = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
if (priv->toplevel && !toplevel)
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
{
if (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget)
{
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
_gtk_window_remove_popover (GTK_WINDOW (priv->toplevel),
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget);
g_object_unref (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget);
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget = NULL;
}
if (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget)
{
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
_gtk_window_remove_popover (GTK_WINDOW (priv->toplevel),
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget);
g_object_unref (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget);
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget = NULL;
}
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
priv->toplevel = NULL;
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
}
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
GtkTextHandle: Look up for the first child of a scrolled window found Text handles use to connect to the first GtkScrollable up the hierarchy so they can be repositioned when scrolling. It makes more sense to look up the first child of a GtkScrolledWindow, it must be an scrollable too, and will be the scrollable that can actually change the position of the text handles. https://bugzilla.gnome.org/show_bug.cgi?id=761676
2016-02-24 16:19:48 +00:00
scrollable = gtk_text_handle_lookup_scrollable (handle);
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
_gtk_text_handle_update_scrollable (handle, GTK_SCROLLABLE (scrollable));
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
}
static void
_gtk_text_handle_set_parent (GtkTextHandle *handle,
GtkWidget *parent)
{
GtkTextHandlePrivate *priv;
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
GtkWidget *scrollable = NULL;
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
priv = handle->priv;
if (priv->parent == parent)
return;
if (priv->parent && priv->hierarchy_changed_id &&
g_signal_handler_is_connected (priv->parent, priv->hierarchy_changed_id))
g_signal_handler_disconnect (priv->parent, priv->hierarchy_changed_id);
priv->parent = parent;
if (parent)
{
priv->hierarchy_changed_id =
text handle: Stop using ::hierarchy-changed Use notify::root instead.
2019-02-23 05:46:44 +00:00
g_signal_connect (parent, "notify::root",
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
G_CALLBACK (_gtk_text_handle_parent_hierarchy_changed),
handle);
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
GtkTextHandle: Look up for the first child of a scrolled window found Text handles use to connect to the first GtkScrollable up the hierarchy so they can be repositioned when scrolling. It makes more sense to look up the first child of a GtkScrolledWindow, it must be an scrollable too, and will be the scrollable that can actually change the position of the text handles. https://bugzilla.gnome.org/show_bug.cgi?id=761676
2016-02-24 16:19:48 +00:00
scrollable = gtk_text_handle_lookup_scrollable (handle);
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
}
texthandle: Track parent scrollable adjustments This makes sure texthandles follow the parent if it is contained within a GtkScrollable.
2014-01-22 15:39:10 +00:00
_gtk_text_handle_update_scrollable (handle, GTK_SCROLLABLE (scrollable));
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
}
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
static void
gtk_text_handle_finalize (GObject *object)
{
GtkTextHandlePrivate *priv;
priv = GTK_TEXT_HANDLE (object)->priv;
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
_gtk_text_handle_set_parent (GTK_TEXT_HANDLE (object), NULL);
popover: Fix memory management of popovers Popovers are strange in the sense that they aren't attached to a parent directly, they rely on the relative_to widget so the toplevel is shared, and when they have a parent, it is the toplevel itself, not relative_to. This also means that there are conditions where the popover loses it's parent, so they must survive unparenting. The previous code would be floating the last reference as soon as the parent is gone, but it was non-obvious who'd own that reference. So fix this situation by granting the ownership of popovers to their relative_to widget, an extra reference may be held by the toplevel when the popover has a parent, but the popover object will be guaranteed to be alive as long as the parent lives. This way, memory management of popovers is as hidden from the user as regular widgets within containers are, users are free to call gtk_widget_destroy() on a popover, but it'd eventually become destructed when relative_to is.
2014-01-09 16:21:43 +00:00
/* We sank the references, unref here */
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget)
popover: Fix memory management of popovers Popovers are strange in the sense that they aren't attached to a parent directly, they rely on the relative_to widget so the toplevel is shared, and when they have a parent, it is the toplevel itself, not relative_to. This also means that there are conditions where the popover loses it's parent, so they must survive unparenting. The previous code would be floating the last reference as soon as the parent is gone, but it was non-obvious who'd own that reference. So fix this situation by granting the ownership of popovers to their relative_to widget, an extra reference may be held by the toplevel when the popover has a parent, but the popover object will be guaranteed to be alive as long as the parent lives. This way, memory management of popovers is as hidden from the user as regular widgets within containers are, users are free to call gtk_widget_destroy() on a popover, but it'd eventually become destructed when relative_to is.
2014-01-09 16:21:43 +00:00
g_object_unref (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget)
popover: Fix memory management of popovers Popovers are strange in the sense that they aren't attached to a parent directly, they rely on the relative_to widget so the toplevel is shared, and when they have a parent, it is the toplevel itself, not relative_to. This also means that there are conditions where the popover loses it's parent, so they must survive unparenting. The previous code would be floating the last reference as soon as the parent is gone, but it was non-obvious who'd own that reference. So fix this situation by granting the ownership of popovers to their relative_to widget, an extra reference may be held by the toplevel when the popover has a parent, but the popover object will be guaranteed to be alive as long as the parent lives. This way, memory management of popovers is as hidden from the user as regular widgets within containers are, users are free to call gtk_widget_destroy() on a popover, but it'd eventually become destructed when relative_to is.
2014-01-09 16:21:43 +00:00
g_object_unref (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
G_OBJECT_CLASS (_gtk_text_handle_parent_class)->finalize (object);
}
static void
gtk_text_handle_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkTextHandle *handle;
handle = GTK_TEXT_HANDLE (object);
switch (prop_id)
{
case PROP_PARENT:
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
_gtk_text_handle_set_parent (handle, g_value_get_object (value));
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
gtk_text_handle_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkTextHandlePrivate *priv;
priv = GTK_TEXT_HANDLE (object)->priv;
switch (prop_id)
{
case PROP_PARENT:
g_value_set_object (value, priv->parent);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
_gtk_text_handle_class_init (GtkTextHandleClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gtk_text_handle_finalize;
object_class->set_property = gtk_text_handle_set_property;
object_class->get_property = gtk_text_handle_get_property;
signals[HANDLE_DRAGGED] =
g_signal_new (I_("handle-dragged"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextHandleClass, handle_dragged),
NULL, NULL,
_gtk_marshal_VOID__ENUM_INT_INT,
G_TYPE_NONE, 3,
GTK_TYPE_TEXT_HANDLE_POSITION,
G_TYPE_INT, G_TYPE_INT);
GtkTextHandle: add a drag-started signal This will be used to discriminate drags from taps.
2015-06-07 16:45:34 +00:00
signals[DRAG_STARTED] =
g_signal_new (I_("drag-started"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST, 0,
NULL, NULL,
gtk: rely on default marshallers Similar to previous removals of g_cclosure_marshal_VOID__VOID we can remove other marshallers for which are a simple G_TYPE_NONE with single parameter. In those cases, GLib will setup both a c_marshaller and va_marshaller for us. Before this commit, we would not get a va_marshaller because the c_marshaller is set. Related to GNOME/Initiatives#10
2019-05-31 03:56:50 +00:00
NULL,
GtkTextHandle: add a drag-started signal This will be used to discriminate drags from taps.
2015-06-07 16:45:34 +00:00
G_TYPE_NONE, 1,
GTK_TYPE_TEXT_HANDLE_POSITION);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
signals[DRAG_FINISHED] =
g_signal_new (I_("drag-finished"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST, 0,
NULL, NULL,
gtk: rely on default marshallers Similar to previous removals of g_cclosure_marshal_VOID__VOID we can remove other marshallers for which are a simple G_TYPE_NONE with single parameter. In those cases, GLib will setup both a c_marshaller and va_marshaller for us. Before this commit, we would not get a va_marshaller because the c_marshaller is set. Related to GNOME/Initiatives#10
2019-05-31 03:56:50 +00:00
NULL,
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
G_TYPE_NONE, 1,
GTK_TYPE_TEXT_HANDLE_POSITION);
g_object_class_install_property (object_class,
PROP_PARENT,
g_param_spec_object ("parent",
P_("Parent widget"),
P_("Parent widget"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
}
static void
_gtk_text_handle_init (GtkTextHandle *handle)
{
texthandle: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
handle->priv = _gtk_text_handle_get_instance_private (handle);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
GtkTextHandle *
_gtk_text_handle_new (GtkWidget *parent)
{
return g_object_new (GTK_TYPE_TEXT_HANDLE,
"parent", parent,
NULL);
}
void
_gtk_text_handle_set_mode (GtkTextHandle *handle,
GtkTextHandleMode mode)
{
GtkTextHandlePrivate *priv;
texthandle: small refactor These long enums are used too often, shorten things a bit with temp vars.
2015-10-14 15:41:12 +00:00
HandleWindow *start, *end;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
g_return_if_fail (GTK_IS_TEXT_HANDLE (handle));
priv = handle->priv;
if (priv->mode == mode)
return;
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
priv->mode = mode;
texthandle: small refactor These long enums are used too often, shorten things a bit with temp vars.
2015-10-14 15:41:12 +00:00
start = &priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START];
end = &priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END];
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
switch (mode)
{
case GTK_TEXT_HANDLE_MODE_CURSOR:
texthandle: small refactor These long enums are used too often, shorten things a bit with temp vars.
2015-10-14 15:41:12 +00:00
start->mode_visible = FALSE;
/* end = cursor */
end->mode_visible = TRUE;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
break;
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
case GTK_TEXT_HANDLE_MODE_SELECTION:
texthandle: small refactor These long enums are used too often, shorten things a bit with temp vars.
2015-10-14 15:41:12 +00:00
start->mode_visible = TRUE;
end->mode_visible = TRUE;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
break;
case GTK_TEXT_HANDLE_MODE_NONE:
default:
texthandle: small refactor These long enums are used too often, shorten things a bit with temp vars.
2015-10-14 15:41:12 +00:00
start->mode_visible = FALSE;
end->mode_visible = FALSE;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
break;
}
text handle: Port to CSS nodes Use cursor-handle as the element name for the CSS node that is used to render text the selection handles.
2015-11-10 04:33:54 +00:00
if (end->widget)
{
if (mode == GTK_TEXT_HANDLE_MODE_CURSOR)
gtk_style_context_add_class (gtk_widget_get_style_context (end->widget), GTK_STYLE_CLASS_INSERTION_CURSOR);
else
gtk_style_context_remove_class (gtk_widget_get_style_context (end->widget), GTK_STYLE_CLASS_INSERTION_CURSOR);
}
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
_gtk_text_handle_update (handle, GTK_TEXT_HANDLE_POSITION_SELECTION_START);
_gtk_text_handle_update (handle, GTK_TEXT_HANDLE_POSITION_SELECTION_END);
texthandle: Ensure handles are invalidated on mode changes Otherwise the "cursor" handle stays with "cursor" appearance instead of "selection end" when a text selection is started.
2015-10-14 15:27:53 +00:00
if (start->widget && start->mode_visible)
gtk_widget_queue_draw (start->widget);
if (end->widget && end->mode_visible)
gtk_widget_queue_draw (end->widget);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
GtkTextHandleMode
_gtk_text_handle_get_mode (GtkTextHandle *handle)
{
GtkTextHandlePrivate *priv;
g_return_val_if_fail (GTK_IS_TEXT_HANDLE (handle), GTK_TEXT_HANDLE_MODE_NONE);
priv = handle->priv;
return priv->mode;
}
void
_gtk_text_handle_set_position (GtkTextHandle *handle,
GtkTextHandlePosition pos,
GdkRectangle *rect)
{
GtkTextHandlePrivate *priv;
HandleWindow *handle_window;
g_return_if_fail (GTK_IS_TEXT_HANDLE (handle));
priv = handle->priv;
pos = CLAMP (pos, GTK_TEXT_HANDLE_POSITION_CURSOR,
GTK_TEXT_HANDLE_POSITION_SELECTION_START);
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
handle_window = &priv->windows[pos];
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
if (priv->mode == GTK_TEXT_HANDLE_MODE_NONE ||
(priv->mode == GTK_TEXT_HANDLE_MODE_CURSOR &&
pos != GTK_TEXT_HANDLE_POSITION_CURSOR))
return;
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
handle_window->pointing_to = *rect;
handle_window->has_point = TRUE;
texthandle: Set a bigger input shape, covering the line height Now, even if the handles being rendered are small, the handle touch input shape will be as wide as the visible part of the rendered asset, and high enough to cover both the handle and the height of the line where the selection bound is. Also, make handles have the same virtual distance to the line top/bottom when a drag starts, so the handle doesn't jump to another line after a too short threshold.
2013-01-11 16:22:02 +00:00
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (gtk_widget_is_visible (priv->parent))
_gtk_text_handle_update (handle, pos);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
void
_gtk_text_handle_set_visible (GtkTextHandle *handle,
GtkTextHandlePosition pos,
gboolean visible)
{
GtkTextHandlePrivate *priv;
g_return_if_fail (GTK_IS_TEXT_HANDLE (handle));
priv = handle->priv;
pos = CLAMP (pos, GTK_TEXT_HANDLE_POSITION_CURSOR,
GTK_TEXT_HANDLE_POSITION_SELECTION_START);
texthandles: Keep state internally to avoid X overhead Handles now do sync X calls less often. As visibility state is kept, it now can move+resize+show handles at once instead of in separated steps.
2012-11-07 13:23:04 +00:00
priv->windows[pos].user_visible = visible;
texthandles: Use GtkWindow popovers API This offers the same behavior, but GDK_WINDOW_TEMP windows aren't used anymore, involving less translations from/to root coordinates, plus no glitches in having handles snap to content as windows move.
2013-12-23 18:09:10 +00:00
if (gtk_widget_is_visible (priv->parent))
_gtk_text_handle_update (handle, pos);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
gboolean
_gtk_text_handle_get_is_dragged (GtkTextHandle *handle,
GtkTextHandlePosition pos)
{
GtkTextHandlePrivate *priv;
g_return_val_if_fail (GTK_IS_TEXT_HANDLE (handle), FALSE);
priv = handle->priv;
pos = CLAMP (pos, GTK_TEXT_HANDLE_POSITION_CURSOR,
GTK_TEXT_HANDLE_POSITION_SELECTION_START);
return priv->windows[pos].dragged;
}
texthandle: Handle ltr/rtl positioning This setting is per handle, as is dependent on the selected text, rather than the locale.
2015-06-10 18:52:02 +00:00
void
_gtk_text_handle_set_direction (GtkTextHandle *handle,
GtkTextHandlePosition pos,
GtkTextDirection dir)
{
GtkTextHandlePrivate *priv;
Fix return value error in _gtk_text_handle_set_direction https://bugzilla.gnome.org/show_bug.cgi?id=750888
2015-06-13 05:44:24 +00:00
g_return_if_fail (GTK_IS_TEXT_HANDLE (handle));
texthandle: Handle ltr/rtl positioning This setting is per handle, as is dependent on the selected text, rather than the locale.
2015-06-10 18:52:02 +00:00
priv = handle->priv;
pos = CLAMP (pos, GTK_TEXT_HANDLE_POSITION_CURSOR,
GTK_TEXT_HANDLE_POSITION_SELECTION_START);
priv->windows[pos].dir = dir;
if (priv->windows[pos].widget)
{
gtk_widget_set_direction (priv->windows[pos].widget, dir);
_gtk_text_handle_update (handle, pos);
}
}
Reference in New Issue Copy Permalink