# -*- coding: utf-8 -*-
# This file has been autogenerated by the pywayland scanner

# Copyright © 2008-2013 Kristian Høgsberg
# Copyright © 2013      Rafael Antognolli
# Copyright © 2013      Jasper St. Pierre
# Copyright © 2010-2013 Intel Corporation
# Copyright © 2015-2017 Samsung Electronics Co., Ltd
# Copyright © 2015-2017 Red Hat Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice (including the next
# paragraph) shall be included in all copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

from pywayland.interface import Interface

import enum


class XdgPositioner(Interface):
    """Child surface positioner

    The :class:`XdgPositioner` provides a collection of rules for the placement
    of a child surface relative to a parent surface. Rules can be defined to
    ensure the child surface remains within the visible area's borders, and to
    specify how the child surface changes its position, such as sliding along
    an axis, or flipping around a rectangle. These positioner-created rules are
    constrained by the requirement that a child surface must intersect with or
    be at least partially adjacent to its parent surface.

    See the various requests for details about possible rules.

    At the time of the request, the compositor makes a copy of the rules
    specified by the :class:`XdgPositioner`. Thus, after the request is
    complete the :class:`XdgPositioner` object can be destroyed or reused;
    further changes to the object will have no effect on previous usages.

    For an :class:`XdgPositioner` object to be considered complete, it must
    have a non-zero size set by set_size, and a non-zero anchor rectangle set
    by set_anchor_rect. Passing an incomplete :class:`XdgPositioner` object
    when positioning a surface raises an error.
    """
    name = "xdg_positioner"
    version = 2

    error = enum.Enum("error", {
        "invalid_input": 0,
    })

    anchor = enum.Enum("anchor", {
        "none": 0,
        "top": 1,
        "bottom": 2,
        "left": 3,
        "right": 4,
        "top_left": 5,
        "bottom_left": 6,
        "top_right": 7,
        "bottom_right": 8,
    })

    gravity = enum.Enum("gravity", {
        "none": 0,
        "top": 1,
        "bottom": 2,
        "left": 3,
        "right": 4,
        "top_left": 5,
        "bottom_left": 6,
        "top_right": 7,
        "bottom_right": 8,
    })

    constraint_adjustment = enum.Enum("constraint_adjustment", {
        "none": 0,
        "slide_x": 1,
        "slide_y": 2,
        "flip_x": 4,
        "flip_y": 8,
        "resize_x": 16,
        "resize_y": 32,
    })


@XdgPositioner.request("", [])
def destroy(self):
    """Destroy the :class:`XdgPositioner` object

    Notify the compositor that the :class:`XdgPositioner` will no longer be
    used.
    """
    self._marshal(0)
    self._destroy()


@XdgPositioner.request("ii", [None, None])
def set_size(self, width, height):
    """Set the size of the to-be positioned rectangle

    Set the size of the surface that is to be positioned with the positioner
    object. The size is in surface-local coordinates and corresponds to the
    window geometry. See :func:`XdgSurface.set_window_geometry()
    <pywayland.protocol.xdg_shell.XdgSurface..set_window_geometry>`.

    If a zero or negative size is set the invalid_input error is raised.

    :param width:
        width of positioned rectangle
    :type width: `int`
    :param height:
        height of positioned rectangle
    :type height: `int`
    """
    self._marshal(1, width, height)


@XdgPositioner.request("iiii", [None, None, None, None])
def set_anchor_rect(self, x, y, width, height):
    """Set the anchor rectangle within the parent surface

    Specify the anchor rectangle within the parent surface that the child
    surface will be placed relative to. The rectangle is relative to the window
    geometry as defined by :func:`XdgSurface.set_window_geometry()
    <pywayland.protocol.xdg_shell.XdgSurface..set_window_geometry>` of the
    parent surface.

    When the :class:`XdgPositioner` object is used to position a child surface,
    the anchor rectangle may not extend outside the window geometry of the
    positioned child's parent surface.

    If a negative size is set the invalid_input error is raised.

    :param x:
        x position of anchor rectangle
    :type x: `int`
    :param y:
        y position of anchor rectangle
    :type y: `int`
    :param width:
        width of anchor rectangle
    :type width: `int`
    :param height:
        height of anchor rectangle
    :type height: `int`
    """
    self._marshal(2, x, y, width, height)


@XdgPositioner.request("u", [None])
def set_anchor(self, anchor):
    """Set anchor rectangle anchor

    Defines the anchor point for the anchor rectangle. The specified anchor is
    used derive an anchor point that the child surface will be positioned
    relative to. If a corner anchor is set (e.g. 'top_left' or 'bottom_right'),
    the anchor point will be at the specified corner; otherwise, the derived
    anchor point will be centered on the specified edge, or in the center of
    the anchor rectangle if no edge is specified.

    :param anchor:
        anchor
    :type anchor: `uint`
    """
    self._marshal(3, anchor)


@XdgPositioner.request("u", [None])
def set_gravity(self, gravity):
    """Set child surface gravity

    Defines in what direction a surface should be positioned, relative to the
    anchor point of the parent surface. If a corner gravity is specified (e.g.
    'bottom_right' or 'top_left'), then the child surface will be placed
    towards the specified gravity; otherwise, the child surface will be
    centered over the anchor point on any axis that had no gravity specified.

    :param gravity:
        gravity direction
    :type gravity: `uint`
    """
    self._marshal(4, gravity)


@XdgPositioner.request("u", [None])
def set_constraint_adjustment(self, constraint_adjustment):
    """Set the adjustment to be done when constrained

    Specify how the window should be positioned if the originally intended
    position caused the surface to be constrained, meaning at least partially
    outside positioning boundaries set by the compositor. The adjustment is set
    by constructing a bitmask describing the adjustment to be made when the
    surface is constrained on that axis.

    If no bit for one axis is set, the compositor will assume that the child
    surface should not change its position on that axis when constrained.

    If more than one bit for one axis is set, the order of how adjustments are
    applied is specified in the corresponding adjustment descriptions.

    The default adjustment is none.

    :param constraint_adjustment:
        bit mask of constraint adjustments
    :type constraint_adjustment: `uint`
    """
    self._marshal(5, constraint_adjustment)


@XdgPositioner.request("ii", [None, None])
def set_offset(self, x, y):
    """Set surface position offset

    Specify the surface position offset relative to the position of the anchor
    on the anchor rectangle and the anchor on the surface. For example if the
    anchor of the anchor rectangle is at (x, y), the surface has the gravity
    bottom|right, and the offset is (ox, oy), the calculated surface position
    will be (x + ox, y + oy). The offset position of the surface is the one
    used for constraint testing. See set_constraint_adjustment.

    An example use case is placing a popup menu on top of a user interface
    element, while aligning the user interface element of the parent surface
    with some user interface element placed somewhere in the popup surface.

    :param x:
        surface position x offset
    :type x: `int`
    :param y:
        surface position y offset
    :type y: `int`
    """
    self._marshal(6, x, y)


XdgPositioner._gen_c()
