[gtk+/wip/attachment-parameters-4: 1/24] gdkattachparams: add GdkAttachParams
- From: William Hua <williamhua src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/wip/attachment-parameters-4: 1/24] gdkattachparams: add GdkAttachParams
- Date: Tue, 22 Dec 2015 19:44:53 +0000 (UTC)
commit dde3e1d64674efc6fe47b1700b5a5c05ff6d9104
Author: William Hua <william hua canonical com>
Date: Fri Sep 18 13:40:36 2015 -0400
gdkattachparams: add GdkAttachParams
docs/reference/gdk/gdk-docs.sgml | 1 +
docs/reference/gdk/gdk3-sections.txt | 31 ++
gdk/Makefile.am | 3 +
gdk/gdk.h | 1 +
gdk/gdkattachparams.c | 943 ++++++++++++++++++++++++++++++++++
gdk/gdkattachparams.h | 161 ++++++
gdk/gdkattachparamsprivate.h | 81 +++
7 files changed, 1221 insertions(+), 0 deletions(-)
---
diff --git a/docs/reference/gdk/gdk-docs.sgml b/docs/reference/gdk/gdk-docs.sgml
index fdd36a4..6962b4d 100644
--- a/docs/reference/gdk/gdk-docs.sgml
+++ b/docs/reference/gdk/gdk-docs.sgml
@@ -47,6 +47,7 @@
<xi:include href="xml/wayland_interaction.xml" />
<xi:include href="xml/gdkapplaunchcontext.xml" />
<xi:include href="xml/gdktestutils.xml" />
+ <xi:include href="xml/gdkattachparams.xml" />
</reference>
<reference>
diff --git a/docs/reference/gdk/gdk3-sections.txt b/docs/reference/gdk/gdk3-sections.txt
index 7b1b9f7..34c4e1f 100644
--- a/docs/reference/gdk/gdk3-sections.txt
+++ b/docs/reference/gdk/gdk3-sections.txt
@@ -551,6 +551,37 @@ gdk_fullscreen_mode_get_type
</SECTION>
<SECTION>
+<TITLE>Attachment Parameters</TITLE>
+<FILE>gdkattachparams</FILE>
+GdkAttachParams
+GdkAttachRule
+GdkAttachCallback
+gdk_attach_params_new
+gdk_attach_params_copy
+gdk_attach_params_free
+gdk_attach_params_set_attach_origin
+gdk_attach_params_set_attach_rect
+gdk_attach_params_set_attach_margin
+gdk_attach_params_set_window_margin
+gdk_attach_params_set_window_padding
+gdk_attach_params_set_window_offset
+gdk_attach_params_get_window_type_hint
+gdk_attach_params_set_window_type_hint
+gdk_attach_params_set_right_to_left
+gdk_attach_params_add_primary_rules
+gdk_attach_params_add_secondary_rules
+gdk_attach_params_add_primary_rules_valist
+gdk_attach_params_add_secondary_rules_valist
+gdk_attach_params_set_position_callback
+
+<SUBSECTION Private>
+_GdkAttachParams
+gdk_attach_params_choose_position
+gdk_attach_params_choose_position_for_window
+gdk_window_move_using_attach_params
+</SECTION>
+
+<SECTION>
<TITLE>Selections</TITLE>
<FILE>selections</FILE>
GDK_SELECTION_PRIMARY
diff --git a/gdk/Makefile.am b/gdk/Makefile.am
index bb0007a..a56dd56 100644
--- a/gdk/Makefile.am
+++ b/gdk/Makefile.am
@@ -63,6 +63,7 @@ gdk_public_h_sources = \
gdk.h \
gdk-autocleanup.h \
gdkapplaunchcontext.h \
+ gdkattachparams.h \
gdkcairo.h \
gdkcursor.h \
gdkdevice.h \
@@ -103,6 +104,7 @@ gdk_h_sources = \
gdk_private_headers = \
gdk-private.h \
gdkapplaunchcontextprivate.h \
+ gdkattachparamsprivate.h \
gdkcursorprivate.h \
gdkdevicemanagerprivate.h \
gdkdeviceprivate.h \
@@ -129,6 +131,7 @@ gdk_c_sources = \
gdk-private.c \
gdk.c \
gdkapplaunchcontext.c \
+ gdkattachparams.c \
gdkcairo.c \
gdkcursor.c \
gdkdeprecated.c \
diff --git a/gdk/gdk.h b/gdk/gdk.h
index 81ba765..869f6bf 100644
--- a/gdk/gdk.h
+++ b/gdk/gdk.h
@@ -30,6 +30,7 @@
#include <gdk/gdkconfig.h>
#include <gdk/gdkversionmacros.h>
#include <gdk/gdkapplaunchcontext.h>
+#include <gdk/gdkattachparams.h>
#include <gdk/gdkcairo.h>
#include <gdk/gdkcursor.h>
#include <gdk/gdkdevice.h>
diff --git a/gdk/gdkattachparams.c b/gdk/gdkattachparams.c
new file mode 100644
index 0000000..2f8811e
--- /dev/null
+++ b/gdk/gdkattachparams.c
@@ -0,0 +1,943 @@
+#include "config.h"
+
+#include "gdkattachparamsprivate.h"
+#include "gdkscreen.h"
+#include "gdkwindow.h"
+
+/**
+ * SECTION: gdkattachparams
+ * @section_id: gdkattachparams
+ * @title: Attachment Parameters
+ * @short_description: Describing relative window position
+ * @stability: Unstable
+ * @include: gdk/gdkattachparams.h
+ *
+ * A full description of how a window should be positioned relative to an
+ * attachment rectangle.
+ *
+ * Since: 3.20
+ */
+
+/**
+ * gdk_attach_params_new:
+ *
+ * Creates a new #GdkAttachParams for describing the position of a #GdkWindow
+ * relative to an attachment #GdkRectangle.
+ *
+ * Returns: (transfer full): a new #GdkAttachParams, to be freed with
+ * gdk_attach_params_free()
+ *
+ * Since: 3.20
+ */
+GdkAttachParams *
+gdk_attach_params_new (void)
+{
+ GdkAttachParams *params = g_new0 (GdkAttachParams, 1);
+
+ params->primary_rules = g_array_new (TRUE, TRUE, sizeof (GdkAttachRule));
+ params->secondary_rules = g_array_new (TRUE, TRUE, sizeof (GdkAttachRule));
+
+ return params;
+}
+
+/**
+ * gdk_attach_params_copy:
+ * @src: the #GdkAttachParams to copy
+ * @data: (nullable): unused
+ *
+ * Creates a deep copy of @src.
+ *
+ * Returns: (transfer full) (nullable): a deep copy of @src, to be freed with
+ * gdk_attach_params_free()
+ *
+ * Since: 3.20
+ */
+gpointer
+gdk_attach_params_copy (gconstpointer src,
+ gpointer data)
+{
+ GdkAttachParams *copy;
+ const GdkAttachParams *params;
+
+ if (!src)
+ return NULL;
+
+ params = src;
+
+ copy = g_memdup (params, sizeof (*params));
+
+ copy->primary_rules = g_array_sized_new (TRUE, TRUE, sizeof (GdkAttachRule),
+ params->primary_rules->len);
+
+ g_array_append_vals (copy->primary_rules,
+ params->primary_rules->data,
+ params->primary_rules->len);
+
+ copy->secondary_rules = g_array_sized_new (TRUE, TRUE, sizeof (GdkAttachRule),
+ params->secondary_rules->len);
+
+ g_array_append_vals (copy->secondary_rules,
+ params->secondary_rules->data,
+ params->secondary_rules->len);
+
+ return copy;
+}
+
+/**
+ * gdk_attach_params_free:
+ * @data: the #GdkAttachParams to free
+ *
+ * Releases @data.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_free (gpointer data)
+{
+ GdkAttachParams *params;
+
+ g_return_if_fail (data);
+
+ params = data;
+
+ if (params->attach_user_data && params->attach_destroy_notify)
+ params->attach_destroy_notify (params->attach_user_data);
+
+ g_array_unref (params->secondary_rules);
+ g_array_unref (params->primary_rules);
+
+ g_free (params);
+}
+
+/**
+ * gdk_attach_params_set_attach_origin:
+ * @params: a #GdkAttachParams
+ * @origin: (nullable): the attachment rectangle's origin
+ *
+ * Sets the origin of the attachment rectangle's coordinate system in root
+ * coordinates.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_attach_origin (GdkAttachParams *params,
+ const GdkPoint *origin)
+{
+ GdkPoint zero = { 0 };
+
+ g_return_if_fail (params);
+
+ params->attach_origin = origin ? *origin : zero;
+}
+
+/**
+ * gdk_attach_params_set_attach_rect:
+ * @params: a #GdkAttachParams
+ * @rectangle: (nullable): the attachment rectangle
+ *
+ * Sets the attachment rectangle the window needs to be aligned relative to.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_attach_rect (GdkAttachParams *params,
+ const GdkRectangle *rectangle)
+{
+ g_return_if_fail (params);
+
+ if (rectangle)
+ {
+ params->has_attach_rect = TRUE;
+ params->attach_rect = *rectangle;
+ }
+ else
+ params->has_attach_rect = FALSE;
+}
+
+/**
+ * gdk_attach_params_set_attach_margin:
+ * @params: a #GdkAttachParams
+ * @margin: (nullable): the space around the attachment rectangle
+ *
+ * Sets the amount of space to leave around the attachment rectangle.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_attach_margin (GdkAttachParams *params,
+ const GdkBorder *margin)
+{
+ GdkBorder zero = { 0 };
+
+ g_return_if_fail (params);
+
+ params->attach_margin = margin ? *margin : zero;
+}
+
+/**
+ * gdk_attach_params_set_window_margin:
+ * @params: a #GdkAttachParams
+ * @margin: (nullable): the space around the window
+ *
+ * Sets the amount of space to leave around the window.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_window_margin (GdkAttachParams *params,
+ const GdkBorder *margin)
+{
+ GdkBorder zero = { 0 };
+
+ g_return_if_fail (params);
+
+ params->window_margin = margin ? *margin : zero;
+}
+
+/**
+ * gdk_attach_params_set_window_padding:
+ * @params: a #GdkAttachParams
+ * @padding: (nullable): the space between the window and its
+ * contents.
+ *
+ * Sets the amount of space between the window and its contents.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_window_padding (GdkAttachParams *params,
+ const GdkBorder *padding)
+{
+ GdkBorder zero = { 0 };
+
+ g_return_if_fail (params);
+
+ params->window_padding = padding ? *padding : zero;
+}
+
+/**
+ * gdk_attach_params_set_window_offset:
+ * @params: a #GdkAttachParams
+ * @offset: (nullable): the window displacement
+ *
+ * Sets the offset to displace the window by.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_window_offset (GdkAttachParams *params,
+ const GdkPoint *offset)
+{
+ GdkPoint zero = { 0 };
+
+ g_return_if_fail (params);
+
+ params->window_offset = offset ? *offset : zero;
+}
+
+/**
+ * gdk_attach_params_get_window_type_hint:
+ * @params: a #GdkAttachParams
+ *
+ * Gets the window type hint set on @params.
+ *
+ * Returns: the window type hint set on @params
+ *
+ * Since: 3.20
+ */
+GdkWindowTypeHint
+gdk_attach_params_get_window_type_hint (const GdkAttachParams *params)
+{
+ g_return_val_if_fail (params, GDK_WINDOW_TYPE_HINT_NORMAL);
+
+ return params->window_type_hint;
+}
+
+/**
+ * gdk_attach_params_set_window_type_hint:
+ * @params: a #GdkAttachParams
+ * @window_type_hint: the window type hint
+ *
+ * Sets the window type hint.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_window_type_hint (GdkAttachParams *params,
+ GdkWindowTypeHint window_type_hint)
+{
+ g_return_if_fail (params);
+
+ params->window_type_hint = window_type_hint;
+}
+
+/**
+ * gdk_attach_params_set_right_to_left:
+ * @params: a #GdkAttachParams
+ * @is_right_to_left: %TRUE if the text direction is right to left
+ *
+ * Sets the window text direction.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_right_to_left (GdkAttachParams *params,
+ gboolean is_right_to_left)
+{
+ g_return_if_fail (params);
+
+ params->is_right_to_left = is_right_to_left;
+}
+
+static void
+add_rules (GArray *array,
+ GdkAttachRule first_rule,
+ va_list args)
+{
+ GdkAttachRule rule;
+
+ for (rule = first_rule; rule; rule = va_arg (args, GdkAttachRule))
+ g_array_append_val (array, rule);
+}
+
+/**
+ * gdk_attach_params_add_primary_rules_valist:
+ * @params: a #GdkAttachParams
+ * @first_rule: first primary rule
+ * @args: a #va_list of the remaining primary rules
+ *
+ * Non-variadic version of gdk_attach_params_add_primary_rules().
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_add_primary_rules_valist (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ va_list args)
+{
+ add_rules (params->primary_rules, first_rule, args);
+}
+
+/**
+ * gdk_attach_params_add_secondary_rules_valist:
+ * @params: a #GdkAttachParams
+ * @first_rule: first secondary rule
+ * @args: a #va_list of the remaining secondary rules
+ *
+ * Non-variadic version of gdk_attach_params_add_secondary_rules().
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_add_secondary_rules_valist (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ va_list args)
+{
+ add_rules (params->secondary_rules, first_rule, args);
+}
+
+/**
+ * gdk_attach_params_add_primary_rules:
+ * @params: a #GdkAttachParams
+ * @first_rule: first primary rule
+ * @...: a %NULL-terminated list of rules
+ *
+ * Appends to the list of primary positioning rules to try.
+ *
+ * A typical backend will try each primary rule in the order they're added. If
+ * a rule can be satisfied, it will then try each secondary rule until it
+ * finds a satisfiable secondary rule that doesn't conflict with the primary
+ * rule. If it finds a pair of satisfiable non-conflicting rules, then it will
+ * place the window there. If it cannot find a pair, it proceeds to the next
+ * primary rule and tries again.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_add_primary_rules (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (params);
+
+ va_start (args, first_rule);
+
+ gdk_attach_params_add_primary_rules_valist (params, first_rule, args);
+
+ va_end (args);
+}
+
+/**
+ * gdk_attach_params_add_secondary_rules:
+ * @params: a #GdkAttachParams
+ * @first_rule: first secondary rule
+ * @...: a %NULL-terminated list of rules
+ *
+ * Appends to the list of secondary positioning rules to try.
+ *
+ * A typical backend will try each primary rule in the order they're added. If
+ * a rule can be satisfied, it will then try each secondary rule until it
+ * finds a satisfiable secondary rule that doesn't conflict with the primary
+ * rule. If it finds a pair of satisfiable non-conflicting rules, then it will
+ * place the window there. If it cannot find a pair, it proceeds to the next
+ * primary rule and tries again.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_add_secondary_rules (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (params);
+
+ va_start (args, first_rule);
+
+ gdk_attach_params_add_secondary_rules_valist (params, first_rule, args);
+
+ va_end (args);
+}
+
+/**
+ * gdk_attach_params_set_position_callback:
+ * @params: a #GdkAttachParams
+ * @callback: (nullable): a function to be called when the final position of
+ * the window is known
+ * @user_data: (transfer full) (nullable): additional data to pass to @callback
+ * @destroy_notify: (nullable): a function to release @user_data
+ *
+ * Sets the function to be called when the final position of the window is
+ * known.
+ *
+ * Since: 3.20
+ */
+void
+gdk_attach_params_set_position_callback (GdkAttachParams *params,
+ GdkAttachCallback callback,
+ gpointer user_data,
+ GDestroyNotify destroy_notify)
+{
+ g_return_if_fail (params);
+
+ params->attach_callback = callback;
+
+ if (user_data != params->attach_user_data)
+ {
+ if (params->attach_user_data && params->attach_destroy_notify)
+ params->attach_destroy_notify (params->attach_user_data);
+
+ params->attach_user_data = user_data;
+ params->attach_destroy_notify = destroy_notify;
+ }
+ else if (user_data)
+ g_warning ("%s (): params already owns user data", G_STRFUNC);
+}
+
+static gboolean
+is_satisfiable (GdkAttachRule rule,
+ const GdkAttachParams *params,
+ gint width,
+ gint height,
+ const GdkRectangle *bounds,
+ gint *value)
+{
+ gboolean use_rect_margin;
+ gboolean use_window_margin;
+ gboolean use_window_padding;
+
+ g_return_val_if_fail (params, FALSE);
+ g_return_val_if_fail (params->has_attach_rect, FALSE);
+
+ if (params->is_right_to_left && (rule & GDK_ATTACH_FLIP_IF_RTL))
+ {
+ switch (rule & GDK_ATTACH_RECT_MASK)
+ {
+ case GDK_ATTACH_RECT_MIN:
+ rule = (rule & ~(GDK_ATTACH_RECT_MASK | GDK_ATTACH_FLIP_IF_RTL)) | GDK_ATTACH_RECT_MAX;
+ break;
+
+ case GDK_ATTACH_RECT_MAX:
+ rule = (rule & ~(GDK_ATTACH_RECT_MASK | GDK_ATTACH_FLIP_IF_RTL)) | GDK_ATTACH_RECT_MIN;
+ break;
+ }
+
+ switch (rule & GDK_ATTACH_WINDOW_MASK)
+ {
+ case GDK_ATTACH_WINDOW_MIN:
+ rule = (rule & ~(GDK_ATTACH_WINDOW_MASK | GDK_ATTACH_FLIP_IF_RTL)) | GDK_ATTACH_WINDOW_MAX;
+ break;
+
+ case GDK_ATTACH_WINDOW_MAX:
+ rule = (rule & ~(GDK_ATTACH_WINDOW_MASK | GDK_ATTACH_FLIP_IF_RTL)) | GDK_ATTACH_WINDOW_MIN;
+ break;
+ }
+ }
+
+ use_rect_margin = (((rule & GDK_ATTACH_RECT_MASK) == GDK_ATTACH_RECT_MIN &&
+ (rule & GDK_ATTACH_WINDOW_MASK) == GDK_ATTACH_WINDOW_MAX) ||
+ ((rule & GDK_ATTACH_RECT_MASK) == GDK_ATTACH_RECT_MAX &&
+ (rule & GDK_ATTACH_WINDOW_MASK) == GDK_ATTACH_WINDOW_MIN));
+
+ use_window_margin = use_rect_margin;
+
+ use_window_padding = TRUE;
+
+ switch (rule & GDK_ATTACH_AXIS_MASK)
+ {
+ case GDK_ATTACH_AXIS_X:
+ *value = params->attach_origin.x;
+
+ switch (rule & GDK_ATTACH_RECT_MASK)
+ {
+ case GDK_ATTACH_RECT_MIN:
+ *value += params->attach_rect.x;
+
+ if (use_rect_margin)
+ *value -= params->attach_margin.left;
+
+ break;
+
+ case GDK_ATTACH_RECT_MID:
+ *value += params->attach_rect.x + params->attach_rect.width / 2;
+ break;
+
+ case GDK_ATTACH_RECT_MAX:
+ *value += params->attach_rect.x + params->attach_rect.width;
+
+ if (use_rect_margin)
+ *value += params->attach_margin.right;
+
+ break;
+ }
+
+ switch (rule & GDK_ATTACH_WINDOW_MASK)
+ {
+ case GDK_ATTACH_WINDOW_MIN:
+ if (use_window_margin)
+ *value += params->window_margin.left;
+
+ if (use_window_padding)
+ *value -= params->window_margin.left;
+
+ break;
+
+ case GDK_ATTACH_WINDOW_MID:
+ *value -= width / 2;
+ break;
+
+ case GDK_ATTACH_WINDOW_MAX:
+ *value -= width;
+
+ if (use_window_margin)
+ *value -= params->window_margin.right;
+
+ if (use_window_padding)
+ *value += params->window_margin.right;
+
+ break;
+ }
+
+ *value += params->window_offset.x;
+
+ return !bounds || (bounds->x <= *value && *value + width <= bounds->x + bounds->width);
+
+ case GDK_ATTACH_AXIS_Y:
+ *value = params->attach_origin.y;
+
+ switch (rule & GDK_ATTACH_RECT_MASK)
+ {
+ case GDK_ATTACH_RECT_MIN:
+ *value += params->attach_rect.y;
+
+ if (use_rect_margin)
+ *value -= params->attach_margin.top;
+
+ break;
+
+ case GDK_ATTACH_RECT_MID:
+ *value += params->attach_rect.y + params->attach_rect.height / 2;
+ break;
+
+ case GDK_ATTACH_RECT_MAX:
+ *value += params->attach_rect.y + params->attach_rect.height;
+
+ if (use_rect_margin)
+ *value += params->attach_margin.bottom;
+
+ break;
+ }
+
+ switch (rule & GDK_ATTACH_WINDOW_MASK)
+ {
+ case GDK_ATTACH_WINDOW_MIN:
+ if (use_window_margin)
+ *value += params->window_margin.top;
+
+ if (use_window_padding)
+ *value -= params->window_margin.top;
+
+ break;
+
+ case GDK_ATTACH_WINDOW_MID:
+ *value -= height / 2;
+ break;
+
+ case GDK_ATTACH_WINDOW_MAX:
+ *value -= height;
+
+ if (use_window_margin)
+ *value -= params->window_margin.bottom;
+
+ if (use_window_padding)
+ *value += params->window_margin.bottom;
+
+ break;
+ }
+
+ *value += params->window_offset.y;
+
+ return !bounds || (bounds->y <= *value && *value + height <= bounds->y + bounds->height);
+ }
+
+ return FALSE;
+}
+
+#define BEST 0
+#define GOOD 1
+#define PRIMARY 0
+#define SECONDARY 1
+#define X 0
+#define Y 1
+
+/**
+ * gdk_attach_params_choose_position:
+ * @params: a #GdkAttachParams
+ * @width: window width
+ * @height: window height
+ * @bounds: (nullable): monitor geometry
+ * @position: (out) (optional): the best position for the window
+ * @offset: (out) (optional): the displacement needed to push the window
+ * on-screen
+ * @primary_rule: (out) (optional): the best primary rule
+ * @secondary_rule: (out) (optional): the best secondary rule
+ *
+ * Finds the best position for a window of size @width and @height on a screen
+ * with @bounds using the given @params.
+ *
+ * Returns: %TRUE if there is a pair of satisfiable primary and secondary
+ * rules that do not conflict with each other
+ *
+ * Since: 3.20
+ */
+gboolean
+gdk_attach_params_choose_position (const GdkAttachParams *params,
+ gint width,
+ gint height,
+ const GdkRectangle *bounds,
+ GdkPoint *position,
+ GdkPoint *offset,
+ GdkAttachRule *primary_rule,
+ GdkAttachRule *secondary_rule)
+{
+ GdkPoint p;
+ GdkPoint o;
+ GdkAttachRule pr;
+ GdkAttachRule sr;
+ GdkAttachRule rules[2][2][2] = { 0 };
+ gint axes[2][2] = { 0 };
+ gint values[2][2][2] = { 0 };
+ GArray *arrays[2];
+ gint i;
+ gint j;
+ gint k;
+ GdkAttachRule rule;
+ gint axis;
+ gint value;
+ gboolean satisfiable;
+ gboolean success;
+ GdkAttachRule x_rule;
+ GdkAttachRule y_rule;
+
+ g_return_val_if_fail (params, FALSE);
+ g_return_val_if_fail (params->has_attach_rect, FALSE);
+
+ if (!position)
+ position = &p;
+
+ if (!offset)
+ offset = &o;
+
+ if (!primary_rule)
+ primary_rule = ≺
+
+ if (!secondary_rule)
+ secondary_rule = &sr;
+
+ arrays[PRIMARY] = params->primary_rules;
+ arrays[SECONDARY] = params->secondary_rules;
+
+ for (i = PRIMARY; i <= SECONDARY; i++)
+ {
+ for (j = 0; j < arrays[i]->len; j++)
+ {
+ rule = g_array_index (arrays[i], GdkAttachRule, j);
+
+ switch (rule & GDK_ATTACH_AXIS_MASK)
+ {
+ case GDK_ATTACH_AXIS_X:
+ axis = X;
+ break;
+
+ case GDK_ATTACH_AXIS_Y:
+ axis = Y;
+ break;
+
+ default:
+ axis = -1;
+ break;
+ }
+
+ if (axis < 0)
+ {
+ g_warning ("%s (): invalid constraint axis: 0x%X", G_STRFUNC, rule);
+ continue;
+ }
+
+ satisfiable = is_satisfiable (rule, params, width, height, bounds, &value);
+
+ if (satisfiable && !rules[i][BEST][axis])
+ {
+ rules[i][BEST][axis] = rule;
+ values[i][BEST][axis] = value;
+
+ if (rules[i][BEST][!axis])
+ break;
+ else
+ axes[i][BEST] = axis;
+ }
+ else if (!rules[i][GOOD][axis])
+ {
+ rules[i][GOOD][axis] = rule;
+ values[i][GOOD][axis] = value;
+
+ if (!rules[i][GOOD][!axis])
+ axes[i][GOOD] = axis;
+ }
+ }
+ }
+
+ success = FALSE;
+
+ for (i = BEST; i <= GOOD; i++)
+ {
+ for (j = BEST; j <= GOOD; j++)
+ {
+ for (k = Y; k >= X; k--)
+ {
+ if (rules[PRIMARY][i][axes[PRIMARY][i] == k] && rules[SECONDARY][j][axes[PRIMARY][i] != k])
+ {
+ *primary_rule = rules[PRIMARY][i][axes[PRIMARY][i] == k];
+ *secondary_rule = rules[SECONDARY][j][axes[PRIMARY][i] != k];
+
+ if ((axes[PRIMARY][i] == k) == X)
+ {
+ position->x = values[PRIMARY][i][X];
+ position->y = values[SECONDARY][j][Y];
+ }
+ else
+ {
+ position->x = values[SECONDARY][j][X];
+ position->y = values[PRIMARY][i][Y];
+ }
+
+ offset->x = 0;
+ offset->y = 0;
+ success = TRUE;
+ break;
+ }
+ }
+
+ if (success)
+ break;
+ }
+
+ if (success)
+ break;
+ }
+
+ if (success && bounds)
+ {
+ if ((*primary_rule & GDK_ATTACH_AXIS_MASK) == GDK_ATTACH_AXIS_X)
+ {
+ x_rule = *primary_rule;
+ y_rule = *secondary_rule;
+ }
+ else
+ {
+ x_rule = *secondary_rule;
+ y_rule = *primary_rule;
+ }
+
+ if (params->is_right_to_left && (x_rule & GDK_ATTACH_FLIP_IF_RTL))
+ {
+ if (position->x < bounds->x)
+ {
+ offset->x += bounds->x - position->x;
+ position->x = bounds->x;
+ }
+
+ if (position->x + width > bounds->x + bounds->width)
+ {
+ offset->x += bounds->x + bounds->width - width - position->x;
+ position->x = bounds->x + bounds->width - width;
+ }
+ }
+ else
+ {
+ if (position->x + width > bounds->x + bounds->width)
+ {
+ offset->x += bounds->x + bounds->width - width - position->x;
+ position->x = bounds->x + bounds->width - width;
+ }
+
+ if (position->x < bounds->x)
+ {
+ offset->x += bounds->x - position->x;
+ position->x = bounds->x;
+ }
+ }
+
+ if (params->is_right_to_left && (y_rule & GDK_ATTACH_FLIP_IF_RTL))
+ {
+ if (position->y < bounds->y)
+ {
+ offset->y += bounds->y - position->y;
+ position->y = bounds->y;
+ }
+
+ if (position->y + height > bounds->y + bounds->height)
+ {
+ offset->y += bounds->y + bounds->height - height - position->y;
+ position->y = bounds->y + bounds->height - height;
+ }
+ }
+ else
+ {
+ if (position->y + height > bounds->y + bounds->height)
+ {
+ offset->y += bounds->y + bounds->height - height - position->y;
+ position->y = bounds->y + bounds->height - height;
+ }
+
+ if (position->y < bounds->y)
+ {
+ offset->y += bounds->y - position->y;
+ position->y = bounds->y;
+ }
+ }
+ }
+
+ return success;
+}
+
+/**
+ * gdk_attach_params_choose_position_for_window:
+ * @params: a #GdkAttachParams
+ * @window: (transfer none) (not nullable): the #GdkWindow to find the best
+ * position for
+ * @position: (out) (optional): the best position for the window
+ * @offset: (out) (optional): the displacement needed to push the window
+ * on-screen
+ * @primary_rule: (out) (optional): the best primary rule
+ * @secondary_rule: (out) (optional): the best secondary rule
+ *
+ * Finds the best position for @window according to @params.
+ *
+ * Returns: %TRUE if there's a best position
+ *
+ * Since: 3.20
+ */
+gboolean
+gdk_attach_params_choose_position_for_window (const GdkAttachParams *params,
+ GdkWindow *window,
+ GdkPoint *position,
+ GdkPoint *offset,
+ GdkAttachRule *primary_rule,
+ GdkAttachRule *secondary_rule)
+{
+ GdkScreen *screen;
+ gint x;
+ gint y;
+ gint monitor;
+ GdkRectangle bounds;
+ gint width;
+ gint height;
+
+ g_return_val_if_fail (params, FALSE);
+ g_return_val_if_fail (params->has_attach_rect, FALSE);
+ g_return_val_if_fail (window, FALSE);
+
+ screen = gdk_window_get_screen (window);
+ x = params->attach_origin.x + params->attach_rect.x + params->attach_rect.width / 2;
+ y = params->attach_origin.y + params->attach_rect.y + params->attach_rect.height / 2;
+ monitor = gdk_screen_get_monitor_at_point (screen, x, y);
+ gdk_screen_get_monitor_workarea (screen, monitor, &bounds);
+ width = gdk_window_get_width (window);
+ height = gdk_window_get_height (window);
+
+ return gdk_attach_params_choose_position (params,
+ width,
+ height,
+ &bounds,
+ position,
+ offset,
+ primary_rule,
+ secondary_rule);
+}
+
+/**
+ * gdk_window_move_using_attach_params:
+ * @window: the #GdkWindow to position
+ * @params: (nullable): a description of how to position @window
+ *
+ * Moves @window to the best position according to @params.
+ *
+ * Since: 3.20
+ */
+void
+gdk_window_move_using_attach_params (GdkWindow *window,
+ const GdkAttachParams *params)
+{
+ GdkPoint position;
+ GdkPoint offset;
+ GdkAttachRule primary_rule;
+ GdkAttachRule secondary_rule;
+
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (!params || !params->has_attach_rect)
+ return;
+
+ if (gdk_attach_params_choose_position_for_window (params,
+ window,
+ &position,
+ &offset,
+ &primary_rule,
+ &secondary_rule))
+ {
+ gdk_window_move (window, position.x, position.y);
+
+ if (params->attach_callback)
+ params->attach_callback (window,
+ params,
+ &position,
+ &offset,
+ primary_rule,
+ secondary_rule,
+ params->attach_user_data);
+ }
+}
diff --git a/gdk/gdkattachparams.h b/gdk/gdkattachparams.h
new file mode 100644
index 0000000..4a6a394
--- /dev/null
+++ b/gdk/gdkattachparams.h
@@ -0,0 +1,161 @@
+#ifndef __GDK_ATTACH_PARAMS_H__
+#define __GDK_ATTACH_PARAMS_H__
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#include <gdk/gdktypes.h>
+#include <gdk/gdkversionmacros.h>
+
+G_BEGIN_DECLS
+
+/**
+ * GdkAttachRule:
+ * @GDK_ATTACH_UNKNOWN: not a constraint
+ * @GDK_ATTACH_AXIS_X: constrain horizontally
+ * @GDK_ATTACH_AXIS_Y: constrain vertically
+ * @GDK_ATTACH_AXIS_MASK: mask for constraint axis
+ * @GDK_ATTACH_RECT_MIN: left/top edge of rectangle
+ * @GDK_ATTACH_RECT_MID: center of rectangle
+ * @GDK_ATTACH_RECT_MAX: right/bottom edge of rectangle
+ * @GDK_ATTACH_RECT_MASK: mask for rectangle anchor
+ * @GDK_ATTACH_WINDOW_MIN: left/top edge of window
+ * @GDK_ATTACH_WINDOW_MID: center of window
+ * @GDK_ATTACH_WINDOW_MAX: right/bottom edge of window
+ * @GDK_ATTACH_WINDOW_MASK: mask for window anchor
+ * @GDK_ATTACH_FLIP_IF_RTL: swap min and max if text is right-to-left
+ *
+ * Constraints on the position of the window relative to its attachment
+ * rectangle.
+ *
+ * Since: 3.20
+ */
+typedef enum _GdkAttachRule
+{
+ GDK_ATTACH_UNKNOWN = 0x00,
+ GDK_ATTACH_AXIS_X = 0x01,
+ GDK_ATTACH_AXIS_Y = 0x02,
+ GDK_ATTACH_AXIS_MASK = 0x03,
+ GDK_ATTACH_RECT_MIN = 0x04,
+ GDK_ATTACH_RECT_MID = 0x08,
+ GDK_ATTACH_RECT_MAX = 0x0C,
+ GDK_ATTACH_RECT_MASK = 0x0C,
+ GDK_ATTACH_WINDOW_MIN = 0x10,
+ GDK_ATTACH_WINDOW_MID = 0x20,
+ GDK_ATTACH_WINDOW_MAX = 0x30,
+ GDK_ATTACH_WINDOW_MASK = 0x30,
+ GDK_ATTACH_FLIP_IF_RTL = 0x40
+} GdkAttachRule;
+
+/**
+ * GdkAttachParams:
+ *
+ * Opaque type containing the information needed to position a window relative
+ * to an attachment rectangle.
+ *
+ * Since: 3.20
+ */
+typedef struct _GdkAttachParams GdkAttachParams;
+
+/**
+ * GdkAttachCallback:
+ * @window: the #GdkWindow that was moved
+ * @params: (transfer none) (nullable): the #GdkAttachParams that was used
+ * @position: (transfer none) (nullable): the final position of @window
+ * @offset: (transfer none) (nullable): the displacement applied to keep
+ * @window on-screen
+ * @primary_rule: the primary rule that was used for positioning. If unknown,
+ * this will be %GDK_ATTACH_UNKNOWN
+ * @secondary_rule: the secondary rule that was used for positioning. If
+ * unknown, this will be %GDK_ATTACH_UNKNOWN
+ * @user_data: (transfer none) (nullable): the user data that was set on
+ * @params
+ *
+ * A function that can be used to receive information about the final position
+ * of a window.
+ *
+ * Since: 3.20
+ */
+typedef void (*GdkAttachCallback) (GdkWindow *window,
+ const GdkAttachParams *params,
+ const GdkPoint *position,
+ const GdkPoint *offset,
+ GdkAttachRule primary_rule,
+ GdkAttachRule secondary_rule,
+ gpointer user_data);
+
+GDK_AVAILABLE_IN_3_20
+GdkAttachParams * gdk_attach_params_new (void);
+
+GDK_AVAILABLE_IN_3_20
+gpointer gdk_attach_params_copy (gconstpointer src,
+ gpointer data);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_free (gpointer data);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_attach_origin (GdkAttachParams *params,
+ const GdkPoint *origin);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_attach_rect (GdkAttachParams *params,
+ const GdkRectangle *rectangle);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_attach_margin (GdkAttachParams *params,
+ const GdkBorder *margin);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_window_margin (GdkAttachParams *params,
+ const GdkBorder *margin);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_window_padding (GdkAttachParams *params,
+ const GdkBorder *padding);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_window_offset (GdkAttachParams *params,
+ const GdkPoint *offset);
+
+GDK_AVAILABLE_IN_3_20
+GdkWindowTypeHint gdk_attach_params_get_window_type_hint (const GdkAttachParams *params);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_window_type_hint (GdkAttachParams *params,
+ GdkWindowTypeHint window_type_hint);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_right_to_left (GdkAttachParams *params,
+ gboolean is_right_to_left);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_add_primary_rules_valist (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ va_list args);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_add_secondary_rules_valist (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ va_list args);
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_add_primary_rules (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ ...) G_GNUC_NULL_TERMINATED;
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_add_secondary_rules (GdkAttachParams *params,
+ GdkAttachRule first_rule,
+ ...) G_GNUC_NULL_TERMINATED;
+
+GDK_AVAILABLE_IN_3_20
+void gdk_attach_params_set_position_callback (GdkAttachParams *params,
+ GdkAttachCallback callback,
+ gpointer user_data,
+ GDestroyNotify destroy_notify);
+
+G_END_DECLS
+
+#endif /* __GDK_ATTACH_PARAMS_H__ */
diff --git a/gdk/gdkattachparamsprivate.h b/gdk/gdkattachparamsprivate.h
new file mode 100644
index 0000000..25abdc9
--- /dev/null
+++ b/gdk/gdkattachparamsprivate.h
@@ -0,0 +1,81 @@
+#ifndef __GDK_ATTACH_PARAMS_PRIVATE_H__
+#define __GDK_ATTACH_PARAMS_PRIVATE_H__
+
+#include "gdkattachparams.h"
+
+G_BEGIN_DECLS
+
+/*
+ * GdkAttachParams:
+ * @attach_origin: root origin of @attach_rect coordinate system
+ * @has_attach_rect: %TRUE if @attach_rect is valid
+ * @attach_rect: the attachment rectangle to attach the window to
+ * @attach_margin: the space to leave around @attach_rect
+ * @window_margin: the space to leave around the window
+ * @window_padding: the space between the window and its contents
+ * @window_offset: the offset to displace the window by
+ * @window_type_hint: the window type hint
+ * @is_right_to_left: %TRUE if the text direction is right to left
+ * @primary_rules: an array of primary #GdkAttachRule
+ * @secondary_rules: an array of secondary #GdkAttachRule
+ * @position_callback: a function to call when the final position is known
+ * @position_callback_user_data: additional data to pass to @position_callback
+ * @position_callback_destroy_notify: a function to free
+ * @position_callback_user_data
+ *
+ * Opaque type containing the information needed to position a window relative
+ * to an attachment rectangle.
+ *
+ * Since: 3.20
+ */
+struct _GdkAttachParams
+{
+ /*< private >*/
+ GdkPoint attach_origin;
+
+ gboolean has_attach_rect;
+ GdkRectangle attach_rect;
+
+ GdkBorder attach_margin;
+ GdkBorder window_margin;
+ GdkBorder window_padding;
+
+ GdkPoint window_offset;
+
+ GdkWindowTypeHint window_type_hint;
+
+ gboolean is_right_to_left;
+
+ GArray *primary_rules;
+ GArray *secondary_rules;
+
+ GdkAttachCallback attach_callback;
+ gpointer attach_user_data;
+ GDestroyNotify attach_destroy_notify;
+};
+
+G_GNUC_INTERNAL
+gboolean gdk_attach_params_choose_position (const GdkAttachParams *params,
+ gint width,
+ gint height,
+ const GdkRectangle *bounds,
+ GdkPoint *position,
+ GdkPoint *offset,
+ GdkAttachRule *primary_rule,
+ GdkAttachRule *secondary_rule);
+
+G_GNUC_INTERNAL
+gboolean gdk_attach_params_choose_position_for_window (const GdkAttachParams *params,
+ GdkWindow *window,
+ GdkPoint *position,
+ GdkPoint *offset,
+ GdkAttachRule *primary_rule,
+ GdkAttachRule *secondary_rule);
+
+G_GNUC_INTERNAL
+void gdk_window_move_using_attach_params (GdkWindow *window,
+ const GdkAttachParams *params);
+
+G_END_DECLS
+
+#endif /* __GDK_ATTACH_PARAMS_PRIVATE_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
