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

503 lines
15 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"
stylecontext: Get rid of gtk_style_context_get() ... and replace all the calls to it with gtk_style_context_peek_property(). All the calls are hacks that need to go away btw.
2020-01-27 23:27:36 +00:00
#include "gtkcssnumbervalueprivate.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 "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 "gtkwidgetprivate.h"
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
#include "gtkrendericonprivate.h"
natives: Use GtkCssBoxes in get_surface_transform
2020-05-16 06:01:22 +00:00
#include "gtkcssboxesimplprivate.h"
#include "gtkcssnumbervalueprivate.h"
stylecontext: Get rid of gtk_style_context_get() ... and replace all the calls to it with gtk_style_context_peek_property(). All the calls are hacks that need to go away btw.
2020-01-27 23:27:36 +00:00
#include "gtkstylecontextprivate.h"
Make GtkNativeInterface private We are not sure yet if allowing out-of-tree implementations of GtkNative are a good idea.
2020-08-13 23:21:05 +00:00
#include "gtknativeprivate.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>
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
};
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
struct _GtkTextHandle
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: Drop the Private struct
2020-03-28 14:36:09 +00:00
GtkWidget parent_instance;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkWidget *parent;
GdkSurface *surface;
GskRenderer *renderer;
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;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int dx;
int dy;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
guint role : 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
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
};
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static void gtk_text_handle_native_interface_init (GtkNativeInterface *iface);
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
G_DEFINE_TYPE_WITH_CODE (GtkTextHandle, gtk_text_handle, GTK_TYPE_WIDGET,
G_IMPLEMENT_INTERFACE (GTK_TYPE_NATIVE,
gtk_text_handle_native_interface_init))
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static GdkSurface *
gtk_text_handle_native_get_surface (GtkNative *native)
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: Drop the Private struct
2020-03-28 14:36:09 +00:00
return GTK_TEXT_HANDLE (native)->surface;
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static GskRenderer *
gtk_text_handle_native_get_renderer (GtkNative *native)
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: Drop the Private struct
2020-03-28 14:36:09 +00:00
return GTK_TEXT_HANDLE (native)->renderer;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
static void
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_native_get_surface_transform (GtkNative *native,
Change coordinate translation apis to take doubles Change gtk_widget_translate_coordinates and gtk_native_get_surface_transform to operate on doubles. Update all callers.
2020-05-17 21:08:01 +00:00
double *x,
double *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
{
natives: Use GtkCssBoxes in get_surface_transform
2020-05-16 06:01:22 +00:00
GtkCssBoxes css_boxes;
const graphene_rect_t *margin_rect;
gtk_css_boxes_init (&css_boxes, GTK_WIDGET (native));
margin_rect = gtk_css_boxes_get_margin_rect (&css_boxes);
*x = - margin_rect->origin.x;
*y = - margin_rect->origin.y;
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
}
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
gizmo: return void from snapshot func This boolean return was from the old gadget code and we weren't using it in the new gizmo code.
2019-01-18 07:01:40 +00:00
static void
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_get_padding (GtkTextHandle *handle,
GtkBorder *border)
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkWidget *widget = GTK_WIDGET (handle);
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
context = gtk_widget_get_style_context (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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
border->left = _gtk_css_number_value_get (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_PADDING_LEFT), 100);
border->right = _gtk_css_number_value_get (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_PADDING_RIGHT), 100);
border->top = _gtk_css_number_value_get (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_PADDING_TOP), 100);
border->bottom = _gtk_css_number_value_get (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_PADDING_BOTTOM), 100);
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_present_surface (GtkTextHandle *handle)
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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkWidget *widget = GTK_WIDGET (handle);
GdkPopupLayout *layout;
GdkRectangle rect;
GtkRequisition req;
texthandle: Fix positioning Use the same approach we use for popovers, using gtk_widget_get_surface_allocation. It works. Fixes: #3319
2020-11-03 17:37:07 +00:00
GtkWidget *parent;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_get_preferred_size (widget, NULL, &req);
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
gtk_text_handle_get_padding (handle, &handle->border);
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
texthandle: Fix positioning Use the same approach we use for popovers, using gtk_widget_get_surface_allocation. It works. Fixes: #3319
2020-11-03 17:37:07 +00:00
parent = gtk_widget_get_parent (widget);
gtk_widget_get_surface_allocation (parent, &rect);
rect.x += handle->pointing_to.x;
rect.y += handle->pointing_to.y + handle->pointing_to.height - handle->border.top;
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
rect.width = req.width - handle->border.left - handle->border.right;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
rect.height = 1;
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->role == GTK_TEXT_HANDLE_ROLE_CURSOR)
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
rect.x -= rect.width / 2;
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
else if ((handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_END &&
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ||
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
(handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_START &&
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL))
rect.x -= rect.width;
layout = gdk_popup_layout_new (&rect,
GDK_GRAVITY_SOUTH,
GDK_GRAVITY_NORTH);
gdk_popup_layout_set_anchor_hints (layout,
GDK_ANCHOR_FLIP_Y | GDK_ANCHOR_SLIDE_X);
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
gdk_popup_present (GDK_POPUP (handle->surface),
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
MAX (req.width, 1),
MAX (req.height, 1),
layout);
gdk_popup_layout_unref (layout);
gtk_widget_allocate (widget,
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
gdk_surface_get_width (handle->surface),
gdk_surface_get_height (handle->surface),
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
-1, NULL);
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
}
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_native_check_resize (GtkNative *native)
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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle = GTK_TEXT_HANDLE (native);
GtkWidget *widget = GTK_WIDGET (native);
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
if (!_gtk_widget_get_alloc_needed (widget))
gtk_widget_ensure_allocate (widget);
else if (gtk_widget_get_visible (widget))
gtk_text_handle_present_surface (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
}
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_native_interface_init (GtkNativeInterface *iface)
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
iface->get_surface = gtk_text_handle_native_get_surface;
iface->get_renderer = gtk_text_handle_native_get_renderer;
iface->get_surface_transform = gtk_text_handle_native_get_surface_transform;
iface->check_resize = gtk_text_handle_native_check_resize;
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static gboolean
surface_render (GdkSurface *surface,
cairo_region_t *region,
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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_render (GTK_WIDGET (handle), surface, region);
return TRUE;
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static gboolean
surface_event (GdkSurface *surface,
GdkEvent *event,
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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_main_do_event (event);
return TRUE;
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
surface_mapped_changed (GtkWidget *widget)
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle = GTK_TEXT_HANDLE (widget);
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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
gtk_widget_set_visible (widget, gdk_surface_get_mapped (handle->surface));
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static void
gtk_text_handle_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkCssStyle *style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_css_style_snapshot_icon (style,
snapshot,
gtk_widget_get_width (widget),
gtk_widget_get_height (widget));
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
}
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_realize (GtkWidget *widget)
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle = GTK_TEXT_HANDLE (widget);
GdkSurface *parent_surface;
GtkWidget *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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
parent = gtk_widget_get_parent (widget);
parent_surface = gtk_native_get_surface (gtk_widget_get_native (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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
handle->surface = gdk_surface_new_popup (parent_surface, FALSE);
gdk_surface_set_widget (handle->surface, widget);
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
g_signal_connect_swapped (handle->surface, "notify::mapped",
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
G_CALLBACK (surface_mapped_changed), widget);
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
g_signal_connect (handle->surface, "render", G_CALLBACK (surface_render), widget);
g_signal_connect (handle->surface, "event", G_CALLBACK (surface_event), widget);
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GTK_WIDGET_CLASS (gtk_text_handle_parent_class)->realize (widget);
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
handle->renderer = gsk_renderer_new_for_surface (handle->surface);
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_unrealize (GtkWidget *widget)
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle = GTK_TEXT_HANDLE (widget);
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GTK_WIDGET_CLASS (gtk_text_handle_parent_class)->unrealize (widget);
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: Drop the Private struct
2020-03-28 14:36:09 +00:00
gsk_renderer_unrealize (handle->renderer);
g_clear_object (&handle->renderer);
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: Drop the Private struct
2020-03-28 14:36:09 +00:00
g_signal_handlers_disconnect_by_func (handle->surface, surface_render, widget);
g_signal_handlers_disconnect_by_func (handle->surface, surface_event, widget);
g_signal_handlers_disconnect_by_func (handle->surface, surface_mapped_changed, widget);
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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
gdk_surface_set_widget (handle->surface, NULL);
gdk_surface_destroy (handle->surface);
g_clear_object (&handle->surface);
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_map (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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle = GTK_TEXT_HANDLE (widget);
texthandle: ensure handles are recreated on parent hierarchy changes This ensures the handles come out right even if the parent widget is reparented to a different toplevel.
2014-01-22 15:33:47 +00:00
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GTK_WIDGET_CLASS (gtk_text_handle_parent_class)->map (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: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->has_point)
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_present_surface (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
}
static void
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_unmap (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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle = GTK_TEXT_HANDLE (widget);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GTK_WIDGET_CLASS (gtk_text_handle_parent_class)->unmap (widget);
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
gdk_surface_hide (handle->surface);
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
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: Remove min-width/height handling We do that automatically for all widgets.
2020-05-16 06:12:50 +00:00
*natural = 0;
*minimum = 0;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
*minimum_baseline = -1;
*natural_baseline = -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 void
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_class_init (GtkTextHandleClass *klass)
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
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
GObjectClass *object_class = G_OBJECT_CLASS (klass);
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
widget_class->snapshot = gtk_text_handle_snapshot;
widget_class->realize = gtk_text_handle_realize;
widget_class->unrealize = gtk_text_handle_unrealize;
widget_class->map = gtk_text_handle_map;
widget_class->unmap = gtk_text_handle_unmap;
widget_class->measure = gtk_text_handle_measure;
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[HANDLE_DRAGGED] =
g_signal_new (I_("handle-dragged"),
G_OBJECT_CLASS_TYPE (object_class),
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
G_SIGNAL_RUN_LAST, 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
NULL, NULL,
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
_gtk_marshal_VOID__INT_INT,
G_TYPE_NONE, 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
G_TYPE_INT, G_TYPE_INT);
GtkTextHandle: add a drag-started signal This will be used to discriminate drags from taps.
2015-06-07 16:45:34 +00:00
signals[DRAG_STARTED] =
g_signal_new (I_("drag-started"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST, 0,
NULL, NULL,
gtk: rely on default marshallers Similar to previous removals of g_cclosure_marshal_VOID__VOID we can remove other marshallers for which are a simple G_TYPE_NONE with single parameter. In those cases, GLib will setup both a c_marshaller and va_marshaller for us. Before this commit, we would not get a va_marshaller because the c_marshaller is set. Related to GNOME/Initiatives#10
2019-05-31 03:56:50 +00:00
NULL,
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
G_TYPE_NONE, 0, G_TYPE_NONE);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
signals[DRAG_FINISHED] =
g_signal_new (I_("drag-finished"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST, 0,
NULL, NULL,
gtk: rely on default marshallers Similar to previous removals of g_cclosure_marshal_VOID__VOID we can remove other marshallers for which are a simple G_TYPE_NONE with single parameter. In those cases, GLib will setup both a c_marshaller and va_marshaller for us. Before this commit, we would not get a va_marshaller because the c_marshaller is set. Related to GNOME/Initiatives#10
2019-05-31 03:56:50 +00:00
NULL,
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
G_TYPE_NONE, 0, G_TYPE_NONE);
gtktexthandle: Set css name on GtkWidgetClass Handles are their own widget, special names are not necessary anymore.
2020-04-25 00:56:38 +00:00
gtk_widget_class_set_css_name (widget_class, I_("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
}
static void
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
handle_drag_begin (GtkGestureDrag *gesture,
Replace "gdouble" with "double"
2020-07-24 20:32:16 +00:00
double x,
double y,
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->role == GTK_TEXT_HANDLE_ROLE_CURSOR)
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
x -= gtk_widget_get_width (widget) / 2;
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
else if ((handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_END &&
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ||
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
(handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_START &&
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL))
x -= gtk_widget_get_width (widget);
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
y += handle->border.top / 2;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
handle->dx = x;
handle->dy = y;
handle->dragged = TRUE;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
g_signal_emit (handle, signals[DRAG_STARTED], 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
}
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static void
handle_drag_update (GtkGestureDrag *gesture,
Replace "gdouble" with "double"
2020-07-24 20:32:16 +00:00
double offset_x,
double offset_y,
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +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
{
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
GtkTextHandle *handle = GTK_TEXT_HANDLE (widget);
Replace "gdouble" with "double"
2020-07-24 20:32:16 +00:00
double start_x, start_y;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int 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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_gesture_drag_get_start_point (gesture, &start_x, &start_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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
x = handle->pointing_to.x + handle->pointing_to.width / 2 +
start_x + offset_x - handle->dx;
y = handle->pointing_to.y + handle->pointing_to.height +
start_y + offset_y - handle->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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->role == GTK_TEXT_HANDLE_ROLE_CURSOR)
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
x -= gtk_widget_get_width (widget) / 2;
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
else if ((handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_END &&
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ||
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
(handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_START &&
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_widget_get_direction (widget) != GTK_TEXT_DIR_RTL))
x -= gtk_widget_get_width (widget);
g_signal_emit (widget, signals[HANDLE_DRAGGED], 0, x, y);
}
static void
handle_drag_end (GtkGestureDrag *gesture,
Replace "gdouble" with "double"
2020-07-24 20:32:16 +00:00
double offset_x,
double offset_y,
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *handle)
{
g_signal_emit (handle, signals[DRAG_FINISHED], 0);
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
handle->dragged = FALSE;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static void
gtk_text_handle_update_for_role (GtkTextHandle *handle)
{
GtkWidget *widget = GTK_WIDGET (handle);
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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->role == GTK_TEXT_HANDLE_ROLE_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
{
Drop style class defines We document the supported style classes by name, not by macro name, and these macros don't really add any value. Drop them for GTK 4.
2020-08-13 23:49:02 +00:00
gtk_widget_remove_css_class (widget, "top");
gtk_widget_add_css_class (widget, "bottom");
gtk_widget_add_css_class (widget, "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
}
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
else if (handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_END)
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
{
Drop style class defines We document the supported style classes by name, not by macro name, and these macros don't really add any value. Drop them for GTK 4.
2020-08-13 23:49:02 +00:00
gtk_widget_remove_css_class (widget, "top");
gtk_widget_add_css_class (widget, "bottom");
gtk_widget_remove_css_class (widget, "insertion-cursor");
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
}
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
else if (handle->role == GTK_TEXT_HANDLE_ROLE_SELECTION_START)
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
{
Drop style class defines We document the supported style classes by name, not by macro name, and these macros don't really add any value. Drop them for GTK 4.
2020-08-13 23:49:02 +00:00
gtk_widget_add_css_class (widget, "top");
gtk_widget_remove_css_class (widget, "bottom");
gtk_widget_remove_css_class (widget, "insertion-cursor");
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
static void
gtk_text_handle_init (GtkTextHandle *widget)
{
GtkEventController *controller;
controller = GTK_EVENT_CONTROLLER (gtk_gesture_drag_new ());
g_signal_connect (controller, "drag-begin",
G_CALLBACK (handle_drag_begin), widget);
g_signal_connect (controller, "drag-update",
G_CALLBACK (handle_drag_update), widget);
g_signal_connect (controller, "drag-end",
G_CALLBACK (handle_drag_end), widget);
gtk_widget_add_controller (GTK_WIDGET (widget), controller);
gtk_text_handle_update_for_role (GTK_TEXT_HANDLE (widget));
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandle *
gtk_text_handle_new (GtkWidget *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
{
gtktexthandle: Set parent through API call The GtkWidget::parent property went readonly, use the API call to ensure the text handle has a parent set.
2020-04-24 22:09:41 +00:00
GtkTextHandle *handle;
gtktexthandle: Set css name on GtkWidgetClass Handles are their own widget, special names are not necessary anymore.
2020-04-25 00:56:38 +00:00
handle = g_object_new (GTK_TYPE_TEXT_HANDLE, NULL);
gtktexthandle: Set parent through API call The GtkWidget::parent property went readonly, use the API call to ensure the text handle has a parent set.
2020-04-24 22:09:41 +00:00
gtk_widget_set_parent (GTK_WIDGET (handle), parent);
return 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
}
void
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_set_role (GtkTextHandle *handle,
GtkTextHandleRole role)
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));
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->role == role)
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;
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
handle->role = role;
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_update_for_role (handle);
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
if (gtk_widget_get_visible (GTK_WIDGET (handle)))
{
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->has_point)
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gtk_text_handle_present_surface (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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
GtkTextHandleRole
gtk_text_handle_get_role (GtkTextHandle *handle)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
g_return_val_if_fail (GTK_IS_TEXT_HANDLE (handle), GTK_TEXT_HANDLE_ROLE_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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
return handle->role;
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
void
gtk_text_handle_set_position (GtkTextHandle *handle,
const GdkRectangle *rect)
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: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
g_return_if_fail (GTK_IS_TEXT_HANDLE (handle));
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
if (handle->pointing_to.x == rect->x &&
handle->pointing_to.y == rect->y &&
handle->pointing_to.width == rect->width &&
handle->pointing_to.height == rect->height)
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
return;
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: Drop the Private struct
2020-03-28 14:36:09 +00:00
handle->pointing_to = *rect;
handle->has_point = 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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
if (gtk_widget_is_visible (GTK_WIDGET (handle)))
gtk_text_handle_present_surface (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
}
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
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
gboolean
gtk_text_handle_get_is_dragged (GtkTextHandle *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
{
gtktexthandle: Refactor and use native surfaces Instead of being a GObject managing two GtkWidgets, make GtkTextHandle a GtkWidget subclass, representing a single handle. From the perspective of users (GtkText and GtkTextView), this is not a big leap since they have to be aware of a great deal of text handles' state. It actually makes things more direct and simple. With text handles being widgets, those can be actual children of the widget, and may have their own GdkSurface that we move around at will. This is the second major aspect of this refactor.
2020-02-03 14:59:49 +00:00
g_return_val_if_fail (GTK_IS_TEXT_HANDLE (handle), FALSE);
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
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
return handle->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
}
Reference in New Issue Copy Permalink