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

770 lines
23 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"
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 {
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;
gint dx;
gint dy;
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
_gtk_text_handle_get_size (GtkTextHandle *handle,
gint *width,
gint *height)
{
GtkTextHandlePrivate *priv;
gint w, h;
priv = handle->priv;
gtk_widget_style_get (priv->parent,
"text-handle-width", &w,
"text-handle-height", &h,
NULL);
if (width)
*width = w;
if (height)
*height = h;
}
static void
_gtk_text_handle_draw (GtkTextHandle *handle,
cairo_t *cr,
GtkTextHandlePosition pos)
{
GtkTextHandlePrivate *priv;
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;
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
context = gtk_widget_get_style_context (priv->windows[pos].widget);
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
_gtk_text_handle_get_size (handle, &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);
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
if (pos == GTK_TEXT_HANDLE_POSITION_SELECTION_END)
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
cairo_translate (cr, width, priv->windows[pos].pointing_to.height);
else
cairo_translate (cr, width, height);
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: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
gtk_style_context_save (context);
gtk_style_context_add_class (context,
Improve CSS styling of touch text selection handles Don't hook on the widget style context and set up instead a widget path for itself. Also use a common style class for both handles, with an extra top/bottom class for each handle.
2012-09-03 15:03:52 +00:00
GTK_STYLE_CLASS_CURSOR_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
if (pos == GTK_TEXT_HANDLE_POSITION_SELECTION_END)
texthandles: Add an extra style class to the cursor-mode handle Themes may want to render handles differently depending on whether the widget is in selection mode (2 handles enclosing a selection) or cursor mode (one handle pointing out the insertion cursor).
2012-10-26 15:57:03 +00:00
{
texthandle: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
gtk_style_context_add_class (context,
texthandles: Add an extra style class to the cursor-mode handle Themes may want to render handles differently depending on whether the widget is in selection mode (2 handles enclosing a selection) or cursor mode (one handle pointing out the insertion cursor).
2012-10-26 15:57:03 +00:00
GTK_STYLE_CLASS_BOTTOM);
if (priv->mode == GTK_TEXT_HANDLE_MODE_CURSOR)
texthandle: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
gtk_style_context_add_class (context,
texthandles: Add an extra style class to the cursor-mode handle Themes may want to render handles differently depending on whether the widget is in selection mode (2 handles enclosing a selection) or cursor mode (one handle pointing out the insertion cursor).
2012-10-26 15:57:03 +00:00
GTK_STYLE_CLASS_INSERTION_CURSOR);
}
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
texthandle: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
gtk_style_context_add_class (context,
Improve CSS styling of touch text selection handles Don't hook on the widget style context and set up instead a widget path for itself. Also use a common style class for both handles, with an extra top/bottom class for each handle.
2012-09-03 15:03:52 +00:00
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
texthandle: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
gtk_render_background (context, cr, 0, 0, width, height);
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_frame (context, cr, 0, 0, width, height);
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
texthandle: Use the parent widget's style context ... instead of creating our own.
2013-10-01 13:08:30 +00:00
gtk_style_context_restore (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
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;
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,
GtkStateFlags state)
{
GtkTextHandlePrivate *priv;
gint i;
priv = handle->priv;
for (i = 0; i <= GTK_TEXT_HANDLE_POSITION_SELECTION_START; i++)
{
if (!priv->windows[i].widget)
continue;
gtk_widget_set_state_flags (priv->windows[i].widget, state, TRUE);
gtk_widget_queue_draw (priv->windows[i].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
static gboolean
gtk_text_handle_widget_event (GtkWidget *widget,
GdkEvent *event,
GtkTextHandle *handle)
{
GtkTextHandlePrivate *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
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
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;
if (event->type == GDK_BUTTON_PRESS)
{
priv->windows[pos].dx = event->button.x;
priv->windows[pos].dy = event->button.y;
priv->windows[pos].dragged = TRUE;
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
gtk_text_handle_set_state (handle, 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
}
else if (event->type == GDK_BUTTON_RELEASE)
{
g_signal_emit (handle, signals[DRAG_FINISHED], 0, pos);
priv->windows[pos].dragged = FALSE;
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
gtk_text_handle_set_state (handle, GTK_STATE_FLAG_NORMAL);
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
else if (event->type == GDK_MOTION_NOTIFY &&
event->motion.state & GDK_BUTTON1_MASK &&
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: 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
gint x, y, width, height, handle_height;
GtkAllocation allocation;
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: 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);
width = allocation.width;
height = allocation.height;
_gtk_text_handle_get_size (handle, NULL, &handle_height);
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
x = event->motion.x - priv->windows[pos].dx + (width / 2);
y = event->motion.y - priv->windows[pos].dy;
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 != GTK_TEXT_HANDLE_POSITION_CURSOR)
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
y += height - handle_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
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
y += priv->windows[pos].pointing_to.height / 2;
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_translate_coordinates (widget, 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;
widget = gtk_event_box_new ();
gtk_widget_set_events (widget,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK);
g_signal_connect (widget, "draw",
G_CALLBACK (gtk_text_handle_widget_draw), handle);
g_signal_connect (widget, "event",
G_CALLBACK (gtk_text_handle_widget_event), handle);
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);
texthandle: Use GtkWindow private popover API.
2014-01-17 17:12:57 +00:00
_gtk_window_add_popover (GTK_WINDOW (window), widget);
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
gtk_style_context_set_parent (gtk_widget_get_style_context (widget),
gtk_widget_get_style_context (priv->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
}
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;
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];
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;
GtkPositionType handle_pos;
gint width, height;
GtkWidget *window;
_gtk_text_handle_ensure_widget (handle, pos);
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
_gtk_text_handle_get_size (handle, &width, &height);
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
rect.x = handle_window->pointing_to.x;
rect.y = handle_window->pointing_to.y;
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
rect.width = width;
rect.height = 0;
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
/* Make the window 3 times as wide, and 2 times as high (plus
* handle_window->pointing_to.height), the handle will be rendered
* in the center. Making the rest an invisible input area.
*/
width *= 3;
height *= 2;
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: 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 == GTK_TEXT_HANDLE_POSITION_CURSOR)
handle_pos = GTK_POS_BOTTOM;
else
{
handle_pos = GTK_POS_TOP;
rect.y += handle_window->pointing_to.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
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
height += handle_window->pointing_to.height;
rect.x -= rect.width / 2;
gtk_widget_set_size_request (handle_window->widget, width, height);
gtk_widget_show (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,
handle_pos, &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;
if (priv->parent_scrollable)
{
if (priv->vadj)
{
g_signal_handlers_disconnect_by_data (priv->vadj, handle);
g_object_unref (priv->vadj);
priv->vadj = NULL;
}
if (priv->hadj)
{
g_signal_handlers_disconnect_by_data (priv->hadj, handle);
g_object_unref (priv->hadj);
priv->hadj = NULL;
}
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_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);
}
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
scrollable = gtk_widget_get_ancestor (widget, GTK_TYPE_SCROLLABLE);
_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
scrollable = gtk_widget_get_ancestor (parent, GTK_TYPE_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
}
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);
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;
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;
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:
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[GTK_TEXT_HANDLE_POSITION_CURSOR].mode_visible = TRUE;
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].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;
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:
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].mode_visible = TRUE;
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_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:
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[GTK_TEXT_HANDLE_POSITION_SELECTION_START].mode_visible = FALSE;
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_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;
}
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);
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;
}
Reference in New Issue Copy Permalink