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

521 lines
16 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 "gtkcssnodeprivate.h"
#include "gtkwidgetprivate.h"
gtktexthandle: Update to gtk4 rendering/input GtkTextHandle was neglected by whoever removed the ::draw signal, leaving it entirely broken. Update to using GtkGizmo so we can implement snapshot of text handles. Input has received a revamp too, handling is done through a GtkGestureDrag and coordinate calculations simplified by storing the delta to the hotspot on ::begin instead of ::update, as this value is constant throughout the gesture. Widget state management on crossing events happens implicitly, so no longer needs to be done here. Last but not least, CSS has also been updated so handles are rendered at the correct size and proportion, and with the padding that code expects of it.
2018-06-12 10:33:03 +00:00
#include "gtkrendericonprivate.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"
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;
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
gint dx;
gint dy;
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,
int *x,
int *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
GtkCssStyle *style;
style = gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (native)));
*x = _gtk_css_number_value_get (style->size->margin_left, 100) +
_gtk_css_number_value_get (style->border->border_left_width, 100) +
_gtk_css_number_value_get (style->size->padding_left, 100);
*y = _gtk_css_number_value_get (style->size->margin_top, 100) +
_gtk_css_number_value_get (style->border->border_top_width, 100) +
_gtk_css_number_value_get (style->size->padding_top, 100);
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
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_get_size (GtkTextHandle *handle,
gint *width,
gint *height)
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);
texthandle: Use the handle widget style context for rendering Using the parent widget context is a leftover of the pre-popover implementation, which used GdkWindows directly. This will make the context reflect widget state, at the expense of changing the selector paths that used to match the handles.
2014-11-20 12:41:24 +00:00
gtktexthandle: 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 (width)
*width = _gtk_css_number_value_get (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_MIN_WIDTH), 100);
if (height)
*height = _gtk_css_number_value_get (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_MIN_HEIGHT), 100);
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
}
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;
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: Drop the Private struct
2020-03-28 14:36:09 +00:00
rect.x = handle->pointing_to.x;
rect.y = handle->pointing_to.y + handle->pointing_to.height - handle->border.top;
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;
gtk_widget_translate_coordinates (gtk_widget_get_parent (widget),
gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW),
texthandle: Update child visibility of handles within scrollables If the rect a handle points to starts falling outside of the parent scrollable allocation, the handle will be automatically hidden, and shown again when the rectangle is visible too.
2014-01-22 15:41:00 +00:00
rect.x, rect.y, &rect.x, &rect.y);
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
{
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
gint size;
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 (orientation == GTK_ORIENTATION_VERTICAL)
gtk_text_handle_get_size (GTK_TEXT_HANDLE (widget), NULL, &size);
else
gtk_text_handle_get_size (GTK_TEXT_HANDLE (widget), &size, NULL);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
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
*natural = size;
*minimum = size;
*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);
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,
gdouble x,
gdouble y,
GtkTextHandle *handle)
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
{
gtktexthandle: 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,
gdouble offset_x,
gdouble offset_y,
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);
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
gdouble start_x, start_y;
gint 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,
gdouble offset_x,
gdouble offset_y,
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
{
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_remove_css_class (widget, GTK_STYLE_CLASS_TOP);
gtk_widget_add_css_class (widget, GTK_STYLE_CLASS_BOTTOM);
gtk_widget_add_css_class (widget, GTK_STYLE_CLASS_INSERTION_CURSOR);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
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
{
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_remove_css_class (widget, GTK_STYLE_CLASS_TOP);
gtk_widget_add_css_class (widget, GTK_STYLE_CLASS_BOTTOM);
gtk_widget_remove_css_class (widget, GTK_STYLE_CLASS_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
{
gtk_widget_add_css_class (widget, GTK_STYLE_CLASS_TOP);
gtk_widget_remove_css_class (widget, GTK_STYLE_CLASS_BOTTOM);
gtk_widget_remove_css_class (widget, GTK_STYLE_CLASS_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
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
{
texthandle: Drop the Private struct
2020-03-28 14:36:09 +00:00
return g_object_new (GTK_TYPE_TEXT_HANDLE,
"parent", parent,
"css-name", I_("cursor-handle"),
NULL);
Add GtkTextHandle This is a helper object to allow text widgets to implement text selection on touch devices. It allows for both cursor placement and text selection, displaying draggable handles on/around the cursor and selection bound positions. Currently, this is private to GTK+, and only available to GtkEntry and GtkTextView.
2012-07-11 13:51:43 +00:00
}
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