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

# Copyright 2015 Sean Vig
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from pywayland.interface import Interface
from ..wayland.output import Output as wl_Output
from ..wayland.surface import Surface as wl_Surface
from .fullscreenshellmodefeedbackv1 import FullscreenShellModeFeedbackV1

import enum


class FullscreenShellV1(Interface):
    """Displays a single surface per output

    Displays a single surface per output.

    This interface provides a mechanism for a single client to display simple
    full-screen surfaces.  While there technically may be multiple clients
    bound to this interface, only one of those clients should be shown at a
    time.

    To present a surface, the client uses either the present_surface or
    present_surface_for_mode requests.  Presenting a surface takes effect on
    the next :func:`Surface.commit()
    <pywayland.protocol.wayland.surface.Surface.commit>`.  See the individual
    requests for details about scaling and mode switches.

    The client can have at most one surface per output at any time. Requesting
    a surface be presented on an output that already has a surface replaces the
    previously presented surface.  Presenting a null surface removes its
    content and effectively disables the output. Exactly what happens when an
    output is "disabled" is compositor-specific.  The same surface may be
    presented on multiple outputs simultaneously.

    Once a surface is presented on an output, it stays on that output until
    either the client removes it or the compositor destroys the output.  This
    way, the client can update the output's contents by simply attaching a new
    buffer.

    Warning! The protocol described in this file is experimental and backward
    incompatible changes may be made. Backward compatible changes may be added
    together with the corresponding interface version bump. Backward
    incompatible changes are done by bumping the version number in the protocol
    and interface names and resetting the interface version. Once the protocol
    is to be declared stable, the 'z' prefix and the version number in the
    protocol and interface names are removed and the interface version number
    is reset.
    """
    name = "zwp_fullscreen_shell_v1"
    version = 1

    capability = enum.Enum("capability", {
        "arbitrary_modes": 1,
        "cursor_plane": 2,
    })

    present_method = enum.Enum("present_method", {
        "default": 0,
        "center": 1,
        "zoom": 2,
        "zoom_crop": 3,
        "stretch": 4,
    })

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


@FullscreenShellV1.request("", [])
def release(self):
    """Release the :class:`~pywayland.protocol.wayland.fullscreenshell.FullscreenShell` interface

    Release the binding from the
    :class:`~pywayland.protocol.wayland.fullscreenshell.FullscreenShell`
    interface

    This destroys the server-side object and frees this binding.  If the client
    binds to
    :class:`~pywayland.protocol.wayland.fullscreenshell.FullscreenShell`
    multiple times, it may wish to free some of those bindings.
    """
    self._marshal(0)
    self._destroy()


@FullscreenShellV1.request("?ou?o", [wl_Surface, None, wl_Output])
def present_surface(self, surface, method, output):
    """Present surface for display

    Present a surface on the given output.

    If the output is null, the compositor will present the surface on whatever
    display (or displays) it thinks best.  In particular, this may replace any
    or all surfaces currently presented so it should not be used in combination
    with placing surfaces on specific outputs.

    The method parameter is a hint to the compositor for how the surface is to
    be presented.  In particular, it tells the compositor how to handle a size
    mismatch between the presented surface and the output.  The compositor is
    free to ignore this parameter.

    The "zoom", "zoom_crop", and "stretch" methods imply a scaling operation on
    the surface.  This will override any kind of output scaling, so the
    buffer_scale property of the surface is effectively ignored.

    :param surface:
    :type surface: :class:`~pywayland.protocol.wayland.surface.Surface` or `None`
    :param method:
    :type method: `uint`
    :param output:
    :type output: :class:`~pywayland.protocol.wayland.output.Output` or `None`
    """
    self._marshal(1, surface, method, output)


@FullscreenShellV1.request("ooin", [wl_Surface, wl_Output, None, FullscreenShellModeFeedbackV1])
def present_surface_for_mode(self, surface, output, framerate):
    """Present surface for display at a particular mode

    Presents a surface on the given output for a particular mode.

    If the current size of the output differs from that of the surface, the
    compositor will attempt to change the size of the output to match the
    surface.  The result of the mode-switch operation will be returned via the
    provided :class:`~pywayland.protocol.wayland.fullscreenshellmodefeedback.Fu
    llscreenShellModeFeedback` object.

    If the current output mode matches the one requested or if the compositor
    successfully switches the mode to match the surface, then the
    mode_successful event will be sent and the output will contain the contents
    of the given surface.  If the compositor cannot match the output size to
    the surface size, the mode_failed will be sent and the output will contain
    the contents of the previously presented surface (if any).  If another
    surface is presented on the given output before either of these has a
    chance to happen, the present_cancelled event will be sent.

    Due to race conditions and other issues unknown to the client, no mode-
    switch operation is guaranteed to succeed.  However, if the mode is one
    advertised by :func:`Output.mode()
    <pywayland.protocol.wayland.output.Output.mode>` or if the compositor
    advertises the ARBITRARY_MODES capability, then the client should expect
    that the mode-switch operation will usually succeed.

    If the size of the presented surface changes, the resulting output is
    undefined.  The compositor may attempt to change the output mode to
    compensate.  However, there is no guarantee that a suitable mode will be
    found and the client has no way to be notified of success or failure.

    The framerate parameter specifies the desired framerate for the output in
    mHz.  The compositor is free to ignore this parameter.  A value of 0
    indicates that the client has no preference.

    If the value of :func:`Output.scale()
    <pywayland.protocol.wayland.output.Output.scale>` differs from
    :func:`Surface.buffer_scale()
    <pywayland.protocol.wayland.surface.Surface.buffer_scale>`, then the
    compositor may choose a mode that matches either the buffer size or the
    surface size.  In either case, the surface will fill the output.

    :param surface:
    :type surface: :class:`~pywayland.protocol.wayland.surface.Surface`
    :param output:
    :type output: :class:`~pywayland.protocol.wayland.output.Output`
    :param framerate:
    :type framerate: `int`
    :returns: :class:`~pywayland.protocol.fullscreen_shell_unstable_v1.fullscreenshellmodefeedbackv1.FullscreenShellModeFeedbackV1`
    """
    feedback = self._marshal_constructor(2, FullscreenShellModeFeedbackV1, surface, output, framerate)
    return feedback


@FullscreenShellV1.event("u", [None])
def capability(self, capabilty):
    """Advertises a capability of the compositor

    Advertises a single capability of the compositor.

    When the
    :class:`~pywayland.protocol.wayland.fullscreenshell.FullscreenShell`
    interface is bound, this event is emitted once for each capability
    advertised.  Valid capabilities are given by the
    :func:`FullscreenShell.capability()
    <pywayland.protocol.wayland.fullscreenshell.FullscreenShell.capability>`
    enum.  If clients want to take advantage of any of these capabilities, they
    should use a :func:`Display.sync()
    <pywayland.protocol.wayland.display.Display.sync>` request immediately
    after binding to ensure that they receive all the capability events.

    :param capabilty:
    :type capabilty: `uint`
    """
    self._post_event(0, capabilty)


FullscreenShellV1._gen_c()
