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

2492 lines
74 KiB
C
Raw Normal View History

Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
/* GTK - The GIMP Toolkit
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
* Copyright (C) 2019 Red Hat, Inc.
*
* Authors:
* - Matthias Clasen <mclasen@redhat.com>
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
* 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/>.
*/
popover: Add documentation
2013-11-13 14:11:21 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* GtkPopover:
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* `GtkPopover` is a bubble-like context popup.
*
* ![An example GtkPopover](popover.png)
*
* It is primarily meant to provide context-dependent information
* or options. Popovers are attached to a parent widget. By default,
* they point to the whole widget area, although this behavior can be
* changed with [method@Gtk.Popover.set_pointing_to].
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
popover: Add documentation
2013-11-13 14:11:21 +00:00
* The position of a popover relative to the widget it is attached to
popover: Convert docs
2021-02-27 04:15:43 +00:00
* can also be changed with [method@Gtk.Popover.set_position]
popover: Add documentation
2013-11-13 14:11:21 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* By default, `GtkPopover` performs a grab, in order to ensure input
* events get redirected to it while it is shown, and also so the popover
* is dismissed in the expected situations (clicks outside the popover,
* or the Escape key being pressed). If no such modal behavior is desired
* on a popover, [method@Gtk.Popover.set_autohide] may be called on it to
* tweak its behavior.
popover: Fix documentation blurb The grabbing behavior is no longer exclusively controlled by the caller, mention gtk_popover_set_modal().
2014-01-22 15:26:13 +00:00
*
Document iconic section support https://bugzilla.gnome.org/show_bug.cgi?id=727477
2014-04-26 18:38:07 +00:00
* ## GtkPopover as menu replacement
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* `GtkPopover` is often used to replace menus. The best was to do this
* is to use the [class@Gtk.PopoverMenu] subclass which supports being
* populated from a `GMenuModel` with [ctor@Gtk.PopoverMenu.new_from_model].
Document iconic section support https://bugzilla.gnome.org/show_bug.cgi?id=727477
2014-04-26 18:38:07 +00:00
*
popover: Use markdown for css tree
2021-02-28 01:04:02 +00:00
* ```xml
Document iconic section support https://bugzilla.gnome.org/show_bug.cgi?id=727477
2014-04-26 18:38:07 +00:00
* <section>
* <attribute name="display-hint">horizontal-buttons</attribute>
* <item>
* <attribute name="label">Cut</attribute>
* <attribute name="action">app.cut</attribute>
* <attribute name="verb-icon">edit-cut-symbolic</attribute>
* </item>
* <item>
* <attribute name="label">Copy</attribute>
* <attribute name="action">app.copy</attribute>
* <attribute name="verb-icon">edit-copy-symbolic</attribute>
* </item>
* <item>
* <attribute name="label">Paste</attribute>
* <attribute name="action">app.paste</attribute>
* <attribute name="verb-icon">edit-paste-symbolic</attribute>
* </item>
* </section>
popover: Convert docs
2021-02-27 04:15:43 +00:00
* ```
Document iconic section support https://bugzilla.gnome.org/show_bug.cgi?id=727477
2014-04-26 18:38:07 +00:00
*
popover: Document differentiating style classes There's a lot of popover variations out there.
2015-11-02 17:53:57 +00:00
* # CSS nodes
*
popover: Use markdown for css tree
2021-02-28 01:04:02 +00:00
* ```
Rationalize popover menu apis Make gtk_popover_new_from_model() return a GtkPopoverMenu, rename it to gtk_popover_menu_new_from_model() and add a relative_to argument to gtk_popover_menu_new(). Update all callers.
2019-06-07 17:05:48 +00:00
* popover[.menu]
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
* ├── arrow
Rationalize popover menu apis Make gtk_popover_new_from_model() return a GtkPopoverMenu, rename it to gtk_popover_menu_new_from_model() and add a relative_to argument to gtk_popover_menu_new(). Update all callers.
2019-06-07 17:05:48 +00:00
* ╰── contents.background
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
* ╰── <child>
popover: Use markdown for css tree
2021-02-28 01:04:02 +00:00
* ```
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* The contents child node always gets the .background style class
* and the popover itself gets the .menu style class if the popover
* is menu-like (i.e. `GtkPopoverMenu`).
popover: Document differentiating style classes There's a lot of popover variations out there.
2015-11-02 17:53:57 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Particular uses of `GtkPopover`, such as touch selection popups or
* magnifiers in `GtkEntry` or `GtkTextView` get style classes like
* .touch-selection or .magnifier to differentiate from plain popovers.
popover: Use element name Pick "popover" and add .menu for popover menus
2015-10-30 14:08:18 +00:00
*
Rationalize popover menu apis Make gtk_popover_new_from_model() return a GtkPopoverMenu, rename it to gtk_popover_menu_new_from_model() and add a relative_to argument to gtk_popover_menu_new(). Update all callers.
2019-06-07 17:05:48 +00:00
* When styling a popover directly, the popover node should usually
popover: Convert docs
2021-02-27 04:15:43 +00:00
* not have any background. The visible part of the popover can have
* a shadow. To specify it in CSS, set the box-shadow of the contents node.
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Note that, in order to accomplish appropriate arrow visuals, `GtkPopover`
* uses custom drawing for the arrow node. This makes it possible for the
* arrow to change its shape dynamically, but it also limits the possibilities
* of styling it using CSS. In particular, the arrow gets drawn over the
* content node's border and shadow, so they look like one shape, which
* means that the border width of the content node and the arrow node should
* be the same. The arrow also does not support any border shape other than
* solid, no border-radius, only one border width (border-bottom-width is
* used) and no box-shadow.
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*/
#include "config.h"
a11y: Remove gtk.h include from container accessible
2018-02-08 23:42:38 +00:00
window: Update popover positions on ::size-allocate Popovers may get relocations optimized away if only x/y changed in the GtkAllocation. So make sure the toplevel updates popover positions on all situations. https://bugzilla.gnome.org/show_bug.cgi?id=729140
2014-08-01 15:38:42 +00:00
#include "gtkpopoverprivate.h"
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
#include "gtkpopovermenuprivate.h"
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
#include "gtknative.h"
#include "gtkwidgetprivate.h"
#include "gtkeventcontrollerkey.h"
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
#include "gtkeventcontrollerfocus.h"
popover: Use a bin layout for the contents gizmo
2019-10-25 08:36:29 +00:00
#include "gtkbinlayout.h"
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
#include "gtkenums.h"
#include "gtktypebuiltins.h"
popover: Add a popover content class Instead of bending GtkGizmo to the breaking point, split off a GtkPopoverContent class that just does what is needed here. Its simpler, and lets us keep GtkGizmo simpler too.
2021-02-17 04:47:20 +00:00
#include "gtkpopovercontentprivate.h"
a11y: Remove gtk.h include from container accessible
2018-02-08 23:42:38 +00:00
#include "gtkintl.h"
#include "gtkprivate.h"
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
#include "gtkmain.h"
a11y: Remove gtk.h include from container accessible
2018-02-08 23:42:38 +00:00
#include "gtkstack.h"
Rename a bunch of private headers We want to follow the convention that all private headers have names ending in private.h
2019-06-10 03:10:13 +00:00
#include "gtkmenusectionboxprivate.h"
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
#include "gdk/gdkeventsprivate.h"
#include "gtkpointerfocusprivate.h"
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
#include "gtkcsscolorvalueprivate.h"
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
#include "gtksnapshot.h"
popover: Implement GtkShortcutManager This makes mnemonics work in popovers.
2020-03-24 03:04:06 +00:00
#include "gtkshortcutmanager.h"
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
#include "gtkbuildable.h"
tooltip: Add private api to allocate the window Add private gtk_tooltip_maybe_allocate() function and use it from GtkWindow and GtkPopover. This will let us stop using the ::size-allocate signal, without having to redo all the tooltip management first. That will happen later.
2020-05-06 17:56:27 +00:00
#include "gtktooltipprivate.h"
popover: Return correct values from get_surface_transform() We do not (yet) care about the box shadow here, so it's sufficient to return the css values.
2020-05-16 05:20:50 +00:00
#include "gtkcssboxesimplprivate.h"
Make GtkNativeInterface private We are not sure yet if allowing out-of-tree implementations of GtkNative are a good idea.
2020-08-13 23:21:05 +00:00
#include "gtknativeprivate.h"
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
#include "gtkrender.h"
#include "gtkstylecontextprivate.h"
#include "gtkroundedboxprivate.h"
#include "gsk/gskroundedrectprivate.h"
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
#include "gtkcssshadowvalueprivate.h"
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
#define MNEMONICS_DELAY 300 /* ms */
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
#define TAIL_GAP_WIDTH 24
#define TAIL_HEIGHT 12
#define POS_IS_VERTICAL(p) ((p) == GTK_POS_TOP || (p) == GTK_POS_BOTTOM)
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
typedef struct {
GdkSurface *surface;
GskRenderer *renderer;
GtkWidget *default_widget;
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GdkRectangle pointing_to;
gboolean has_pointing_to;
guint surface_transform_changed_cb;
GtkPositionType position;
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
gboolean autohide;
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
gboolean has_arrow;
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
gboolean mnemonics_visible;
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
gboolean disable_auto_mnemonics;
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
gboolean cascade_popdown;
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
popover: allow setting popup layout offset Currently there is no way to alter the offset of the popup when positioning with GdkPopupLayout. This makes using the popup difficult for scenarios like completion windows where you may need to offset the window by a given amount for aligning text. gtk_popover_set_offset() allows setting these values and are analagous to the function of the same name for GdkPopupLayout.
2020-08-08 00:06:08 +00:00
int x_offset;
int y_offset;
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
guint mnemonics_display_timeout_id;
roundedbox: Remove _gtk_rounded_box_path() Use gsk_rounded_rect_path() instead. That's a private GSK function, be we can just include its header.
2016-12-13 20:00:28 +00:00
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
GtkWidget *child;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkWidget *contents_widget;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
GtkCssNode *arrow_node;
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
GskRenderNode *arrow_render_node;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
GdkPopupLayout *layout;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
GdkRectangle final_rect;
GtkPositionType final_position;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
} GtkPopoverPrivate;
window: Use subsurfaces for popovers on wayland On the wayland backend, set up GDK_WINDOW_SUBSURFACE windows for popovers. In the popover code, the popover-relative-to-parent calculation had to be tweaked, and it's been made to always prefer the given popover position, since there's no sizing limitations. https://bugzilla.gnome.org/show_bug.cgi?id=738891
2014-10-20 17:10:52 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
enum {
CLOSED,
popover: Bring back the activate-default signal As long as key bindings only work via action signals, we need a signal here in order to override the Enter/Space bindings for popover menus.
2019-06-12 16:54:57 +00:00
ACTIVATE_DEFAULT,
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
LAST_SIGNAL
};
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static guint signals[LAST_SIGNAL] = { 0 };
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
enum {
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
PROP_POINTING_TO = 1,
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
PROP_POSITION,
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
PROP_AUTOHIDE,
popover: Add a default-widget property This is part of redoing default widget handling.
2019-04-28 16:54:02 +00:00
PROP_DEFAULT_WIDGET,
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
PROP_HAS_ARROW,
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
PROP_MNEMONICS_VISIBLE,
popover: Add a child property
2020-05-01 22:24:15 +00:00
PROP_CHILD,
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
PROP_CASCADE_POPDOWN,
popover: Port to g_object_install_properties And use the pspecs for notification.
2015-12-02 06:03:35 +00:00
NUM_PROPERTIES
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
};
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static GParamSpec *properties[NUM_PROPERTIES] = { NULL };
popover: Add ::closed signal This signal is emitted when the popover is dismissed either through API or user interaction, somewhat more friendly than connecting to ::unmap.
2014-02-06 14:30:55 +00:00
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
static void gtk_popover_buildable_init (GtkBuildableIface *iface);
popover: Implement GtkShortcutManager This makes mnemonics work in popovers.
2020-03-24 03:04:06 +00:00
static void gtk_popover_shortcut_manager_interface_init (GtkShortcutManagerInterface *iface);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static void gtk_popover_native_interface_init (GtkNativeInterface *iface);
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
G_DEFINE_TYPE_WITH_CODE (GtkPopover, gtk_popover, GTK_TYPE_WIDGET,
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
G_ADD_PRIVATE (GtkPopover)
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_popover_buildable_init)
popover: Implement GtkShortcutManager This makes mnemonics work in popovers.
2020-03-24 03:04:06 +00:00
G_IMPLEMENT_INTERFACE (GTK_TYPE_SHORTCUT_MANAGER,
gtk_popover_shortcut_manager_interface_init)
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
G_IMPLEMENT_INTERFACE (GTK_TYPE_NATIVE,
gtk_popover_native_interface_init))
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
popover: Fix memory management of popovers Popovers are strange in the sense that they aren't attached to a parent directly, they rely on the relative_to widget so the toplevel is shared, and when they have a parent, it is the toplevel itself, not relative_to. This also means that there are conditions where the popover loses it's parent, so they must survive unparenting. The previous code would be floating the last reference as soon as the parent is gone, but it was non-obvious who'd own that reference. So fix this situation by granting the ownership of popovers to their relative_to widget, an extra reference may be held by the toplevel when the popover has a parent, but the popover object will be guaranteed to be alive as long as the parent lives. This way, memory management of popovers is as hidden from the user as regular widgets within containers are, users are free to call gtk_widget_destroy() on a popover, but it'd eventually become destructed when relative_to is.
2014-01-09 16:21:43 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static GdkSurface *
gtk_popover_native_get_surface (GtkNative *native)
{
GtkPopover *popover = GTK_POPOVER (native);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
return priv->surface;
}
popover: Add helper functions around setting up an scrollable gtk_popover_set_scrollable_full() takes care of the signal connected on the scrollable itself, in addition to the adjustment signals the popover listens to. gtk_popover_update_scrollable() looks up the current relative-to widget hierarchy and updates the current scrollable. The places where the scrollable is being maintained have been updated to use these functions. https://bugzilla.gnome.org/show_bug.cgi?id=771812
2016-09-28 17:53:10 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static GskRenderer *
gtk_popover_native_get_renderer (GtkNative *native)
{
GtkPopover *popover = GTK_POPOVER (native);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
return priv->renderer;
}
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_native_get_surface_transform (GtkNative *native,
Change coordinate translation apis to take doubles Change gtk_widget_translate_coordinates and gtk_native_get_surface_transform to operate on doubles. Update all callers.
2020-05-17 21:08:01 +00:00
double *x,
double *y)
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
{
popover: Return correct values from get_surface_transform() We do not (yet) care about the box shadow here, so it's sufficient to return the css values.
2020-05-16 05:20:50 +00:00
GtkCssBoxes css_boxes;
const graphene_rect_t *margin_rect;
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
popover: Return correct values from get_surface_transform() We do not (yet) care about the box shadow here, so it's sufficient to return the css values.
2020-05-16 05:20:50 +00:00
gtk_css_boxes_init (&css_boxes, GTK_WIDGET (native));
margin_rect = gtk_css_boxes_get_margin_rect (&css_boxes);
*x = - margin_rect->origin.x;
*y = - margin_rect->origin.y;
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
}
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
static gboolean
is_gravity_facing_north (GdkGravity gravity)
{
switch (gravity)
{
case GDK_GRAVITY_NORTH_EAST:
case GDK_GRAVITY_NORTH:
case GDK_GRAVITY_NORTH_WEST:
case GDK_GRAVITY_STATIC:
return TRUE;
case GDK_GRAVITY_SOUTH_WEST:
case GDK_GRAVITY_WEST:
case GDK_GRAVITY_SOUTH_EAST:
case GDK_GRAVITY_EAST:
case GDK_GRAVITY_CENTER:
case GDK_GRAVITY_SOUTH:
return FALSE;
default:
g_assert_not_reached ();
}
}
static gboolean
is_gravity_facing_south (GdkGravity gravity)
{
switch (gravity)
{
case GDK_GRAVITY_SOUTH_WEST:
case GDK_GRAVITY_SOUTH_EAST:
case GDK_GRAVITY_SOUTH:
return TRUE;
case GDK_GRAVITY_NORTH_EAST:
case GDK_GRAVITY_NORTH:
case GDK_GRAVITY_NORTH_WEST:
case GDK_GRAVITY_STATIC:
case GDK_GRAVITY_WEST:
case GDK_GRAVITY_EAST:
case GDK_GRAVITY_CENTER:
return FALSE;
default:
g_assert_not_reached ();
}
}
static gboolean
is_gravity_facing_west (GdkGravity gravity)
{
switch (gravity)
{
case GDK_GRAVITY_NORTH_WEST:
case GDK_GRAVITY_STATIC:
case GDK_GRAVITY_SOUTH_WEST:
case GDK_GRAVITY_WEST:
return TRUE;
case GDK_GRAVITY_NORTH_EAST:
case GDK_GRAVITY_SOUTH_EAST:
case GDK_GRAVITY_EAST:
case GDK_GRAVITY_NORTH:
case GDK_GRAVITY_CENTER:
case GDK_GRAVITY_SOUTH:
return FALSE;
default:
g_assert_not_reached ();
}
}
static gboolean
is_gravity_facing_east (GdkGravity gravity)
{
switch (gravity)
{
case GDK_GRAVITY_NORTH_EAST:
case GDK_GRAVITY_SOUTH_EAST:
case GDK_GRAVITY_EAST:
return TRUE;
case GDK_GRAVITY_NORTH_WEST:
case GDK_GRAVITY_STATIC:
case GDK_GRAVITY_SOUTH_WEST:
case GDK_GRAVITY_WEST:
case GDK_GRAVITY_NORTH:
case GDK_GRAVITY_CENTER:
case GDK_GRAVITY_SOUTH:
return FALSE;
default:
g_assert_not_reached ();
}
}
static gboolean
did_flip_horizontally (GdkGravity original_gravity,
GdkGravity final_gravity)
{
g_return_val_if_fail (original_gravity, FALSE);
g_return_val_if_fail (final_gravity, FALSE);
if (is_gravity_facing_east (original_gravity) &&
is_gravity_facing_west (final_gravity))
return TRUE;
if (is_gravity_facing_west (original_gravity) &&
is_gravity_facing_east (final_gravity))
return TRUE;
return FALSE;
}
static gboolean
did_flip_vertically (GdkGravity original_gravity,
GdkGravity final_gravity)
{
g_return_val_if_fail (original_gravity, FALSE);
g_return_val_if_fail (final_gravity, FALSE);
if (is_gravity_facing_north (original_gravity) &&
is_gravity_facing_south (final_gravity))
return TRUE;
if (is_gravity_facing_south (original_gravity) &&
is_gravity_facing_north (final_gravity))
return TRUE;
return FALSE;
}
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
static void
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
update_popover_layout (GtkPopover *popover,
popover: Try to not exceed monitor bounds When the natural size of the popover exceeds the monitor width, clamp it to fit on screen. This gives the Emoji chooser a chance to work on phone screens. Fixes: #3307
2020-12-22 03:46:52 +00:00
GdkPopupLayout *layout,
int width,
int height)
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GdkRectangle final_rect;
gboolean flipped_x;
gboolean flipped_y;
popover: Use GdkPopup
2020-02-29 14:44:05 +00:00
GdkPopup *popup = GDK_POPUP (priv->surface);
popover: Fix repositioning logic When the arrow changes position, we need to queue an allocation to ensure that gtk_widget_allocate actually calls our ->size_allocate vfunc.
2020-04-29 03:26:19 +00:00
GtkPositionType position;
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
g_clear_pointer (&priv->layout, gdk_popup_layout_unref);
priv->layout = layout;
final_rect = (GdkRectangle) {
popover: Use GdkPopup
2020-02-29 14:44:05 +00:00
.x = gdk_popup_get_position_x (GDK_POPUP (priv->surface)),
.y = gdk_popup_get_position_y (GDK_POPUP (priv->surface)),
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
.width = gdk_surface_get_width (priv->surface),
.height = gdk_surface_get_height (priv->surface),
};
flipped_x =
did_flip_horizontally (gdk_popup_layout_get_rect_anchor (layout),
popover: Use GdkPopup
2020-02-29 14:44:05 +00:00
gdk_popup_get_rect_anchor (popup)) &&
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
did_flip_horizontally (gdk_popup_layout_get_surface_anchor (layout),
popover: Use GdkPopup
2020-02-29 14:44:05 +00:00
gdk_popup_get_surface_anchor (popup));
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
flipped_y =
did_flip_vertically (gdk_popup_layout_get_rect_anchor (layout),
popover: Use GdkPopup
2020-02-29 14:44:05 +00:00
gdk_popup_get_rect_anchor (popup)) &&
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
did_flip_vertically (gdk_popup_layout_get_surface_anchor (layout),
popover: Use GdkPopup
2020-02-29 14:44:05 +00:00
gdk_popup_get_surface_anchor (popup));
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
priv->final_rect = final_rect;
popover: Fix repositioning logic When the arrow changes position, we need to queue an allocation to ensure that gtk_widget_allocate actually calls our ->size_allocate vfunc.
2020-04-29 03:26:19 +00:00
position = priv->final_position;
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
switch (priv->position)
{
case GTK_POS_LEFT:
priv->final_position = flipped_x ? GTK_POS_RIGHT : GTK_POS_LEFT;
break;
case GTK_POS_RIGHT:
priv->final_position = flipped_x ? GTK_POS_LEFT : GTK_POS_RIGHT;
break;
case GTK_POS_TOP:
priv->final_position = flipped_y ? GTK_POS_BOTTOM : GTK_POS_TOP;
break;
case GTK_POS_BOTTOM:
priv->final_position = flipped_y ? GTK_POS_TOP : GTK_POS_BOTTOM;
break;
default:
g_assert_not_reached ();
break;
}
popover: Try to not exceed monitor bounds When the natural size of the popover exceeds the monitor width, clamp it to fit on screen. This gives the Emoji chooser a chance to work on phone screens. Fixes: #3307
2020-12-22 03:46:52 +00:00
if (priv->final_position != position ||
priv->final_rect.width != width ||
priv->final_rect.height != height)
popover: Only destroy arrow render node if position changed
2020-09-10 04:02:34 +00:00
{
gtk_widget_queue_allocate (GTK_WIDGET (popover));
g_clear_pointer (&priv->arrow_render_node, gsk_render_node_unref);
}
popover: Fix repositioning logic When the arrow changes position, we need to queue an allocation to ensure that gtk_widget_allocate actually calls our ->size_allocate vfunc.
2020-04-29 03:26:19 +00:00
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
gtk_widget_queue_draw (GTK_WIDGET (popover));
}
static GdkPopupLayout *
create_popup_layout (GtkPopover *popover)
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GdkRectangle rect;
GdkGravity parent_anchor;
GdkGravity surface_anchor;
GdkAnchorHints anchor_hints;
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
GdkPopupLayout *layout;
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
GtkWidget *parent;
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
GtkCssStyle *style;
GtkBorder shadow_width;
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
parent = gtk_widget_get_parent (GTK_WIDGET (popover));
gtk_widget_get_surface_allocation (parent, &rect);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (priv->has_pointing_to)
{
rect.x += priv->pointing_to.x;
rect.y += priv->pointing_to.y;
rect.width = priv->pointing_to.width;
rect.height = priv->pointing_to.height;
}
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
style = gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (priv->contents_widget)));
gtk_css_shadow_value_get_extents (style->background->box_shadow, &shadow_width);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
switch (priv->position)
{
case GTK_POS_LEFT:
popover: Support vertical aligment We already support horizontal alignment, and we should do the same for vertical alignment.
2019-09-05 19:29:19 +00:00
switch (gtk_widget_get_valign (GTK_WIDGET (popover)))
{
case GTK_ALIGN_START:
parent_anchor = GDK_GRAVITY_NORTH_WEST;
surface_anchor = GDK_GRAVITY_NORTH_EAST;
break;
case GTK_ALIGN_END:
parent_anchor = GDK_GRAVITY_SOUTH_WEST;
surface_anchor = GDK_GRAVITY_SOUTH_EAST;
break;
case GTK_ALIGN_FILL:
case GTK_ALIGN_CENTER:
case GTK_ALIGN_BASELINE:
default:
parent_anchor = GDK_GRAVITY_WEST;
surface_anchor = GDK_GRAVITY_EAST;
break;
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
anchor_hints = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_SLIDE_Y;
break;
case GTK_POS_RIGHT:
popover: Support vertical aligment We already support horizontal alignment, and we should do the same for vertical alignment.
2019-09-05 19:29:19 +00:00
switch (gtk_widget_get_valign (GTK_WIDGET (popover)))
{
case GTK_ALIGN_START:
parent_anchor = GDK_GRAVITY_NORTH_EAST;
surface_anchor = GDK_GRAVITY_NORTH_WEST;
break;
case GTK_ALIGN_END:
parent_anchor = GDK_GRAVITY_SOUTH_EAST;
surface_anchor = GDK_GRAVITY_SOUTH_WEST;
break;
case GTK_ALIGN_FILL:
case GTK_ALIGN_CENTER:
case GTK_ALIGN_BASELINE:
default:
parent_anchor = GDK_GRAVITY_EAST;
surface_anchor = GDK_GRAVITY_WEST;
break;
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
anchor_hints = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_SLIDE_Y;
break;
case GTK_POS_TOP:
popover: Respect alignment for positioning We lost the code that takes the halign of the popover into account when positioning it. Bring it back, since we want to use it for popover menus.
2019-06-08 03:14:02 +00:00
switch (gtk_widget_get_halign (GTK_WIDGET (popover)))
{
case GTK_ALIGN_START:
parent_anchor = GDK_GRAVITY_NORTH_WEST;
surface_anchor = GDK_GRAVITY_SOUTH_WEST;
break;
case GTK_ALIGN_END:
parent_anchor = GDK_GRAVITY_NORTH_EAST;
surface_anchor = GDK_GRAVITY_SOUTH_EAST;
break;
case GTK_ALIGN_FILL:
case GTK_ALIGN_CENTER:
case GTK_ALIGN_BASELINE:
default:
parent_anchor = GDK_GRAVITY_NORTH;
surface_anchor = GDK_GRAVITY_SOUTH;
break;
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
anchor_hints = GDK_ANCHOR_FLIP_Y | GDK_ANCHOR_SLIDE_X;
break;
case GTK_POS_BOTTOM:
popover: Respect alignment for positioning We lost the code that takes the halign of the popover into account when positioning it. Bring it back, since we want to use it for popover menus.
2019-06-08 03:14:02 +00:00
switch (gtk_widget_get_halign (GTK_WIDGET (popover)))
{
case GTK_ALIGN_START:
parent_anchor = GDK_GRAVITY_SOUTH_WEST;
surface_anchor = GDK_GRAVITY_NORTH_WEST;
break;
case GTK_ALIGN_END:
parent_anchor = GDK_GRAVITY_SOUTH_EAST;
surface_anchor = GDK_GRAVITY_NORTH_EAST;
break;
case GTK_ALIGN_FILL:
case GTK_ALIGN_CENTER:
case GTK_ALIGN_BASELINE:
default:
parent_anchor = GDK_GRAVITY_SOUTH;
surface_anchor = GDK_GRAVITY_NORTH;
break;
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
anchor_hints = GDK_ANCHOR_FLIP_Y | GDK_ANCHOR_SLIDE_X;
break;
default:
g_assert_not_reached ();
}
popover: Try to not exceed monitor bounds When the natural size of the popover exceeds the monitor width, clamp it to fit on screen. This gives the Emoji chooser a chance to work on phone screens. Fixes: #3307
2020-12-22 03:46:52 +00:00
anchor_hints |= GDK_ANCHOR_RESIZE;
layout = gdk_popup_layout_new (&rect, parent_anchor, surface_anchor);
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
gdk_popup_layout_set_anchor_hints (layout, anchor_hints);
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
gdk_popup_layout_set_shadow_width (layout,
shadow_width.left,
shadow_width.right,
shadow_width.top,
shadow_width.bottom);
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
popover: allow setting popup layout offset Currently there is no way to alter the offset of the popup when positioning with GdkPopupLayout. This makes using the popup difficult for scenarios like completion windows where you may need to offset the window by a given amount for aligning text. gtk_popover_set_offset() allows setting these values and are analagous to the function of the same name for GdkPopupLayout.
2020-08-08 00:06:08 +00:00
if (priv->x_offset || priv->y_offset)
gdk_popup_layout_set_offset (layout, priv->x_offset, priv->y_offset);
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
return layout;
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
}
gtkpopover: Roll back properly if presenting the popup fails If the popover fails to be shown, it would internally undo visible and mapped state. If we just proceed as normal, the widget enters in inconsistent state, and a grab remains issued on the invisible widget, preventing further input from the input device.
2020-04-24 21:06:52 +00:00
static gboolean
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
present_popup (GtkPopover *popover)
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Try to not exceed monitor bounds When the natural size of the popover exceeds the monitor width, clamp it to fit on screen. This gives the Emoji chooser a chance to work on phone screens. Fixes: #3307
2020-12-22 03:46:52 +00:00
GtkRequisition nat;
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
GdkPopupLayout *layout;
layout = create_popup_layout (popover);
popover: Try to not exceed monitor bounds When the natural size of the popover exceeds the monitor width, clamp it to fit on screen. This gives the Emoji chooser a chance to work on phone screens. Fixes: #3307
2020-12-22 03:46:52 +00:00
gtk_widget_get_preferred_size (GTK_WIDGET (popover), NULL, &nat);
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
if (gdk_popup_present (GDK_POPUP (priv->surface), nat.width, nat.height, layout))
gtkpopover: Roll back properly if presenting the popup fails If the popover fails to be shown, it would internally undo visible and mapped state. If we just proceed as normal, the widget enters in inconsistent state, and a grab remains issued on the invisible widget, preventing further input from the input device.
2020-04-24 21:06:52 +00:00
{
popover: Try to not exceed monitor bounds When the natural size of the popover exceeds the monitor width, clamp it to fit on screen. This gives the Emoji chooser a chance to work on phone screens. Fixes: #3307
2020-12-22 03:46:52 +00:00
update_popover_layout (popover, layout, nat.width, nat.height);
gtkpopover: Roll back properly if presenting the popup fails If the popover fails to be shown, it would internally undo visible and mapped state. If we just proceed as normal, the widget enters in inconsistent state, and a grab remains issued on the invisible widget, preventing further input from the input device.
2020-04-24 21:06:52 +00:00
return TRUE;
}
return FALSE;
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
}
docs: Add missing documentation to GtkPopover
2020-12-16 15:32:32 +00:00
/**
* gtk_popover_present:
popover: Convert docs
2021-02-27 04:15:43 +00:00
* @popover: a `GtkPopover`
docs: Add missing documentation to GtkPopover
2020-12-16 15:32:32 +00:00
*
* Presents the popover to the user.
*/
gtk/popover: Use gtk_popover_present() instead of going via GtkNative This makes it more explicit that managers of popovers make it "present".
2020-12-04 08:20:50 +00:00
void
gtk_popover_present (GtkPopover *popover)
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkWidget *widget = GTK_WIDGET (popover);
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (!_gtk_widget_get_alloc_needed (widget))
gtk_widget_ensure_allocate (widget);
else if (gtk_widget_get_visible (widget))
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
present_popup (popover);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
}
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
gtk/popover: Request fake motion events for popovers too As with GtkWindow, we need to request fake motion events if allocation changes, to emulate motion events given the new layout.
2020-12-04 08:12:22 +00:00
static void
maybe_request_motion_event (GtkPopover *popover)
{
GtkWidget *widget = GTK_WIDGET (popover);
GtkRoot *root = gtk_widget_get_root (widget);
GdkSeat *seat;
GdkDevice *device;
GtkWidget *focus;
GdkSurface *focus_surface;
seat = gdk_display_get_default_seat (gtk_widget_get_display (widget));
if (!seat)
return;
device = gdk_seat_get_pointer (seat);
focus = gtk_window_lookup_pointer_focus_widget (GTK_WINDOW (root),
device, NULL);
if (!focus)
return;
if (!gtk_widget_is_ancestor (focus, GTK_WIDGET (popover)))
return;
focus_surface = gtk_native_get_surface (gtk_widget_get_native (focus));
gdk_surface_request_motion (focus_surface);
}
gtk: Allocate everything from GtkNativeClass::layout This changes allocation of the widget trees to happen as a side effect to the GdkSurface::layout signal, which first passes the GtkNative instance where it is then forwarded to the implementations of the GtkNative interface. The implementations of GtkNative are the ones doing the actual gtk_widget_allocate(), and they do so in their GtkNativeClass::layout function.
2020-12-02 10:59:23 +00:00
static void
gtk_popover_native_layout (GtkNative *native,
int width,
int height)
{
GtkPopover *popover = GTK_POPOVER (native);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GtkWidget *widget = GTK_WIDGET (popover);
popover: Try to not exceed monitor bounds When the natural size of the popover exceeds the monitor width, clamp it to fit on screen. This gives the Emoji chooser a chance to work on phone screens. Fixes: #3307
2020-12-22 03:46:52 +00:00
update_popover_layout (popover, gdk_popup_layout_ref (priv->layout), width, height);
gtk: Allocate everything from GtkNativeClass::layout This changes allocation of the widget trees to happen as a side effect to the GdkSurface::layout signal, which first passes the GtkNative instance where it is then forwarded to the implementations of the GtkNative interface. The implementations of GtkNative are the ones doing the actual gtk_widget_allocate(), and they do so in their GtkNativeClass::layout function.
2020-12-02 10:59:23 +00:00
if (gtk_widget_needs_allocate (widget))
gtk/popover: Request fake motion events for popovers too As with GtkWindow, we need to request fake motion events if allocation changes, to emulate motion events given the new layout.
2020-12-04 08:12:22 +00:00
{
gtk_widget_allocate (widget, width, height, -1, NULL);
/* This fake motion event is needed for getting up to date pointer focus
popover: Cosmetics
2021-02-14 00:22:06 +00:00
* and coordinates when the pointer didn't move but the layout changed
gtk/popover: Request fake motion events for popovers too As with GtkWindow, we need to request fake motion events if allocation changes, to emulate motion events given the new layout.
2020-12-04 08:12:22 +00:00
* within the popover.
*/
maybe_request_motion_event (popover);
}
gtk: Allocate everything from GtkNativeClass::layout This changes allocation of the widget trees to happen as a side effect to the GdkSurface::layout signal, which first passes the GtkNative instance where it is then forwarded to the implementations of the GtkNative interface. The implementations of GtkNative are the ones doing the actual gtk_widget_allocate(), and they do so in their GtkNativeClass::layout function.
2020-12-02 10:59:23 +00:00
else
gtk/popover: Request fake motion events for popovers too As with GtkWindow, we need to request fake motion events if allocation changes, to emulate motion events given the new layout.
2020-12-04 08:12:22 +00:00
{
gtk_widget_ensure_allocate (widget);
}
gtk: Allocate everything from GtkNativeClass::layout This changes allocation of the widget trees to happen as a side effect to the GdkSurface::layout signal, which first passes the GtkNative instance where it is then forwarded to the implementations of the GtkNative interface. The implementations of GtkNative are the ones doing the actual gtk_widget_allocate(), and they do so in their GtkNativeClass::layout function.
2020-12-02 10:59:23 +00:00
}
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
static gboolean
gtk_popover_has_mnemonic_modifier_pressed (GtkPopover *popover)
{
GList *seats, *s;
gboolean retval = FALSE;
seats = gdk_display_list_seats (gtk_widget_get_display (GTK_WIDGET (popover)));
for (s = seats; s; s = s->next)
{
gtkpopover: Move away from gdk_device_get_state() Use gdk_device_get_modifier_state() poking the keyboard and keymap, instead of this function.
2020-07-28 13:44:09 +00:00
GdkDevice *dev = gdk_seat_get_keyboard (s->data);
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
GdkModifierType mask;
gtkpopover: Move away from gdk_device_get_state() Use gdk_device_get_modifier_state() poking the keyboard and keymap, instead of this function.
2020-07-28 13:44:09 +00:00
mask = gdk_device_get_modifier_state (dev);
Rename GDK_MOD1_MASK to GDK_ALT_MASK We've hardcoded Mod1 = Alt for a long time, there is no need to keep the confusing naming around anymore.
2020-04-05 13:39:03 +00:00
if ((mask & gtk_accelerator_get_default_mod_mask ()) == GDK_ALT_MASK)
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
{
retval = TRUE;
break;
}
}
g_list_free (seats);
return retval;
}
static gboolean
schedule_mnemonics_visible_cb (gpointer data)
{
GtkPopover *popover = data;
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
priv->mnemonics_display_timeout_id = 0;
gtk_popover_set_mnemonics_visible (popover, TRUE);
return G_SOURCE_REMOVE;
}
static void
gtk_popover_schedule_mnemonics_visible (GtkPopover *popover)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->mnemonics_display_timeout_id)
return;
priv->mnemonics_display_timeout_id =
g_timeout_add (MNEMONICS_DELAY, schedule_mnemonics_visible_cb, popover);
g_source_set_name_by_id (priv->mnemonics_display_timeout_id, "[gtk] popover_schedule_mnemonics_visible_cb");
}
static void
gtk_popover_focus_in (GtkWidget *widget)
{
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->disable_auto_mnemonics)
return;
if (gtk_widget_get_visible (widget))
{
if (gtk_popover_has_mnemonic_modifier_pressed (popover))
gtk_popover_schedule_mnemonics_visible (popover);
}
}
static void
gtk_popover_focus_out (GtkWidget *widget)
{
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->disable_auto_mnemonics)
return;
gtk_popover_set_mnemonics_visible (popover, FALSE);
}
static void
update_mnemonics_visible (GtkPopover *popover,
guint keyval,
GdkModifierType state,
gboolean visible)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->disable_auto_mnemonics)
return;
if ((keyval == GDK_KEY_Alt_L || keyval == GDK_KEY_Alt_R) &&
Rename GDK_MOD1_MASK to GDK_ALT_MASK We've hardcoded Mod1 = Alt for a long time, there is no need to keep the confusing naming around anymore.
2020-04-05 13:39:03 +00:00
((state & (gtk_accelerator_get_default_mod_mask ()) & ~(GDK_ALT_MASK)) == 0))
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
{
if (visible)
gtk_popover_schedule_mnemonics_visible (popover);
else
gtk_popover_set_mnemonics_visible (popover, FALSE);
}
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static gboolean
gtk_popover_key_pressed (GtkWidget *widget,
guint keyval,
guint keycode,
GdkModifierType state)
{
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (keyval == GDK_KEY_Escape)
{
gtkpopover: Remove GtkPopoverMenu special case Now that there's ::cascade-popdown, we don't need to treat GtkPopoverMenu especially here.
2020-10-13 12:58:13 +00:00
gtk_popover_popdown (popover);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
return TRUE;
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
}
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
update_mnemonics_visible (popover, keyval, state, TRUE);
return FALSE;
}
static gboolean
gtk_popover_key_released (GtkWidget *widget,
guint keyval,
guint keycode,
GdkModifierType state)
{
GtkPopover *popover = GTK_POPOVER (widget);
update_mnemonics_visible (popover, keyval, state, FALSE);
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
return FALSE;
}
static void
gtk: use toplevel state getter
2020-03-01 01:32:15 +00:00
surface_mapped_changed (GtkWidget *widget)
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
gtk: use toplevel state getter
2020-03-01 01:32:15 +00:00
gtk_widget_set_visible (widget, gdk_surface_get_mapped (priv->surface));
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
}
popover: Stop using gtk_widget_register_surface The GtkRoot implementations are expected to handle the necessary surface setup themselves, going forward.
2019-04-19 20:14:44 +00:00
static gboolean
surface_render (GdkSurface *surface,
cairo_region_t *region,
GtkWidget *widget)
{
gtk_widget_render (widget, surface, region);
return TRUE;
}
static gboolean
surface_event (GdkSurface *surface,
GdkEvent *event,
GtkWidget *widget)
{
gtk_main_do_event (event);
return TRUE;
}
popover: Add a default.activate action This is a first example of a widget intercepting the default.activate for its own handling.
2019-04-28 17:07:05 +00:00
static void
popover: Bring back the activate-default signal As long as key bindings only work via action signals, we need a signal here in order to override the Enter/Space bindings for popover menus.
2019-06-12 16:54:57 +00:00
gtk_popover_activate_default (GtkPopover *popover)
popover: Add a default.activate action This is a first example of a widget intercepting the default.activate for its own handling.
2019-04-28 17:07:05 +00:00
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GtkWidget *focus_widget;
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
focus_widget = gtk_window_get_focus (GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (popover))));
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (!gtk_widget_is_ancestor (focus_widget, GTK_WIDGET (popover)))
focus_widget = NULL;
popover: Add a default.activate action This is a first example of a widget intercepting the default.activate for its own handling.
2019-04-28 17:07:05 +00:00
if (priv->default_widget && gtk_widget_is_sensitive (priv->default_widget) &&
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
(!focus_widget || !gtk_widget_get_receives_default (focus_widget)
))
popover: Add a default.activate action This is a first example of a widget intercepting the default.activate for its own handling.
2019-04-28 17:07:05 +00:00
gtk_widget_activate (priv->default_widget);
else if (focus_widget && gtk_widget_is_sensitive (focus_widget))
gtk_widget_activate (focus_widget);
}
popover: Bring back the activate-default signal As long as key bindings only work via action signals, we need a signal here in order to override the Enter/Space bindings for popover menus.
2019-06-12 16:54:57 +00:00
static void
activate_default_cb (GSimpleAction *action,
GVariant *parameter,
gpointer data)
{
gtk_popover_activate_default (GTK_POPOVER (data));
}
popover: Add a default.activate action This is a first example of a widget intercepting the default.activate for its own handling.
2019-04-28 17:07:05 +00:00
static void
add_actions (GtkPopover *popover)
{
GActionEntry entries[] = {
{ "activate", activate_default_cb, NULL, NULL, NULL },
};
GActionGroup *actions;
actions = G_ACTION_GROUP (g_simple_action_group_new ());
g_action_map_add_action_entries (G_ACTION_MAP (actions),
entries, G_N_ELEMENTS (entries),
popover);
gtk_widget_insert_action_group (GTK_WIDGET (popover), "default", actions);
g_object_unref (actions);
}
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
static void
node_style_changed_cb (GtkCssNode *node,
GtkCssStyleChange *change,
GtkWidget *widget)
{
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (GTK_POPOVER (widget));
g_clear_pointer (&priv->arrow_render_node, gsk_render_node_unref);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_SIZE))
gtk_widget_queue_resize (widget);
else
gtk_widget_queue_draw (widget);
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
static void
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
gtk_popover_init (GtkPopover *popover)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
popover: Remove priv pointer
2018-03-29 18:15:39 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
GtkWidget *widget = GTK_WIDGET (popover);
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
GtkEventController *controller;
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
popover: Use GTK_POS_BOTTOM as default position This has always made a lot more sense.
2019-08-01 14:03:57 +00:00
priv->position = GTK_POS_BOTTOM;
priv->final_position = GTK_POS_BOTTOM;
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
priv->autohide = TRUE;
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
priv->has_arrow = TRUE;
popover: Change default for cascade-popdown We've found a number of cases where this cascading has unexpected side-effects. So, turn it off by default, and only set it for menus.
2020-11-03 15:23:34 +00:00
priv->cascade_popdown = FALSE;
gtkpopover: Port to GtkEventController/GtkGesture Use GtkEventControllerKey and GtkGestureMultiPress to replace key/button event handling.
2018-06-07 11:32:31 +00:00
controller = gtk_event_controller_key_new ();
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_signal_connect_swapped (controller, "key-pressed", G_CALLBACK (gtk_popover_key_pressed), popover);
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
g_signal_connect_swapped (controller, "key-released", G_CALLBACK (gtk_popover_key_released), popover);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_widget_add_controller (GTK_WIDGET (popover), controller);
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
controller = gtk_event_controller_focus_new ();
g_signal_connect_swapped (controller, "enter", G_CALLBACK (gtk_popover_focus_in), popover);
g_signal_connect_swapped (controller, "leave", G_CALLBACK (gtk_popover_focus_out), popover);
gtk_widget_add_controller (widget, controller);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
priv->arrow_node = gtk_css_node_new ();
cssnode: Convert name + id from interned string to GQuark The reason for this is simply that I want to get hash functions that have their values close together, so they can fit in a smaller range (the goal here is 12 bits). By using GQuark, we get consecutive numbers starting with 1 (and applications have <1000 quarks usually), whereas interned strings can be all over the place. As a side effect we also save 64 bytes per declaration.
2020-01-23 23:43:26 +00:00
gtk_css_node_set_name (priv->arrow_node, g_quark_from_static_string ("arrow"));
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
gtk_css_node_set_parent (priv->arrow_node, gtk_widget_get_css_node (widget));
gtk_css_node_set_state (priv->arrow_node,
gtk_css_node_get_state (gtk_widget_get_css_node (widget)));
g_signal_connect_object (priv->arrow_node, "style-changed",
G_CALLBACK (node_style_changed_cb), popover, 0);
g_object_unref (priv->arrow_node);
popover: Add a popover content class Instead of bending GtkGizmo to the breaking point, split off a GtkPopoverContent class that just does what is needed here. Its simpler, and lets us keep GtkGizmo simpler too.
2021-02-17 04:47:20 +00:00
priv->contents_widget = gtk_popover_content_new ();
popover: Use a bin layout for the contents gizmo
2019-10-25 08:36:29 +00:00
gtk_widget_set_layout_manager (priv->contents_widget, gtk_bin_layout_new ());
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_widget_set_parent (priv->contents_widget, GTK_WIDGET (popover));
popover: Set overflow: hidden This keeps overlay scrollbars from wrecking our nice rounded corners. Fixes: #3012
2020-08-04 15:09:45 +00:00
gtk_widget_set_overflow (priv->contents_widget, GTK_OVERFLOW_HIDDEN);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
popover: Use gtk_widget_add_css_class
2020-08-01 08:31:38 +00:00
gtk_widget_add_css_class (widget, "background");
popover: Add a default.activate action This is a first example of a widget intercepting the default.activate for its own handling.
2019-04-28 17:07:05 +00:00
add_actions (popover);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_realize (GtkWidget *widget)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
GdkSurface *parent_surface;
GtkWidget *parent;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
parent = gtk_widget_get_parent (widget);
parent_surface = gtk_native_get_surface (gtk_widget_get_native (parent));
priv->surface = gdk_surface_new_popup (parent_surface, priv->autohide);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
popover: Stop using gtk_widget_register_surface The GtkRoot implementations are expected to handle the necessary surface setup themselves, going forward.
2019-04-19 20:14:44 +00:00
gdk_surface_set_widget (priv->surface, widget);
gtk: use toplevel state getter
2020-03-01 01:32:15 +00:00
g_signal_connect_swapped (priv->surface, "notify::mapped", G_CALLBACK (surface_mapped_changed), widget);
popover: Stop using gtk_widget_register_surface The GtkRoot implementations are expected to handle the necessary surface setup themselves, going forward.
2019-04-19 20:14:44 +00:00
g_signal_connect (priv->surface, "render", G_CALLBACK (surface_render), widget);
g_signal_connect (priv->surface, "event", G_CALLBACK (surface_event), widget);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GTK_WIDGET_CLASS (gtk_popover_parent_class)->realize (widget);
priv->renderer = gsk_renderer_new_for_surface (priv->surface);
gtk: Allocate everything from GtkNativeClass::layout This changes allocation of the widget trees to happen as a side effect to the GdkSurface::layout signal, which first passes the GtkNative instance where it is then forwarded to the implementations of the GtkNative interface. The implementations of GtkNative are the ones doing the actual gtk_widget_allocate(), and they do so in their GtkNativeClass::layout function.
2020-12-02 10:59:23 +00:00
gtk_native_realize (GTK_NATIVE (popover));
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_unrealize (GtkWidget *widget)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
gtk: Allocate everything from GtkNativeClass::layout This changes allocation of the widget trees to happen as a side effect to the GdkSurface::layout signal, which first passes the GtkNative instance where it is then forwarded to the implementations of the GtkNative interface. The implementations of GtkNative are the ones doing the actual gtk_widget_allocate(), and they do so in their GtkNativeClass::layout function.
2020-12-02 10:59:23 +00:00
gtk_native_unrealize (GTK_NATIVE (popover));
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GTK_WIDGET_CLASS (gtk_popover_parent_class)->unrealize (widget);
gsk_renderer_unrealize (priv->renderer);
g_clear_object (&priv->renderer);
gtk: use toplevel state getter
2020-03-01 01:32:15 +00:00
g_signal_handlers_disconnect_by_func (priv->surface, surface_mapped_changed, widget);
popover: Stop using gtk_widget_register_surface The GtkRoot implementations are expected to handle the necessary surface setup themselves, going forward.
2019-04-19 20:14:44 +00:00
g_signal_handlers_disconnect_by_func (priv->surface, surface_render, widget);
g_signal_handlers_disconnect_by_func (priv->surface, surface_event, widget);
gdk_surface_set_widget (priv->surface, NULL);
Work toward dropping widget->surface Drop special-casing of GtkNative in most widget vfuncs. GtkNative implementations need to override these anyway.
2019-05-17 21:25:36 +00:00
gdk_surface_destroy (priv->surface);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_clear_object (&priv->surface);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_show (GtkWidget *widget)
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
_gtk_widget_set_visible_flag (widget, TRUE);
gtk_widget_realize (widget);
gtkpopover: Roll back properly if presenting the popup fails If the popover fails to be shown, it would internally undo visible and mapped state. If we just proceed as normal, the widget enters in inconsistent state, and a grab remains issued on the invisible widget, preventing further input from the input device.
2020-04-24 21:06:52 +00:00
if (!present_popup (popover))
return;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_widget_map (widget);
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
if (priv->autohide)
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (!gtk_widget_get_focus_child (widget))
gtk_widget_child_focus (widget, GTK_DIR_TAB_FORWARD);
gtkpopover: Set GTK grab on autohide popovers These popovers handle clicks outside the widget, and expect input to be routed through it when it is shown. This pretty much matches the characteristics of GTK grabs, and setting one up will ensure the cancellation of event controllers that were active at the time of showing the popover. Closes: https://gitlab.gnome.org/GNOME/gtk/-/issues/2446
2020-04-20 17:48:10 +00:00
gtk_grab_add (widget);
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
}
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_hide (GtkWidget *widget)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
gtkpopover: Set GTK grab on autohide popovers These popovers handle clicks outside the widget, and expect input to be routed through it when it is shown. This pretty much matches the characteristics of GTK grabs, and setting one up will ensure the cancellation of event controllers that were active at the time of showing the popover. Closes: https://gitlab.gnome.org/GNOME/gtk/-/issues/2446
2020-04-20 17:48:10 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->autohide)
gtk_grab_remove (widget);
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
gtk_popover_set_mnemonics_visible (GTK_POPOVER (widget), FALSE);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
_gtk_widget_set_visible_flag (widget, FALSE);
gtk_widget_unmap (widget);
g_signal_emit (widget, signals[CLOSED], 0);
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
popover: make smarter wrt previous focus widget lifetime If the previous focus widget is unmapped (eg. hidden, scheduled for destruction, etc), make the popover forget about it and grant focus back to the window itself.
2014-12-02 14:44:04 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
unset_surface_transform_changed_cb (gpointer data)
popover: make smarter wrt previous focus widget lifetime If the previous focus widget is unmapped (eg. hidden, scheduled for destruction, etc), make the popover forget about it and grant focus back to the window itself.
2014-12-02 14:44:04 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = data;
popover: Remove priv pointer
2018-03-29 18:15:39 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: make smarter wrt previous focus widget lifetime If the previous focus widget is unmapped (eg. hidden, scheduled for destruction, etc), make the popover forget about it and grant focus back to the window itself.
2014-12-02 14:44:04 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
priv->surface_transform_changed_cb = 0;
}
popover: make smarter wrt previous focus widget lifetime If the previous focus widget is unmapped (eg. hidden, scheduled for destruction, etc), make the popover forget about it and grant focus back to the window itself.
2014-12-02 14:44:04 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static gboolean
surface_transform_changed_cb (GtkWidget *widget,
const graphene_matrix_t *transform,
gpointer user_data)
{
popover: Fix a broken cast The widget passed here is priv->relative_to, not the popover.
2019-07-13 15:06:22 +00:00
GtkPopover *popover = user_data;
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Replace gdk_surface_is_visible by _get_mapped The property is called ::mapped, and we want to get to standard getter naming.
2020-02-25 00:02:34 +00:00
if (priv->surface && gdk_surface_get_mapped (priv->surface))
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
present_popup (popover);
popover: make smarter wrt previous focus widget lifetime If the previous focus widget is unmapped (eg. hidden, scheduled for destruction, etc), make the popover forget about it and grant focus back to the window itself.
2014-12-02 14:44:04 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
return G_SOURCE_CONTINUE;
popover: make smarter wrt previous focus widget lifetime If the previous focus widget is unmapped (eg. hidden, scheduled for destruction, etc), make the popover forget about it and grant focus back to the window itself.
2014-12-02 14:44:04 +00:00
}
bubblewindow: Turn into a GtkWindow popover This way GtkBubbleWindows are rendered on top of all window content, without the need of a GDK_WINDOW_TEMP window.
2013-11-11 09:36:51 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_map (GtkWidget *widget)
bubblewindow: Turn into a GtkWindow popover This way GtkBubbleWindows are rendered on top of all window content, without the need of a GDK_WINDOW_TEMP window.
2013-11-11 09:36:51 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
popover: Remove priv pointer
2018-03-29 18:15:39 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
GtkWidget *parent;
bubblewindow: Turn into a GtkWindow popover This way GtkBubbleWindows are rendered on top of all window content, without the need of a GDK_WINDOW_TEMP window.
2013-11-11 09:36:51 +00:00
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
present_popup (popover);
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
parent = gtk_widget_get_parent (widget);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
priv->surface_transform_changed_cb =
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
gtk_widget_add_surface_transform_changed_callback (parent,
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
surface_transform_changed_cb,
popover,
unset_surface_transform_changed_cb);
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GTK_WIDGET_CLASS (gtk_popover_parent_class)->map (widget);
bubblewindow: Turn into a GtkWindow popover This way GtkBubbleWindows are rendered on top of all window content, without the need of a GDK_WINDOW_TEMP window.
2013-11-11 09:36:51 +00:00
}
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_unmap (GtkWidget *widget)
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
{
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
GtkWidget *parent;
popover: Remember last focused widget on the toplevel when a popover is shown This is so the previously focused widget can regain focus when a modal popover is dismissed.
2014-01-10 14:23:12 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
parent = gtk_widget_get_parent (widget);
gtk_widget_remove_surface_transform_changed_callback (parent,
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
priv->surface_transform_changed_cb);
priv->surface_transform_changed_cb = 0;
popover: Remember last focused widget on the toplevel when a popover is shown This is so the previously focused widget can regain focus when a modal popover is dismissed.
2014-01-10 14:23:12 +00:00
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
GTK_WIDGET_CLASS (gtk_popover_parent_class)->unmap (widget);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gdk_surface_hide (priv->surface);
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
}
snapshot: Convert GtkPopover
2016-11-15 16:28:34 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_dispose (GObject *object)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (object);
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GtkBubbleWindow: rework how drawing is done Use gtk_render_frame_gap(), refactoring the code fetching coordinates to be usable by it. This allows for rounded corners in the window shape.
2013-03-05 16:13:54 +00:00
popover: Fix a reference leak Don't leak the reference to the default widget.
2020-05-09 19:20:15 +00:00
g_clear_object (&priv->default_widget);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_clear_pointer (&priv->contents_widget, gtk_widget_unparent);
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
g_clear_pointer (&priv->arrow_render_node, gsk_render_node_unref);
GtkBubbleWindow: Use style border color to stroke the bubble shape This improves themeability a bit, corners are still square though...
2013-01-15 16:32:42 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
G_OBJECT_CLASS (gtk_popover_parent_class)->dispose (object);
GtkBubbleWindow: allocate CSS borders and paddings
2013-03-05 15:55:41 +00:00
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
static void
gtk_popover_finalize (GObject *object)
popover: Improve minimal size allocation The minimal size if no child widget was present/shown was far too small to have enough room for the arrow width plus border radii, so gtk_render_frame_gap would spew warnings about the gap being out of boundaries. Fixes issues seen in https://bugzilla.gnome.org/show_bug.cgi?id=723031#c2
2014-01-28 15:02:47 +00:00
{
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
GtkPopover *popover = GTK_POPOVER (object);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
g_clear_pointer (&priv->layout, gdk_popup_layout_unref);
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
if (priv->mnemonics_display_timeout_id)
{
g_source_remove (priv->mnemonics_display_timeout_id);
priv->mnemonics_display_timeout_id = 0;
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
G_OBJECT_CLASS (gtk_popover_parent_class)->finalize (object);
popover: Improve minimal size allocation The minimal size if no child widget was present/shown was far too small to have enough room for the arrow width plus border radii, so gtk_render_frame_gap would spew warnings about the gap being out of boundaries. Fixes issues seen in https://bugzilla.gnome.org/show_bug.cgi?id=723031#c2
2014-01-28 15:02:47 +00:00
}
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
static void
gtk_popover_get_gap_coords (GtkPopover *popover,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int *initial_x_out,
int *initial_y_out,
int *tip_x_out,
int *tip_y_out,
int *final_x_out,
int *final_y_out)
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
{
GtkWidget *widget = GTK_WIDGET (popover);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GdkRectangle rect = { 0 };
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int base, tip, tip_pos;
int initial_x, initial_y;
int tip_x, tip_y;
int final_x, final_y;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
GtkPositionType pos;
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
int border_top, border_right, border_bottom;
int border_radius;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
int popover_width, popover_height;
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
GtkCssStyle *style;
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
GtkWidget *parent;
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
GtkBorder shadow_width;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover_width = gtk_widget_get_allocated_width (widget);
popover_height = gtk_widget_get_allocated_height (widget);
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
parent = gtk_widget_get_parent (widget);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
gtk_widget_get_surface_allocation (parent, &rect);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
if (priv->has_pointing_to)
{
rect.x += priv->pointing_to.x;
rect.y += priv->pointing_to.y;
rect.width = priv->pointing_to.width;
rect.height = priv->pointing_to.height;
}
rect.x -= priv->final_rect.x;
rect.y -= priv->final_rect.y;
pos = priv->final_position;
popover: Fix an oversight in gap coord computation This caused a border to show up between the popover arrow and the contents.
2020-01-27 12:01:37 +00:00
style = gtk_css_node_get_style (gtk_widget_get_css_node (priv->contents_widget));
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
border_radius = _gtk_css_number_value_get (style->border->border_top_left_radius, 100);
border_top = _gtk_css_number_value_get (style->border->border_top_width, 100);
border_right = _gtk_css_number_value_get (style->border->border_right_width, 100);
border_bottom = _gtk_css_number_value_get (style->border->border_bottom_width, 100);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
gtk_css_shadow_value_get_extents (style->background->box_shadow, &shadow_width);
if (pos == GTK_POS_BOTTOM)
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
{
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
tip = shadow_width.top;
base = tip + TAIL_HEIGHT + border_top;
}
else if (pos == GTK_POS_RIGHT)
{
tip = shadow_width.left;
base = tip + TAIL_HEIGHT + border_top;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
}
else if (pos == GTK_POS_TOP)
{
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
tip = popover_height - shadow_width.bottom;
base = tip - border_bottom - TAIL_HEIGHT;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
}
else if (pos == GTK_POS_LEFT)
{
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
tip = popover_width - shadow_width.right;
base = tip - border_right - TAIL_HEIGHT;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
}
else
g_assert_not_reached ();
if (POS_IS_VERTICAL (pos))
{
tip_pos = rect.x + (rect.width / 2);
initial_x = CLAMP (tip_pos - TAIL_GAP_WIDTH / 2,
border_radius,
popover_width - TAIL_GAP_WIDTH - border_radius);
initial_y = base;
tip_x = CLAMP (tip_pos, 0, popover_width);
tip_y = tip;
final_x = CLAMP (tip_pos + TAIL_GAP_WIDTH / 2,
border_radius + TAIL_GAP_WIDTH,
popover_width - border_radius);
final_y = base;
}
else
{
tip_pos = rect.y + (rect.height / 2);
initial_x = base;
initial_y = CLAMP (tip_pos - TAIL_GAP_WIDTH / 2,
border_radius,
popover_height - TAIL_GAP_WIDTH - border_radius);
tip_x = tip;
tip_y = CLAMP (tip_pos, 0, popover_height);
final_x = base;
final_y = CLAMP (tip_pos + TAIL_GAP_WIDTH / 2,
border_radius + TAIL_GAP_WIDTH,
popover_height - border_radius);
}
*initial_x_out = initial_x;
*initial_y_out = initial_y;
*tip_x_out = tip_x;
*tip_y_out = tip_y;
*final_x_out = final_x;
*final_y_out = final_y;
}
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
static void
get_border (GtkCssNode *node,
GtkBorder *border)
{
GtkCssStyle *style;
style = gtk_css_node_get_style (node);
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
border->top = _gtk_css_number_value_get (style->border->border_top_width, 100);
border->right = _gtk_css_number_value_get (style->border->border_right_width, 100);
border->bottom = _gtk_css_number_value_get (style->border->border_bottom_width, 100);
border->left = _gtk_css_number_value_get (style->border->border_left_width, 100);
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
}
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
static void
gtk_popover_apply_tail_path (GtkPopover *popover,
cairo_t *cr)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int initial_x, initial_y;
int tip_x, tip_y;
int final_x, final_y;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
GtkBorder border;
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
GtkWidget *parent;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
parent = gtk_widget_get_parent (GTK_WIDGET (popover));
if (!parent)
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
return;
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
get_border (priv->arrow_node, &border);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
cairo_set_line_width (cr, 1);
gtk_popover_get_gap_coords (popover,
&initial_x, &initial_y,
&tip_x, &tip_y,
&final_x, &final_y);
cairo_move_to (cr, initial_x, initial_y);
cairo_line_to (cr, tip_x, tip_y);
cairo_line_to (cr, final_x, final_y);
}
static void
gtk_popover_update_shape (GtkPopover *popover)
{
Stop using gtk_widget_get_surface Replace all uses of gtk_widget_get_surface by gtk_native_get_surface.
2019-05-20 00:38:08 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
if (priv->has_arrow)
{
popover: Fix input shape rendering Once again, calling gtk_widget_get_allocation() is wrong. Fixes #2601
2020-05-16 20:34:38 +00:00
GtkCssBoxes content_css_boxes;
const GskRoundedRect *box;
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
cairo_surface_t *cairo_surface;
cairo_region_t *region;
cairo_t *cr;
Change coordinate translation apis to take doubles Change gtk_widget_translate_coordinates and gtk_native_get_surface_transform to operate on doubles. Update all callers.
2020-05-17 21:08:01 +00:00
double x, y;
double native_x, native_y;
popover: Fix input shape rendering Once again, calling gtk_widget_get_allocation() is wrong. Fixes #2601
2020-05-16 20:34:38 +00:00
gtk_native_get_surface_transform (GTK_NATIVE (popover), &native_x, &native_y);
gtk_css_boxes_init (&content_css_boxes, priv->contents_widget);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
cairo_surface =
gdk_surface_create_similar_surface (priv->surface,
CAIRO_CONTENT_COLOR_ALPHA,
gdk_surface_get_width (priv->surface),
gdk_surface_get_height (priv->surface));
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
cr = cairo_create (cairo_surface);
popover: Fix input shape rendering Once again, calling gtk_widget_get_allocation() is wrong. Fixes #2601
2020-05-16 20:34:38 +00:00
cairo_translate (cr, native_x, native_y);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
gtk_popover_apply_tail_path (popover, cr);
cairo_close_path (cr);
cairo_fill (cr);
box = gtk_css_boxes_get_border_box (&content_css_boxes);
gtk_widget_translate_coordinates (priv->contents_widget, GTK_WIDGET (popover),
0, 0,
&x, &y);
cairo_translate (cr, x, y);
gsk_rounded_rect_path (box, cr);
cairo_fill (cr);
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
cairo_destroy (cr);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
region = gdk_cairo_region_create_from_surface (cairo_surface);
cairo_surface_destroy (cairo_surface);
surface: Rename gdk_surface_input_shape_combine_region There is no shape combining going on anymore, so call this just gdk_surface_set_input_region, and remove the offset arguments too. All callers pass 0 anyway. Update all callers and implementations.
2020-03-01 19:29:06 +00:00
gdk_surface_set_input_region (priv->surface, region);
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
cairo_region_destroy (region);
}
else
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
{
GtkCssNode *content_css_node;
GtkCssStyle *style;
GtkBorder shadow_width;
cairo_rectangle_int_t input_rect;
cairo_region_t *region;
content_css_node =
gtk_widget_get_css_node (GTK_WIDGET (priv->contents_widget));
style = gtk_css_node_get_style (content_css_node);
gtk_css_shadow_value_get_extents (style->background->box_shadow, &shadow_width);
input_rect.x = shadow_width.left;
input_rect.y = shadow_width.top;
input_rect.width =
gdk_surface_get_width (priv->surface) -
(shadow_width.left + shadow_width.right);
input_rect.height =
gdk_surface_get_height (priv->surface) -
(shadow_width.top + shadow_width.bottom);
region = cairo_region_create_rectangle (&input_rect);
gdk_surface_set_input_region (priv->surface, region);
cairo_region_destroy (region);
}
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
}
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
static int
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
get_border_radius (GtkWidget *widget)
{
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
GtkCssStyle *style;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
style = gtk_css_node_get_style (gtk_widget_get_css_node (widget));
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
return round (_gtk_css_number_value_get (style->border->border_top_left_radius, 100));
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
}
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
static int
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
get_minimal_size (GtkPopover *popover,
GtkOrientation orientation)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GtkPositionType pos;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int minimal_size;
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
int tail_gap_width = priv->has_arrow ? TAIL_GAP_WIDTH : 0;
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
int min_width, min_height;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
minimal_size = 2 * get_border_radius (GTK_WIDGET (priv->contents_widget));
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
pos = priv->position;
if ((orientation == GTK_ORIENTATION_HORIZONTAL && POS_IS_VERTICAL (pos)) ||
(orientation == GTK_ORIENTATION_VERTICAL && !POS_IS_VERTICAL (pos)))
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
minimal_size += tail_gap_width;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
gtk_widget_get_size_request (GTK_WIDGET (popover), &min_width, &min_height);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
minimal_size = MAX (minimal_size, min_width);
else
minimal_size = MAX (minimal_size, min_height);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
return minimal_size;
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
static void
widget: Use ::measure vfunc to measure size Add a new ::measure vfunc similar to GtkCssGadget's that widget implementations have to override instead of the old get_preferred_width, get_preferred_height, get_preferred_width_for_height, get_preferred_height_for_width and get_preferred_height_and_baseline_for_width.
2016-10-22 14:06:14 +00:00
gtk_popover_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
More coding style cleanups
2014-02-09 06:22:07 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
int minimal_size;
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
int tail_height = priv->has_arrow ? TAIL_HEIGHT : 0;
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
GtkCssStyle *style;
GtkBorder shadow_width;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
if (for_size >= 0)
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
for_size -= tail_height;
Implement wfh functions With only get_preferred_width and get_preferred_height implemented, we end up calling the GtkBin height_for_width implmementation, which knows nothing about the margins and paddings that GtkPopover needs. As a result, a listbox added to a popover was getting cut off at the bottom.
2014-01-10 22:43:42 +00:00
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
style = gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (priv->contents_widget)));
gtk_css_shadow_value_get_extents (style->background->box_shadow, &shadow_width);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_widget_measure (priv->contents_widget,
orientation, for_size,
minimum, natural,
minimum_baseline, natural_baseline);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
minimal_size = get_minimal_size (popover, orientation);
*minimum = MAX (*minimum, minimal_size);
*natural = MAX (*natural, minimal_size);
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
*minimum += shadow_width.left + shadow_width.right;
*natural += shadow_width.left + shadow_width.right;
}
else
{
*minimum += shadow_width.top + shadow_width.bottom;
*natural += shadow_width.top + shadow_width.bottom;
}
if (POS_IS_VERTICAL (priv->position) == (orientation == GTK_ORIENTATION_VERTICAL))
{
*minimum += tail_height;
*natural += tail_height;
}
popover: Invalidate borders on tail position changes There's nothing doing this explicitly, so tail position changes may leave trails of older positions. https://bugzilla.gnome.org/show_bug.cgi?id=756449
2015-10-12 22:21:43 +00:00
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
static void
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
gtk_popover_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
More coding style cleanups
2014-02-09 06:22:07 +00:00
GtkPopover *popover = GTK_POPOVER (widget);
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
GtkAllocation child_alloc;
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
int tail_height = priv->has_arrow ? TAIL_HEIGHT : 0;
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
GtkCssStyle *style;
GtkBorder shadow_width;
style = gtk_css_node_get_style (gtk_widget_get_css_node (GTK_WIDGET (priv->contents_widget)));
gtk_css_shadow_value_get_extents (style->background->box_shadow, &shadow_width);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
switch (priv->final_position)
{
case GTK_POS_TOP:
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
child_alloc.x = shadow_width.left;
child_alloc.y = shadow_width.top;
child_alloc.width = width - (shadow_width.left + shadow_width.right);
child_alloc.height = height - (shadow_width.top + shadow_width.bottom + tail_height);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
break;
case GTK_POS_BOTTOM:
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
child_alloc.x = shadow_width.left;
child_alloc.y = shadow_width.top + tail_height;
child_alloc.width = width - (shadow_width.left + shadow_width.right);
child_alloc.height = height - (shadow_width.top + shadow_width.bottom + tail_height);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
break;
case GTK_POS_LEFT:
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
child_alloc.x = shadow_width.left;
child_alloc.y = shadow_width.top;
child_alloc.width = width - (shadow_width.left + shadow_width.right + tail_height);
child_alloc.height = height - (shadow_width.top + shadow_width.bottom);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
break;
case GTK_POS_RIGHT:
popover: Support shadows Use gdk_popup_layout_set_shadow_width to take shadows into account when positioning popovers, and set the input region to exclude the shadow, since we aren't doing interactive resizing and the like. When the popover has a beak, we make the surface size be content size + shadow + tail, and then position the content according to the final position inside this slightly too large surface. The surface being too large doesn't matter, since we set up an input region.
2021-02-01 00:26:33 +00:00
child_alloc.x = shadow_width.left + tail_height;
child_alloc.y = shadow_width.top;
child_alloc.width = width - (shadow_width.left + shadow_width.right + tail_height);
child_alloc.height = height - (shadow_width.top + shadow_width.bottom);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
break;
default:
break;
}
gtk_widget_size_allocate (priv->contents_widget, &child_alloc, baseline);
if (priv->surface)
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
{
gtk_popover_update_shape (popover);
g_clear_pointer (&priv->arrow_render_node, gsk_render_node_unref);
}
tooltip: Add private api to allocate the window Add private gtk_tooltip_maybe_allocate() function and use it from GtkWindow and GtkPopover. This will let us stop using the ::size-allocate signal, without having to redo all the tooltip management first. That will happen later.
2020-05-06 17:56:27 +00:00
gtk_tooltip_maybe_allocate (GTK_NATIVE (popover));
popover: convert to indirect rendering
2016-10-29 17:43:49 +00:00
}
popover: Implement keyboard focus behavior When a popover is focused, the focus is forwarded so the first child what would get the focus actually gets it. Also, implement correct focus chain, so the keyboard focus stays within the popover when navigating with keyboard.
2014-01-09 11:53:29 +00:00
static void
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
create_arrow_render_node (GtkPopover *popover)
popover: Implement keyboard focus behavior When a popover is focused, the focus is forwarded so the first child what would get the focus actually gets it. Also, implement correct focus chain, so the keyboard focus stays within the popover when navigating with keyboard.
2014-01-09 11:53:29 +00:00
{
popover: Remove priv pointer
2018-03-29 18:15:39 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
GtkWidget *widget = GTK_WIDGET (popover);
GtkStyleContext *context;
GtkBorder border;
cairo_t *cr;
GtkSnapshot *snapshot;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
snapshot = gtk_snapshot_new ();
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
cr = gtk_snapshot_append_cairo (snapshot,
&GRAPHENE_RECT_INIT (
0, 0,
gtk_widget_get_width (widget),
gtk_widget_get_height (widget)
));
/* Clip to the arrow shape */
cairo_save (cr);
gtk_popover_apply_tail_path (popover, cr);
cairo_clip (cr);
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
get_border (priv->arrow_node, &border);
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
context = gtk_widget_get_style_context (widget);
gtk_style_context_save_to_node (context, priv->arrow_node);
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
/* Render the arrow background */
gtk_render_background (context, cr,
0, 0,
gtk_widget_get_width (widget),
gtk_widget_get_height (widget));
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
/* Render the border of the arrow tip */
if (border.bottom > 0)
{
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
GtkCssStyle *style;
popover: Stop using style context getters
2020-01-18 16:48:30 +00:00
const GdkRGBA *border_color;
Use style values directly Replace uses of gtk_css_style_get_value with direct access, throughout the tree. We don't replace all uses, just those where we are dealing with a fixed property. Be careful to handle the currentColor special case for color properties.
2020-01-28 07:38:25 +00:00
style = gtk_css_node_get_style (priv->arrow_node);
border_color = gtk_css_color_value_get_rgba (style->border->border_left_color ? style->border->border_left_color : style->core->color);
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
gtk_popover_apply_tail_path (popover, cr);
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
gdk_cairo_set_source_rgba (cr, border_color);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
cairo_set_line_width (cr, border.bottom + 1);
cairo_stroke (cr);
}
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
cairo_restore (cr);
cairo_destroy (cr);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
gtk_style_context_restore (context);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
priv->arrow_render_node = gtk_snapshot_free_to_node (snapshot);
}
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
static void
gtk_popover_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
{
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Don't constantly redraw the beak We don't want to constantly draw the arrow if we don't have to. Save the render node to achieve this.
2019-05-25 23:11:30 +00:00
gtk_widget_snapshot_child (widget, priv->contents_widget, snapshot);
if (priv->has_arrow)
{
if (!priv->arrow_render_node)
create_arrow_render_node (popover);
gtk_snapshot_append_node (snapshot, priv->arrow_render_node);
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
}
popover: Implement keyboard focus behavior When a popover is focused, the focus is forwarded so the first child what would get the focus actually gets it. Also, implement correct focus chain, so the keyboard focus stays within the popover when navigating with keyboard.
2014-01-09 11:53:29 +00:00
}
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (object);
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
switch (prop_id)
{
case PROP_POINTING_TO:
gtk_popover_set_pointing_to (popover, g_value_get_boxed (value));
break;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
case PROP_POSITION:
gtk_popover_set_position (popover, g_value_get_enum (value));
break;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
case PROP_AUTOHIDE:
gtk_popover_set_autohide (popover, g_value_get_boolean (value));
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
break;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
case PROP_DEFAULT_WIDGET:
gtk_popover_set_default_widget (popover, g_value_get_object (value));
break;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
case PROP_HAS_ARROW:
gtk_popover_set_has_arrow (popover, g_value_get_boolean (value));
break;
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
case PROP_MNEMONICS_VISIBLE:
gtk_popover_set_mnemonics_visible (popover, g_value_get_boolean (value));
break;
popover: Add a child property
2020-05-01 22:24:15 +00:00
case PROP_CHILD:
gtk_popover_set_child (popover, g_value_get_object (value));
break;
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
case PROP_CASCADE_POPDOWN:
gtk_popover_set_cascade_popdown (popover, g_value_get_boolean (value));
break;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
}
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopover *popover = GTK_POPOVER (object);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
switch (prop_id)
{
case PROP_POINTING_TO:
g_value_set_boxed (value, &priv->pointing_to);
break;
case PROP_POSITION:
g_value_set_enum (value, priv->position);
break;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
case PROP_AUTOHIDE:
g_value_set_boolean (value, priv->autohide);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
break;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
case PROP_DEFAULT_WIDGET:
g_value_set_object (value, priv->default_widget);
break;
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
case PROP_HAS_ARROW:
g_value_set_boolean (value, priv->has_arrow);
break;
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
case PROP_MNEMONICS_VISIBLE:
g_value_set_boolean (value, priv->mnemonics_visible);
break;
popover: Add a child property
2020-05-01 22:24:15 +00:00
case PROP_CHILD:
g_value_set_object (value, gtk_popover_get_child (popover));
break;
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
case PROP_CASCADE_POPDOWN:
g_value_set_boolean (value, priv->cascade_popdown);
break;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
popover: Add show/hide transitions These have the same visual effect and timing than the gnome-shell ones. During the hide animation, the popover has been made to take focus elsewhere, and refuse to take any pointer/keyboard input until the popover is shown again. This has been based on work from Timm Bäder. https://bugzilla.gnome.org/show_bug.cgi?id=741405
2015-01-09 15:10:29 +00:00
}
popover: Implement keyboard focus behavior When a popover is focused, the focus is forwarded so the first child what would get the focus actually gets it. Also, implement correct focus chain, so the keyboard focus stays within the popover when navigating with keyboard.
2014-01-09 11:53:29 +00:00
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
static void
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
add_tab_bindings (GtkWidgetClass *widget_class,
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
GdkModifierType modifiers,
GtkDirectionType direction)
{
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Tab, modifiers,
"move-focus",
"(i)", direction);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Tab, modifiers,
"move-focus",
"(i)", direction);
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
}
static void
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
add_arrow_bindings (GtkWidgetClass *widget_class,
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
guint keysym,
GtkDirectionType direction)
{
guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
gtk_widget_class_add_binding_signal (widget_class, keysym, 0,
"move-focus",
"(i)",
direction);
gtk_widget_class_add_binding_signal (widget_class, keysym, GDK_CONTROL_MASK,
"move-focus",
"(i)",
direction);
gtk_widget_class_add_binding_signal (widget_class, keypad_keysym, 0,
"move-focus",
"(i)",
direction);
gtk_widget_class_add_binding_signal (widget_class, keypad_keysym, GDK_CONTROL_MASK,
"move-focus",
"(i)",
direction);
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
}
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
static void
gtk_popover_compute_expand (GtkWidget *widget,
gboolean *hexpand,
gboolean *vexpand)
{
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->child)
{
*hexpand = gtk_widget_compute_expand (priv->child, GTK_ORIENTATION_HORIZONTAL);
*vexpand = gtk_widget_compute_expand (priv->child, GTK_ORIENTATION_VERTICAL);
}
else
{
*hexpand = FALSE;
*vexpand = FALSE;
}
}
static GtkSizeRequestMode
gtk_popover_get_request_mode (GtkWidget *widget)
{
GtkPopover *popover = GTK_POPOVER (widget);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->child)
return gtk_widget_get_request_mode (priv->child);
else
return GTK_SIZE_REQUEST_CONSTANT_SIZE;
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
static void
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
gtk_popover_class_init (GtkPopoverClass *klass)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
popover: Add a contents node Remove the special case in gtkwidget.c where we didn't draw any css background/border for popovers. Instead, rely on themes to not style the popover node and add a contents gizmo that gets the actual css styling. We then requeste enough space for the popover to draw both the contents and the arrow on the side.
2017-07-08 10:04:44 +00:00
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
object_class->dispose = gtk_popover_dispose;
object_class->finalize = gtk_popover_finalize;
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
object_class->set_property = gtk_popover_set_property;
object_class->get_property = gtk_popover_get_property;
widget_class->realize = gtk_popover_realize;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
widget_class->unrealize = gtk_popover_unrealize;
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
widget_class->map = gtk_popover_map;
widget_class->unmap = gtk_popover_unmap;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
widget_class->show = gtk_popover_show;
widget_class->hide = gtk_popover_hide;
widget: Use ::measure vfunc to measure size Add a new ::measure vfunc similar to GtkCssGadget's that widget implementations have to override instead of the old get_preferred_width, get_preferred_height, get_preferred_width_for_height, get_preferred_height_for_width and get_preferred_height_and_baseline_for_width.
2016-10-22 14:06:14 +00:00
widget_class->measure = gtk_popover_measure;
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
widget_class->size_allocate = gtk_popover_size_allocate;
snapshot: Convert GtkPopover
2016-11-15 16:28:34 +00:00
widget_class->snapshot = gtk_popover_snapshot;
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
widget_class->compute_expand = gtk_popover_compute_expand;
widget_class->get_request_mode = gtk_popover_get_request_mode;
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
popover: Bring back the activate-default signal As long as key bindings only work via action signals, we need a signal here in order to override the Enter/Space bindings for popover menus.
2019-06-12 16:54:57 +00:00
klass->activate_default = gtk_popover_activate_default;
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:pointing-to: (attributes org.gtk.Property.get=gtk_popover_get_pointing_to org.gtk.Property.set=gtk_popover_set_pointing_to)
*
* Rectangle in the parent widget that the popover points to.
*/
popover: Port to g_object_install_properties And use the pspecs for notification.
2015-12-02 06:03:35 +00:00
properties[PROP_POINTING_TO] =
g_param_spec_boxed ("pointing-to",
P_("Pointing to"),
P_("Rectangle the bubble window points to"),
GDK_TYPE_RECTANGLE,
GTK_PARAM_READWRITE);
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:position: (attributes org.gtk.Property.get=gtk_popover_get_position org.gtk.Property.set=gtk_popover_set_position)
*
* How to place the popover, relative to its parent.
*/
popover: Port to g_object_install_properties And use the pspecs for notification.
2015-12-02 06:03:35 +00:00
properties[PROP_POSITION] =
g_param_spec_enum ("position",
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
P_("Position"),
P_("Position to place the bubble window"),
popover: Use GTK_POS_BOTTOM as default position This has always made a lot more sense.
2019-08-01 14:03:57 +00:00
GTK_TYPE_POSITION_TYPE, GTK_POS_BOTTOM,
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
popover: Keep a ref on the parent scrollable This ensures the scrollable is still alive on dispose(), and properly unset after disconnecting all signal handlers.
2015-02-05 13:17:51 +00:00
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:autohide: (attributes org.gtk.Property.get=gtk_popover_get_autohide org.gtk.Property.set=gtk_popover_set_autohide)
*
* Whether to dismiss the popover on outside clicks.
*/
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
properties[PROP_AUTOHIDE] =
g_param_spec_boolean ("autohide",
P_("Autohide"),
popover: fix typo in schema string
2019-08-29 12:50:20 +00:00
P_("Whether to dismiss the popover on outside clicks"),
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
popover: Track parent scrollable adjustments This makes sure popovers follow the relative_to widget if it is contained within a GtkScrollable.
2014-01-22 15:43:37 +00:00
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:default-widget: (attributes org.gtk.Popover.set=gtk_popover_set_default_widget)
*
* The default widget inside the popover.
*/
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
properties[PROP_DEFAULT_WIDGET] =
g_param_spec_object ("default-widget",
P_("Default widget"),
P_("The default widget"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE|G_PARAM_STATIC_STRINGS|G_PARAM_EXPLICIT_NOTIFY);
popover: Track parent scrollable adjustments This makes sure popovers follow the relative_to widget if it is contained within a GtkScrollable.
2014-01-22 15:43:37 +00:00
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:has-arrow: (attributes org.gtk.Popover.get=gtk_popover_get_has_arrow org.gtk.Property.set=gtk_popover_set_has_arrow)
*
* Whether to draw an arrow.
*/
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
properties[PROP_HAS_ARROW] =
g_param_spec_boolean ("has-arrow",
P_("Has Arrow"),
P_("Whether to draw an arrow"),
TRUE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:mnemonics-visible: (attributes org.gtk.Property.get=gtk_popover_get_mnemonics_visible org.gtk.Property.set=gtk_popover_set_mnemonics_visible)
*
* Whether mnemonics are currently visible in this popover.
*/
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
properties[PROP_MNEMONICS_VISIBLE] =
g_param_spec_boolean ("mnemonics-visible",
P_("Mnemonics visible"),
P_("Whether mnemonics are currently visible in this popover"),
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:child: (attributes org.gtk.Property.get=gtk_popover_get_child org.gtk.Property.set=gtk_popover_set_child)
*
* The child widget.
*/
popover: Add a child property
2020-05-01 22:24:15 +00:00
properties[PROP_CHILD] =
g_param_spec_object ("child",
P_("Child"),
P_("The child widget"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
popover: Convert docs
2021-02-27 04:15:43 +00:00
/**
* GtkPopover:cascade-popdown: (attributes org.gtk.Property.get=gtk_popover_get_cascade_popdown org.gtk.Property.set=gtk_popover_set_cascade_popdown)
*
* Whether the popover pops down after a child popover.
*
* This is used to implement the expected behavior of submenus.
*/
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
properties[PROP_CASCADE_POPDOWN] =
g_param_spec_boolean ("cascade-popdown",
P_("Cascade popdown"),
popover: Fix a typo s/Wether/Whether/ Fixes #3393
2020-11-25 18:59:16 +00:00
P_("Whether the popover pops down after a child popover"),
popover: Change default for cascade-popdown We've found a number of cases where this cascading has unexpected side-effects. So, turn it off by default, and only set it for menus.
2020-11-03 15:23:34 +00:00
FALSE,
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
popover: Track parent scrollable adjustments This makes sure popovers follow the relative_to widget if it is contained within a GtkScrollable.
2014-01-22 15:43:37 +00:00
popover: Document signals
2020-11-17 03:46:17 +00:00
/**
* GtkPopover::closed:
popover: Convert docs
2021-02-27 04:15:43 +00:00
* @self: the `GtkPopover` which received the signal
popover: Document signals
2020-11-17 03:46:17 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Emitted when the popover is closed.
popover: Document signals
2020-11-17 03:46:17 +00:00
*/
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
signals[CLOSED] =
g_signal_new (I_("closed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkPopoverClass, closed),
NULL, NULL,
NULL,
G_TYPE_NONE,
0);
popover: Bring back the activate-default signal As long as key bindings only work via action signals, we need a signal here in order to override the Enter/Space bindings for popover menus.
2019-06-12 16:54:57 +00:00
popover: Document signals
2020-11-17 03:46:17 +00:00
/**
* GtkPopover::activate-default:
popover: Convert docs
2021-02-27 04:15:43 +00:00
* @self: the `GtkPopover` which received the signal
popover: Document signals
2020-11-17 03:46:17 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Emitted whend the user activates the default widget.
*
* This is a [keybinding signal](class.SignalAction.html).
popover: Document signals
2020-11-17 03:46:17 +00:00
*/
popover: Bring back the activate-default signal As long as key bindings only work via action signals, we need a signal here in order to override the Enter/Space bindings for popover menus.
2019-06-12 16:54:57 +00:00
signals[ACTIVATE_DEFAULT] =
g_signal_new (I_("activate-default"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkPopoverClass, activate_default),
NULL, NULL,
NULL,
G_TYPE_NONE,
0);
popover: Track parent scrollable adjustments This makes sure popovers follow the relative_to widget if it is contained within a GtkScrollable.
2014-01-22 15:43:37 +00:00
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
add_arrow_bindings (widget_class, GDK_KEY_Up, GTK_DIR_UP);
add_arrow_bindings (widget_class, GDK_KEY_Down, GTK_DIR_DOWN);
add_arrow_bindings (widget_class, GDK_KEY_Left, GTK_DIR_LEFT);
add_arrow_bindings (widget_class, GDK_KEY_Right, GTK_DIR_RIGHT);
add_tab_bindings (widget_class, 0, GTK_DIR_TAB_FORWARD);
add_tab_bindings (widget_class, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
add_tab_bindings (widget_class, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
add_tab_bindings (widget_class, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Return, 0,
"activate-default", NULL);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_ISO_Enter, 0,
"activate-default", NULL);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Enter, 0,
"activate-default", NULL);
popover: Add keynav keybindings The shortcut controllers are limited to same-native, so we need to duplicate the Tab and arrow key bindings for focus handling, as well as the Enter bindings for activation.
2020-03-17 21:24:09 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_widget_class_set_css_name (widget_class, "popover");
popover: Track parent scrollable adjustments This makes sure popovers follow the relative_to widget if it is contained within a GtkScrollable.
2014-01-22 15:43:37 +00:00
}
Assorted documentation fixes
2020-04-20 02:50:35 +00:00
/**
* gtk_popover_new:
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Creates a new `GtkPopover`.
Assorted documentation fixes
2020-04-20 02:50:35 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Returns: the new `GtkPopover`
Assorted documentation fixes
2020-04-20 02:50:35 +00:00
*/
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkWidget *
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
gtk_popover_new (void)
popover: Track parent scrollable adjustments This makes sure popovers follow the relative_to widget if it is contained within a GtkScrollable.
2014-01-22 15:43:37 +00:00
{
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
return g_object_new (GTK_TYPE_POPOVER, NULL);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
}
popover: Add helper functions around setting up an scrollable gtk_popover_set_scrollable_full() takes care of the signal connected on the scrollable itself, in addition to the adjustment signals the popover listens to. gtk_popover_update_scrollable() looks up the current relative-to widget hierarchy and updates the current scrollable. The places where the scrollable is being maintained have been updated to use these functions. https://bugzilla.gnome.org/show_bug.cgi?id=771812
2016-09-28 17:53:10 +00:00
popover: Add a child property
2020-05-01 22:24:15 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_child: (attributes org.gtk.Method.set_property=child)
* @popover: a `GtkPopover`
popover: Add a child property
2020-05-01 22:24:15 +00:00
* @child: (allow-none): the child widget
*
* Sets the child widget of @popover.
*/
void
gtk_popover_set_child (GtkPopover *popover,
GtkWidget *child)
{
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Add a child property
2020-05-01 22:24:15 +00:00
g_return_if_fail (GTK_IS_POPOVER (popover));
g_return_if_fail (child == NULL || GTK_IS_WIDGET (child));
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
if (priv->child == child)
return;
g_clear_pointer (&priv->child, gtk_widget_unparent);
if (child)
{
priv->child = child;
gtk_widget_set_parent (child, priv->contents_widget);
}
popover: Add a child property
2020-05-01 22:24:15 +00:00
g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_CHILD]);
}
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_get_child: (attributes org.gtk.Method.get_property=child)
* @popover: a `GtkPopover`
popover: Add a child property
2020-05-01 22:24:15 +00:00
*
* Gets the child widget of @popover.
*
* Returns: (nullable) (transfer none): the child widget of @popover
*/
GtkWidget *
gtk_popover_get_child (GtkPopover *popover)
{
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Add a child property
2020-05-01 22:24:15 +00:00
g_return_val_if_fail (GTK_IS_POPOVER (popover), NULL);
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
return priv->child;
popover: Add a child property
2020-05-01 22:24:15 +00:00
}
Assorted documentation fixes
2020-04-20 02:50:35 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_default_widget: (attributes org.gtk.Method.set_property=default-widget)
* @popover: a `GtkPopover`
Assorted documentation fixes
2020-04-20 02:50:35 +00:00
* @widget: (allow-none): a child widget of @popover to set as
popover: Convert docs
2021-02-27 04:15:43 +00:00
* the default, or %NULL to unset the default widget for the popover
*
* Sets the default widget of a `GtkPopover`.
Assorted documentation fixes
2020-04-20 02:50:35 +00:00
*
* The default widget is the widget that’s activated when the user
* presses Enter in a dialog (for example). This function sets or
popover: Convert docs
2021-02-27 04:15:43 +00:00
* unsets the default widget for a `GtkPopover`.
Assorted documentation fixes
2020-04-20 02:50:35 +00:00
*/
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
void
gtk_popover_set_default_widget (GtkPopover *popover,
GtkWidget *widget)
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
{
popover: Remove priv pointer
2018-03-29 18:15:39 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_return_if_fail (GTK_IS_POPOVER (popover));
popover: Track parent scrollable adjustments This makes sure popovers follow the relative_to widget if it is contained within a GtkScrollable.
2014-01-22 15:43:37 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (priv->default_widget == widget)
return;
bubblewindow: Turn into a GtkWindow popover This way GtkBubbleWindows are rendered on top of all window content, without the need of a GDK_WINDOW_TEMP window.
2013-11-11 09:36:51 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (priv->default_widget)
popover: listen harder on the widget being pointed to Hierarchy, size allocation and widget visibility are now listened to in order to update the popover state accordingly.
2013-11-13 09:47:13 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
_gtk_widget_set_has_default (priv->default_widget, FALSE);
gtk_widget_queue_draw (priv->default_widget);
g_object_notify (G_OBJECT (priv->default_widget), "has-default");
popover: listen harder on the widget being pointed to Hierarchy, size allocation and widget visibility are now listened to in order to update the popover state accordingly.
2013-11-13 09:47:13 +00:00
}
bubblewindow: Turn into a GtkWindow popover This way GtkBubbleWindows are rendered on top of all window content, without the need of a GDK_WINDOW_TEMP window.
2013-11-11 09:36:51 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_set_object (&priv->default_widget, widget);
bubblewindow: Point to the entire widget area by default This way pointing_to is not fully needed, unless you're pointing to an specific rectangle within the widget, passing NULL would unset the region too.
2013-11-12 11:56:40 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (priv->default_widget)
bubblewindow: Point to the entire widget area by default This way pointing_to is not fully needed, unless you're pointing to an specific rectangle within the widget, passing NULL would unset the region too.
2013-11-12 11:56:40 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
_gtk_widget_set_has_default (priv->default_widget, TRUE);
gtk_widget_queue_draw (priv->default_widget);
g_object_notify (G_OBJECT (priv->default_widget), "has-default");
bubblewindow: Point to the entire widget area by default This way pointing_to is not fully needed, unless you're pointing to an specific rectangle within the widget, passing NULL would unset the region too.
2013-11-12 11:56:40 +00:00
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_DEFAULT_WIDGET]);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
popover: Implement GtkShortcutManager This makes mnemonics work in popovers.
2020-03-24 03:04:06 +00:00
static void
gtk_popover_shortcut_manager_interface_init (GtkShortcutManagerInterface *iface)
{
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
static void
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_native_interface_init (GtkNativeInterface *iface)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
iface->get_surface = gtk_popover_native_get_surface;
iface->get_renderer = gtk_popover_native_get_renderer;
iface->get_surface_transform = gtk_popover_native_get_surface_transform;
gtk: Allocate everything from GtkNativeClass::layout This changes allocation of the widget trees to happen as a side effect to the GdkSurface::layout signal, which first passes the GtkNative instance where it is then forwarded to the implementations of the GtkNative interface. The implementations of GtkNative are the ones doing the actual gtk_widget_allocate(), and they do so in their GtkNativeClass::layout function.
2020-12-02 10:59:23 +00:00
iface->layout = gtk_popover_native_layout;
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
static GtkBuildableIface *parent_buildable_iface;
static void
gtk_popover_buildable_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *type)
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
{
if (GTK_IS_WIDGET (child))
Cosmetics
2020-05-13 12:11:41 +00:00
gtk_popover_set_child (GTK_POPOVER (buildable), GTK_WIDGET (child));
popover: Derive from GtkWidget
2020-05-02 02:35:31 +00:00
else
parent_buildable_iface->add_child (buildable, builder, child, type);
}
static void
gtk_popover_buildable_init (GtkBuildableIface *iface)
{
parent_buildable_iface = g_type_interface_peek_parent (iface);
iface->add_child = gtk_popover_buildable_add_child;
}
popover: Add documentation
2013-11-13 14:11:21 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_pointing_to: (attributes org.gtk.Method.set_property=pointing-to)
* @popover: a `GtkPopover`
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
* @rect: rectangle to point to
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Sets the rectangle that @popover points to.
*
* This is in the coordinate space of the @popover parent.
*/
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
void
Trivial formatting fix
2014-02-09 03:18:15 +00:00
gtk_popover_set_pointing_to (GtkPopover *popover,
GtkPopover: use GdkRectangle instead of cairo_rectangle_int_t cairo_rectangle_int_t replaced by GdkRectangle whenever it is used. Also, rect parameter in public method gtk_popover_set_pointing_to made const. Bug #723394
2014-02-04 21:33:25 +00:00
const GdkRectangle *rect)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
g_return_if_fail (GTK_IS_POPOVER (popover));
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (rect)
{
priv->pointing_to = *rect;
priv->has_pointing_to = TRUE;
gtkpopover: Ensure the pointed to rectangle has a minimum w/h On wayland, protocol errors will be raised if the rectangle width/height are 0. Avoid that situation so it's valid to all popovers.
2020-02-27 17:07:38 +00:00
priv->pointing_to.width = MAX (priv->pointing_to.width, 1);
priv->pointing_to.height = MAX (priv->pointing_to.height, 1);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
}
else
priv->has_pointing_to = FALSE;
g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_POINTING_TO]);
gtkpopover: Re-present surface if position/pointing-to change while visible This ensures the popover will follow the new position parameters. This is necessary for popovers like the text magnifier that can be repositioned while visible.
2020-02-27 17:08:46 +00:00
if (gtk_widget_is_visible (GTK_WIDGET (popover)))
present_popup (popover);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
popover: Add documentation
2013-11-13 14:11:21 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_get_pointing_to: (attributes org.gtk.Method.get_property=pointing-to)
* @popover: a `GtkPopover`
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
* @rect: (out): location to store the rectangle
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Gets the rectangle that the popover points to.
*
popover: Add documentation
2013-11-13 14:11:21 +00:00
* If a rectangle to point to has been set, this function will
* return %TRUE and fill in @rect with such rectangle, otherwise
popover: Convert docs
2021-02-27 04:15:43 +00:00
* it will return %FALSE and fill in @rect with the parent
popover: Add documentation
2013-11-13 14:11:21 +00:00
* widget coordinates.
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
popover: Add documentation
2013-11-13 14:11:21 +00:00
* Returns: %TRUE if a rectangle to point to was set.
popover: Convert docs
2021-02-27 04:15:43 +00:00
*/
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
gboolean
GtkPopover: use GdkRectangle instead of cairo_rectangle_int_t cairo_rectangle_int_t replaced by GdkRectangle whenever it is used. Also, rect parameter in public method gtk_popover_set_pointing_to made const. Bug #723394
2014-02-04 21:33:25 +00:00
gtk_popover_get_pointing_to (GtkPopover *popover,
GdkRectangle *rect)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
popover: Make some public API NULL-safe Instad of potentially dereferencing a NULL-pointer, use the NULL-safe gtk_popover_get_instance_private before the g_return_if_fail precondition check.
2016-08-09 17:29:41 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
g_return_val_if_fail (GTK_IS_POPOVER (popover), FALSE);
popover: Remove useless if case rect is not nullable, so stop checking if it is NULL and instead add a g_return_val_if_fail guard.
2017-06-03 12:38:56 +00:00
g_return_val_if_fail (rect != NULL, FALSE);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
popover: Remove useless if case rect is not nullable, so stop checking if it is NULL and instead add a g_return_val_if_fail guard.
2017-06-03 12:38:56 +00:00
if (priv->has_pointing_to)
*rect = priv->pointing_to;
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
else
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
{
graphene_rect_t r;
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (popover));
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
if (!gtk_widget_compute_bounds (parent, parent, &r))
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
return FALSE;
rect->x = floorf (r.origin.x);
rect->y = floorf (r.origin.y);
rect->width = ceilf (r.size.width);
rect->height = ceilf (r.size.height);
}
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
return priv->has_pointing_to;
}
popover: Add documentation
2013-11-13 14:11:21 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_position: (attributes org.gtk.Method.set_property=position)
* @popover: a `GtkPopover`
popover: Add documentation
2013-11-13 14:11:21 +00:00
* @position: preferred popover position
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Sets the preferred position for @popover to appear.
*
* If the @popover is currently visible, it will be immediately
* updated.
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
Docs: Don't use note elements In most cases, the text itself makes the message clear enough.
2014-02-02 06:22:14 +00:00
* This preference will be respected where possible, although
* on lack of space (eg. if close to the window edges), the
popover: Convert docs
2021-02-27 04:15:43 +00:00
* `GtkPopover` may choose to appear on the opposite side.
*/
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
void
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
gtk_popover_set_position (GtkPopover *popover,
GtkPositionType position)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
g_return_if_fail (GTK_IS_POPOVER (popover));
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
if (priv->position == position)
return;
priv->position = position;
popover: Bring back the beak Bring back the code that draws an arrow.
2019-05-05 23:53:02 +00:00
priv->final_position = position;
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_POSITION]);
gtkpopover: Re-present surface if position/pointing-to change while visible This ensures the popover will follow the new position parameters. This is necessary for popovers like the text magnifier that can be repositioned while visible.
2020-02-27 17:08:46 +00:00
popover: Queue a resize when position changes At least with an arrow, changing the position requires a resize
2021-02-14 01:25:24 +00:00
gtk_widget_queue_resize (GTK_WIDGET (popover));
gtkpopover: Re-present surface if position/pointing-to change while visible This ensures the popover will follow the new position parameters. This is necessary for popovers like the text magnifier that can be repositioned while visible.
2020-02-27 17:08:46 +00:00
if (gtk_widget_is_visible (GTK_WIDGET (popover)))
present_popup (popover);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
popover: Add documentation
2013-11-13 14:11:21 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_get_position: (attributes org.gtk.Method.get_property=position)
* @popover: a `GtkPopover`
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
popover: Add documentation
2013-11-13 14:11:21 +00:00
* Returns the preferred position of @popover.
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
*
popover: Add documentation
2013-11-13 14:11:21 +00:00
* Returns: The preferred position.
popover: Convert docs
2021-02-27 04:15:43 +00:00
*/
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
GtkPositionType
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
gtk_popover_get_position (GtkPopover *popover)
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
{
popover: Remove priv pointer
2018-03-29 18:15:39 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Introduce GtkPopover Now that the GtkBubbleWindow object has been cleaned up and made more generic, rename it as GtkPopover and make it public.
2013-11-12 15:55:23 +00:00
g_return_val_if_fail (GTK_IS_POPOVER (popover), GTK_POS_TOP);
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
return priv->position;
Add GtkBubbleWindow This popup window widget can be used for touch friendly context menus that point to a concrete area.
2013-01-11 16:32:08 +00:00
}
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_autohide: (attributes org.gtk.Method.set_property=autohide)
* @popover: a `GtkPopover`
* @autohide: %TRUE to dismiss the popover on outside clicks
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
*
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
* Sets whether @popover is modal.
*
* A modal popover will grab the keyboard focus on it when being
popover: Convert docs
2021-02-27 04:15:43 +00:00
* displayed. Clicking outside the popover area or pressing Esc
* will dismiss the popover.
popover: Unrealize when autohide prop changes Changing the autohide property means the popover needs to be remapped. Remapping may need user interaction, so lets just unrealize the popover if the property changes, forcing the application to remap it should it be shown again.
2019-07-24 13:45:34 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Called this function on an already showing popup with a new
* autohide value different from the current one, will cause the
* popup to be hidden.
*/
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
void
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
gtk_popover_set_autohide (GtkPopover *popover,
gboolean autohide)
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
{
popover: Make some public API NULL-safe Instad of potentially dereferencing a NULL-pointer, use the NULL-safe gtk_popover_get_instance_private before the g_return_if_fail precondition check.
2016-08-09 17:29:41 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
g_return_if_fail (GTK_IS_POPOVER (popover));
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
autohide = autohide != FALSE;
Trivial coding style cleanups
2014-02-09 05:48:38 +00:00
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
if (priv->autohide == autohide)
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
return;
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
priv->autohide = autohide;
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
popover: Unrealize when autohide prop changes Changing the autohide property means the popover needs to be remapped. Remapping may need user interaction, so lets just unrealize the popover if the property changes, forcing the application to remap it should it be shown again.
2019-07-24 13:45:34 +00:00
gtk_widget_unrealize (GTK_WIDGET (popover));
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_AUTOHIDE]);
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
}
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_get_autohide: (attributes org.gtk.Method.get_property=autohide)
* @popover: a `GtkPopover`
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
*
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
* Returns whether the popover is modal.
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* See [method@Gtk.Popover.set_autohide] for the
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
* implications of this.
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Returns: %TRUE if @popover is modal
*/
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
gboolean
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
gtk_popover_get_autohide (GtkPopover *popover)
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
{
popover: Remove priv pointer
2018-03-29 18:15:39 +00:00
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
g_return_val_if_fail (GTK_IS_POPOVER (popover), FALSE);
popover: Rename modal to autohide This is the term we use for the surface, and it matches the behavior a bit better than modal. Update all callers.
2019-05-19 23:46:56 +00:00
return priv->autohide;
popover: Add a "modal" boolean property to GtkPopover This property is TRUE by default, when a popover is modal, it will automatically set a GTK+ grab on the popover, and grab the keyboard focus into the popover.
2014-01-10 11:04:17 +00:00
}
popover: Add private _gtk_popover_set_apply_shape() call Popovers no longer sets a shape, unless this function is called. This function exists so widgets that are potentially placed on top of other native windows can get a popover that's nicely shaped, even if it has no border shadow around. https://bugzilla.gnome.org/show_bug.cgi?id=723556
2014-02-04 19:45:53 +00:00
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
/**
* gtk_popover_popup:
popover: Convert docs
2021-02-27 04:15:43 +00:00
* @popover: a `GtkPopover`
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Pops @popover up.
*
* This is different from a [method@Gtk.Widget.show() call
* in that it may show the popover with a transition. If
* you want to show the popover without a transition, just
* use [method@Gtk.Widget.show].
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
*/
void
gtk_popover_popup (GtkPopover *popover)
{
g_return_if_fail (GTK_IS_POPOVER (popover));
gtk_widget_show (GTK_WIDGET (popover));
}
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
static void
cascade_popdown (GtkPopover *popover)
{
GtkWidget *parent;
/* Do not trigger cascade close from non-modal popovers */
if (!gtk_popover_get_autohide (popover))
return;
parent = gtk_widget_get_parent (GTK_WIDGET (popover));
while (parent)
{
if (GTK_IS_POPOVER (parent))
{
if (gtk_popover_get_cascade_popdown (GTK_POPOVER (parent)))
gtk_widget_hide (parent);
else
break;
}
parent = gtk_widget_get_parent (parent);
}
}
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
/**
* gtk_popover_popdown:
popover: Convert docs
2021-02-27 04:15:43 +00:00
* @popover: a `GtkPopover`
*
* Pops @popover down.
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* This is different from a [method@Gtk.Widget.hide] call
* in that it may show the popover with a transition. If
* you want to hide the popover without a transition, just
* use [method@Gtk.Widget.hide].
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
*/
void
gtk_popover_popdown (GtkPopover *popover)
{
g_return_if_fail (GTK_IS_POPOVER (popover));
gtk_widget_hide (GTK_WIDGET (popover));
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
cascade_popdown (popover);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
}
Add default widget handling to popovers Add a new API, gtk_popover_set_default_widget, that can be used to make a widget act as default while the popover is shown. This is useful in dialog-like popovers. http://bugzilla.gnome.org/show_bug.cgi?id=747664
2015-04-17 04:10:06 +00:00
GtkWidget *
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
gtk_popover_get_contents_widget (GtkPopover *popover)
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
Reimplement GtkPopover
2019-04-29 03:25:37 +00:00
return priv->contents_widget;
GtkPopover: Add gtk_popover_popdown/popup Since not chaining up in gtk_widget_show/gtk_widget_hide is not allowed, we can't just implicitly delay the hiding in GtkPopover's hide implementation. Fix this by introducing gtk_popover_popup() and gtk_popover_popdown() to show or hide a popover with transition and revert GtkPopover's show/hide implementation to apply their effect without the transition. https://bugzilla.gnome.org/show_bug.cgi?id=769706
2016-08-10 16:28:14 +00:00
}
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_has_arrow: (attributes org.gtk.Method.set_property=has-arrow)
* @popover: a `GtkPopover`
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
* @has_arrow: %TRUE to draw an arrow
*
* Sets whether this popover should draw an arrow
* pointing at the widget it is relative to.
*/
void
gtk_popover_set_has_arrow (GtkPopover *popover,
gboolean has_arrow)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
g_return_if_fail (GTK_IS_POPOVER (popover));
if (priv->has_arrow == has_arrow)
return;
priv->has_arrow = has_arrow;
g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_HAS_ARROW]);
gtk_widget_queue_resize (GTK_WIDGET (popover));
}
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_get_has_arrow: (attributes org.gtk.Method.get_property=has-arrow)
* @popover: a `GtkPopover`
popover: Make it possible to not have an arrow This will make popovers move flexible for other uses, such as the Emoji completion popup.
2019-05-22 00:42:07 +00:00
*
* Gets whether this popover is showing an arrow
* pointing at the widget that it is relative to.
*
* Returns: whether the popover has an arrow
*/
gboolean
gtk_popover_get_has_arrow (GtkPopover *popover)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
g_return_val_if_fail (GTK_IS_POPOVER (popover), TRUE);
return priv->has_arrow;
}
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_mnemonics_visible: (attributes org.gtk.Method.set_property=mnemonics-visible)
* @popover: a `GtkPopover`
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
* @mnemonics_visible: the new value
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Sets whether mnemonics should be visible.
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
*/
void
gtk_popover_set_mnemonics_visible (GtkPopover *popover,
gboolean mnemonics_visible)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
g_return_if_fail (GTK_IS_POPOVER (popover));
if (priv->mnemonics_visible == mnemonics_visible)
return;
priv->mnemonics_visible = mnemonics_visible;
g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_MNEMONICS_VISIBLE]);
gtk_widget_queue_resize (GTK_WIDGET (popover));
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
if (priv->mnemonics_display_timeout_id)
{
g_source_remove (priv->mnemonics_display_timeout_id);
priv->mnemonics_display_timeout_id = 0;
}
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
}
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_get_mnemonics_visible: (attributes org.gtk.Method.get_property=mnemonics-visible)
* @popover: a `GtkPopover`
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Gets whether mnemonics are visible.
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Returns: %TRUE if mnemonics are supposed to be visible
* in this popover
popover: Add a mnemonics-visible property This will be handled separately for popovers, so we need our own property for it.
2020-03-24 16:29:26 +00:00
*/
gboolean
gtk_popover_get_mnemonics_visible (GtkPopover *popover)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
g_return_val_if_fail (GTK_IS_POPOVER (popover), FALSE);
return priv->mnemonics_visible;
}
popover: Implement auto mnemonics Unfortunately, this involves copying a bunch of code from gtkwindow.c. The only difference here is that we add a private method to turn this off, which will be used by GtkPopoverMenu to implement its own auto mnemonics.
2020-03-24 16:45:43 +00:00
void
gtk_popover_disable_auto_mnemonics (GtkPopover *popover)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
priv->disable_auto_mnemonics = TRUE;
}
popover: allow setting popup layout offset Currently there is no way to alter the offset of the popup when positioning with GdkPopupLayout. This makes using the popup difficult for scenarios like completion windows where you may need to offset the window by a given amount for aligning text. gtk_popover_set_offset() allows setting these values and are analagous to the function of the same name for GdkPopupLayout.
2020-08-08 00:06:08 +00:00
/**
* gtk_popover_set_offset:
popover: Convert docs
2021-02-27 04:15:43 +00:00
* @popover: a `GtkPopover`
popover: allow setting popup layout offset Currently there is no way to alter the offset of the popup when positioning with GdkPopupLayout. This makes using the popup difficult for scenarios like completion windows where you may need to offset the window by a given amount for aligning text. gtk_popover_set_offset() allows setting these values and are analagous to the function of the same name for GdkPopupLayout.
2020-08-08 00:06:08 +00:00
* @x_offset: the x offset to adjust the position by
* @y_offset: the y offset to adjust the position by
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Sets the offset to use when calculating the position
* of the popover.
popover: allow setting popup layout offset Currently there is no way to alter the offset of the popup when positioning with GdkPopupLayout. This makes using the popup difficult for scenarios like completion windows where you may need to offset the window by a given amount for aligning text. gtk_popover_set_offset() allows setting these values and are analagous to the function of the same name for GdkPopupLayout.
2020-08-08 00:06:08 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* These values are used when preparing the [struct@Gdk.PopupLayout]
* for positioning the popover.
popover: allow setting popup layout offset Currently there is no way to alter the offset of the popup when positioning with GdkPopupLayout. This makes using the popup difficult for scenarios like completion windows where you may need to offset the window by a given amount for aligning text. gtk_popover_set_offset() allows setting these values and are analagous to the function of the same name for GdkPopupLayout.
2020-08-08 00:06:08 +00:00
*/
void
gtk_popover_set_offset (GtkPopover *popover,
int x_offset,
int y_offset)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
g_return_if_fail (GTK_IS_POPOVER (popover));
if (priv->x_offset != x_offset || priv->y_offset != y_offset)
{
priv->x_offset = x_offset;
priv->y_offset = y_offset;
gtk_widget_queue_resize (GTK_WIDGET (popover));
}
}
/**
* gtk_popover_get_offset:
popover: Convert docs
2021-02-27 04:15:43 +00:00
* @popover: a `GtkPopover`
popover: allow setting popup layout offset Currently there is no way to alter the offset of the popup when positioning with GdkPopupLayout. This makes using the popup difficult for scenarios like completion windows where you may need to offset the window by a given amount for aligning text. gtk_popover_set_offset() allows setting these values and are analagous to the function of the same name for GdkPopupLayout.
2020-08-08 00:06:08 +00:00
* @x_offset: (out) (nullable): a location for the x_offset
* @y_offset: (out) (nullable): a location for the y_offset
*
* Gets the offset previous set with gtk_popover_set_offset().
*/
void
gtk_popover_get_offset (GtkPopover *popover,
int *x_offset,
int *y_offset)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
g_return_if_fail (GTK_IS_POPOVER (popover));
if (x_offset)
*x_offset = priv->x_offset;
if (y_offset)
*y_offset = priv->y_offset;
}
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_set_cascade_popdown: (attributes org.gtk.Method.set_property=cascade-popdown)
* @popover: A `GtkPopover`
* @cascade_popdown: %TRUE if the popover should follow a child closing
*
* If @cascade_popdown is %TRUE, the popover will be
* closed when a child modal popover is closed.
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* If %FALSE, @popover will stay visible.
*/
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
void
gtk_popover_set_cascade_popdown (GtkPopover *popover,
gboolean cascade_popdown)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
if (priv->cascade_popdown != !!cascade_popdown)
{
priv->cascade_popdown = !!cascade_popdown;
g_object_notify (G_OBJECT (popover), "cascade-popdown");
}
}
/**
popover: Convert docs
2021-02-27 04:15:43 +00:00
* gtk_popover_get_cascade_popdown: (attributes org.gtk.Method.get_property=cascade-popdown)
* @popover: a `GtkPopover`
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
*
* Returns whether the popover will close after a modal child is closed.
*
popover: Convert docs
2021-02-27 04:15:43 +00:00
* Returns: %TRUE if @popover will close after a modal child.
*/
gtkpopover: Add cascade-popdown property/functions And honor it in gtk_popover_popdown(). By default, a GtkPopover pops down automatically if a child popover was closed, if this property is FALSE, the popover will remain opened.
2020-10-13 12:26:41 +00:00
gboolean
gtk_popover_get_cascade_popdown (GtkPopover *popover)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
return priv->cascade_popdown;
}
Reference in New Issue Copy Permalink