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

889 lines
28 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"
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];
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
}
static void
_gtk_text_handle_draw (GtkTextHandle *handle,
cairo_t *cr,
GtkTextHandlePosition pos)
{
GtkTextHandlePrivate *priv;
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
HandleWindow *handle_window;
texthandle: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
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
gint width, height;
priv = handle->priv;
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
handle_window = &priv->windows[pos];
context = gtk_widget_get_style_context (handle_window->widget);
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: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +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
cairo_save (cr);
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
cairo_translate (cr, handle_window->border.left, handle_window->border.top);
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
GtkTextHandle: Better draw() implementation Conceptually, text handles are boxes, whose content is a 'handle', so draw background, frame and handle. With this, and the previous commit, the cursor-handle theming in Adwaita now works as intended.
2014-07-13 17:57:23 +00:00
gtk_render_handle (context, cr, 0, 0, width, 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
cairo_restore (cr);
}
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
}
static gboolean
gtk_text_handle_widget_draw (GtkWidget *widget,
cairo_t *cr,
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
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
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
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 (pos < 0)
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
return FALSE;
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
#if 0
/* Show the invisible border */
cairo_set_source_rgba (cr, 1, 0, 0, 0.5);
cairo_paint (cr);
#endif
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_draw (handle, cr, pos);
return 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
}
texthandle: Use active state when handles are being dragged The active state flags is set on both handles when this happens.
2014-11-20 12:46:30 +00:00
static void
gtk_text_handle_set_state (GtkTextHandle *handle,
texthandle: Allow setting individual states, and separately to handles Now each handle gets its individual current state, and we can accumulate more than one state on these. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:46:20 +00:00
gint pos,
texthandle: Use active state when handles are being dragged The active state flags is set on both handles when this happens.
2014-11-20 12:46:30 +00:00
GtkStateFlags state)
{
texthandle: Allow setting individual states, and separately to handles Now each handle gets its individual current state, and we can accumulate more than one state on these. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:46:20 +00:00
GtkTextHandlePrivate *priv = handle->priv;
texthandle: Use active state when handles are being dragged The active state flags is set on both handles when this happens.
2014-11-20 12:46:30 +00:00
texthandle: Allow setting individual states, and separately to handles Now each handle gets its individual current state, and we can accumulate more than one state on these. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:46:20 +00:00
if (!priv->windows[pos].widget)
return;
texthandle: Use active state when handles are being dragged The active state flags is set on both handles when this happens.
2014-11-20 12:46:30 +00:00
texthandle: Allow setting individual states, and separately to handles Now each handle gets its individual current state, and we can accumulate more than one state on these. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:46:20 +00:00
gtk_widget_set_state_flags (priv->windows[pos].widget, state, FALSE);
gtk_widget_queue_draw (priv->windows[pos].widget);
}
texthandle: Use active state when handles are being dragged The active state flags is set on both handles when this happens.
2014-11-20 12:46:30 +00:00
texthandle: Allow setting individual states, and separately to handles Now each handle gets its individual current state, and we can accumulate more than one state on these. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:46:20 +00:00
static void
gtk_text_handle_unset_state (GtkTextHandle *handle,
gint pos,
GtkStateFlags state)
{
GtkTextHandlePrivate *priv = handle->priv;
if (!priv->windows[pos].widget)
return;
gtk_widget_unset_state_flags (priv->windows[pos].widget, state);
gtk_widget_queue_draw (priv->windows[pos].widget);
texthandle: Use active state when handles are being dragged The active state flags is set on both handles when this happens.
2014-11-20 12:46:30 +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 gboolean
gtk_text_handle_widget_event (GtkWidget *widget,
GdkEvent *event,
GtkTextHandle *handle)
{
GtkTextHandlePrivate *priv;
texthandle: Update to using GdkEvent API
2017-08-25 14:55:39 +00:00
GdkEventType event_type;
gdouble event_x, event_y;
guint state;
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;
text handle: Use GdkEvent API
2017-08-26 16:22:35 +00:00
GdkCrossingMode mode;
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
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
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
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 (pos < 0)
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
return FALSE;
texthandle: Update to using GdkEvent API
2017-08-25 14:55:39 +00:00
event_type = gdk_event_get_event_type (event);
gdk_event_get_coords (event, &event_x, &event_y);
text handle: Use GdkEvent API
2017-08-26 16:22:35 +00:00
gdk_event_get_crossing_mode (event, &mode);
texthandle: Update to using GdkEvent API
2017-08-25 14:55:39 +00:00
if (event_type == GDK_BUTTON_PRESS)
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 to using GdkEvent API
2017-08-25 14:55:39 +00:00
priv->windows[pos].dx = event_x;
priv->windows[pos].dy = event_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
priv->windows[pos].dragged = TRUE;
texthandle: Allow setting individual states, and separately to handles Now each handle gets its individual current state, and we can accumulate more than one state on these. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:46:20 +00:00
gtk_text_handle_set_state (handle, pos, GTK_STATE_FLAG_ACTIVE);
GtkTextHandle: add a drag-started signal This will be used to discriminate drags from taps.
2015-06-07 16:45:34 +00:00
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
}
texthandle: Update to using GdkEvent API
2017-08-25 14:55:39 +00:00
else if (event_type == GDK_BUTTON_RELEASE)
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_signal_emit (handle, signals[DRAG_FINISHED], 0, pos);
priv->windows[pos].dragged = FALSE;
texthandle: Allow setting individual states, and separately to handles Now each handle gets its individual current state, and we can accumulate more than one state on these. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:46:20 +00:00
gtk_text_handle_unset_state (handle, pos, GTK_STATE_FLAG_ACTIVE);
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 to using GdkEvent API
2017-08-25 14:55:39 +00:00
else if (event_type == GDK_ENTER_NOTIFY)
texthandle: Set prelight state on the pointer-interacted handle This will be useful with the theming changes to come. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:49:33 +00:00
gtk_text_handle_set_state (handle, pos, GTK_STATE_FLAG_PRELIGHT);
texthandle: Update to using GdkEvent API
2017-08-25 14:55:39 +00:00
else if (event_type == GDK_LEAVE_NOTIFY)
texthandle: Set prelight state on the pointer-interacted handle This will be useful with the theming changes to come. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:49:33 +00:00
{
if (!priv->windows[pos].dragged &&
text handle: Use GdkEvent API
2017-08-26 16:22:35 +00:00
(mode == GDK_CROSSING_NORMAL ||
mode == GDK_CROSSING_UNGRAB))
texthandle: Set prelight state on the pointer-interacted handle This will be useful with the theming changes to come. https://bugzilla.gnome.org/show_bug.cgi?id=750396
2015-06-04 17:49:33 +00:00
gtk_text_handle_unset_state (handle, pos, GTK_STATE_FLAG_PRELIGHT);
}
texthandle: Update to using GdkEvent API
2017-08-25 14:55:39 +00:00
else if (event_type == GDK_MOTION_NOTIFY &&
gdk_event_get_state (event, &state) &&
state & GDK_BUTTON1_MASK &&
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
priv->windows[pos].dragged)
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: Fix handle dragging on wayland Text handles are subsurfaces on wayland, so sort of their own toplevel. This made gtk_widget_translate_coordinates() to bail out there, resulting in text handles being mispositioned and jumpy. To fix this, translate to toplevel GtkWindow coordinates manually, and translate coordinates from there. Along the way, the coordinates reported in ::handle-dragged have been fixed so there is no small jumps in either axis (most noticeable in the X axis when you started dragging, and in the Y axis when moving between lines of different heights.
2015-10-14 13:53:51 +00:00
gint x, y, handle_width, handle_height;
cairo_rectangle_int_t rect;
texthandle: Mind the invisible area when moving the handle The handle is still centered horizontally, but the extra vertical space wasn't taken into account, leading to misplacing the dragging point (and the handle) during motion events.
2014-05-21 12:58:50 +00:00
GtkAllocation allocation;
texthandle: Fix handle dragging on wayland Text handles are subsurfaces on wayland, so sort of their own toplevel. This made gtk_widget_translate_coordinates() to bail out there, resulting in text handles being mispositioned and jumpy. To fix this, translate to toplevel GtkWindow coordinates manually, and translate coordinates from there. Along the way, the coordinates reported in ::handle-dragged have been fixed so there is no small jumps in either axis (most noticeable in the X axis when you started dragging, and in the Y axis when moving between lines of different heights.
2015-10-14 13:53:51 +00:00
GtkWidget *window;
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: Fix handle dragging on wayland Text handles are subsurfaces on wayland, so sort of their own toplevel. This made gtk_widget_translate_coordinates() to bail out there, resulting in text handles being mispositioned and jumpy. To fix this, translate to toplevel GtkWindow coordinates manually, and translate coordinates from there. Along the way, the coordinates reported in ::handle-dragged have been fixed so there is no small jumps in either axis (most noticeable in the X axis when you started dragging, and in the Y axis when moving between lines of different heights.
2015-10-14 13:53:51 +00:00
window = gtk_widget_get_parent (priv->windows[pos].widget);
texthandle: Mind the invisible area when moving the handle The handle is still centered horizontally, but the extra vertical space wasn't taken into account, leading to misplacing the dragging point (and the handle) during motion events.
2014-05-21 12:58:50 +00:00
gtk_widget_get_allocation (priv->windows[pos].widget, &allocation);
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, &handle_width, &handle_height);
texthandle: Fix handle dragging on wayland Text handles are subsurfaces on wayland, so sort of their own toplevel. This made gtk_widget_translate_coordinates() to bail out there, resulting in text handles being mispositioned and jumpy. To fix this, translate to toplevel GtkWindow coordinates manually, and translate coordinates from there. Along the way, the coordinates reported in ::handle-dragged have been fixed so there is no small jumps in either axis (most noticeable in the X axis when you started dragging, and in the Y axis when moving between lines of different heights.
2015-10-14 13:53:51 +00:00
_gtk_window_get_popover_position (GTK_WINDOW (window),
priv->windows[pos].widget,
NULL, &rect);
texthandle: Update to using GdkEvent API
2017-08-25 14:55:39 +00:00
x = rect.x + event_x - priv->windows[pos].dx;
y = rect.y + event_y - priv->windows[pos].dy +
texthandle: Fix handle dragging on wayland Text handles are subsurfaces on wayland, so sort of their own toplevel. This made gtk_widget_translate_coordinates() to bail out there, resulting in text handles being mispositioned and jumpy. To fix this, translate to toplevel GtkWindow coordinates manually, and translate coordinates from there. Along the way, the coordinates reported in ::handle-dragged have been fixed so there is no small jumps in either axis (most noticeable in the X axis when you started dragging, and in the Y axis when moving between lines of different heights.
2015-10-14 13:53:51 +00:00
priv->windows[pos].border.top / 2;
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: Fix handle dragging on wayland Text handles are subsurfaces on wayland, so sort of their own toplevel. This made gtk_widget_translate_coordinates() to bail out there, resulting in text handles being mispositioned and jumpy. To fix this, translate to toplevel GtkWindow coordinates manually, and translate coordinates from there. Along the way, the coordinates reported in ::handle-dragged have been fixed so there is no small jumps in either axis (most noticeable in the X axis when you started dragging, and in the Y axis when moving between lines of different heights.
2015-10-14 13:53:51 +00:00
if (pos == GTK_TEXT_HANDLE_POSITION_CURSOR &&
priv->mode == GTK_TEXT_HANDLE_MODE_CURSOR)
x += handle_width / 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 += handle_width;
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
texthandle: Fix handle dragging on wayland Text handles are subsurfaces on wayland, so sort of their own toplevel. This made gtk_widget_translate_coordinates() to bail out there, resulting in text handles being mispositioned and jumpy. To fix this, translate to toplevel GtkWindow coordinates manually, and translate coordinates from there. Along the way, the coordinates reported in ::handle-dragged have been fixed so there is no small jumps in either axis (most noticeable in the X axis when you started dragging, and in the Y axis when moving between lines of different heights.
2015-10-14 13:53:51 +00:00
gtk_widget_translate_coordinates (window, priv->parent, x, y, &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
g_signal_emit (handle, signals[HANDLE_DRAGGED], 0, pos, x, y);
}
return TRUE;
}
static void
texthandle: Fix arguments in ::style-updated callback
2014-01-09 17:39:45 +00:00
gtk_text_handle_widget_style_updated (GtkWidget *widget,
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
{
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
GtkTextHandlePrivate *priv;
priv = handle->priv;
gtk_style_context_set_parent (gtk_widget_get_style_context (widget),
gtk_widget_get_style_context (priv->parent));
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);
}
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;
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: Don't use GtkEventBox
2017-08-02 15:58:47 +00:00
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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
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);
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
g_signal_connect (widget, "draw",
G_CALLBACK (gtk_text_handle_widget_draw), handle);
text handler: Stop using GtkWidget::event This signal is going away.
2017-12-31 03:38:14 +00:00
g_signal_connect (widget, "button-press-event", G_CALLBACK (gtk_text_handle_widget_event), handle);
g_signal_connect (widget, "button-release-event", G_CALLBACK (gtk_text_handle_widget_event), handle);
g_signal_connect (widget, "enter-notify-event", G_CALLBACK (gtk_text_handle_widget_event), handle);
g_signal_connect (widget, "leave-notify-event", G_CALLBACK (gtk_text_handle_widget_event), handle);
g_signal_connect (widget, "motion-notify-event", G_CALLBACK (gtk_text_handle_widget_event), 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
g_signal_connect (widget, "style-updated",
G_CALLBACK (gtk_text_handle_widget_style_updated),
handle);
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);
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_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));
gtk_css_node_set_name (gtk_widget_get_css_node (widget), I_("cursor-handle"));
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,
GtkWindow *previous_toplevel,
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);
if (previous_toplevel && !toplevel)
{
if (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget)
{
_gtk_window_remove_popover (GTK_WINDOW (previous_toplevel),
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)
{
_gtk_window_remove_popover (GTK_WINDOW (previous_toplevel),
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;
}
}
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 =
g_signal_connect (parent, "hierarchy-changed",
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,
g_cclosure_marshal_VOID__ENUM,
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,
g_cclosure_marshal_VOID__ENUM,
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