ui/gfx/x/generated_protos/xfixes.h

// Copyright 2021 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file was automatically generated with:
// ../../ui/gfx/x/gen_xproto.py \
//    ../../third_party/xcbproto/src \
//    gen/ui/gfx/x \
//    bigreq \
//    composite \
//    damage \
//    dpms \
//    dri2 \
//    dri3 \
//    ge \
//    glx \
//    present \
//    randr \
//    record \
//    render \
//    res \
//    screensaver \
//    shape \
//    shm \
//    sync \
//    xc_misc \
//    xevie \
//    xf86dri \
//    xf86vidmode \
//    xfixes \
//    xinerama \
//    xinput \
//    xkb \
//    xprint \
//    xproto \
//    xselinux \
//    xtest \
//    xv \
//    xvmc

#ifndef UI_GFX_X_GENERATED_PROTOS_XFIXES_H_
#define UI_GFX_X_GENERATED_PROTOS_XFIXES_H_

#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <vector>

#include "base/component_export.h"
#include "base/files/scoped_file.h"
#include "base/memory/ref_counted_memory.h"
#include "base/memory/scoped_refptr.h"
#include "render.h"
#include "shape.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "ui/gfx/x/error.h"
#include "ui/gfx/x/ref_counted_fd.h"
#include "xproto.h"

namespace x11 {

class Connection;

template <typename Reply>
struct Response;

template <typename Reply>
class Future;

class COMPONENT_EXPORT(X11) XFixes {
 public:
  static constexpr unsigned major_version = 5;
  static constexpr unsigned minor_version = 0;

  XFixes(Connection* connection, const x11::QueryExtensionReply& info);

  uint8_t present() const { return info_.present; }
  uint8_t major_opcode() const { return info_.major_opcode; }
  uint8_t first_event() const { return info_.first_event; }
  uint8_t first_error() const { return info_.first_error; }

  Connection* connection() const { return connection_; }

  enum class SaveSetMode : int {
    Insert = 0,
    Delete = 1,
  };

  enum class SaveSetTarget : int {
    Nearest = 0,
    Root = 1,
  };

  enum class SaveSetMapping : int {
    Map = 0,
    Unmap = 1,
  };

  enum class SelectionEvent : int {
    SetSelectionOwner = 0,
    SelectionWindowDestroy = 1,
    SelectionClientClose = 2,
  };

  enum class SelectionEventMask : int {
    SetSelectionOwner = 1 << 0,
    SelectionWindowDestroy = 1 << 1,
    SelectionClientClose = 1 << 2,
  };

  enum class CursorNotify : int {
    DisplayCursor = 0,
  };

  enum class CursorNotifyMask : int {
    DisplayCursor = 1 << 0,
  };

  enum class Region : uint32_t {
    None = 0,
  };

  enum class Barrier : uint32_t {};

  enum class BarrierDirections : int {
    PositiveX = 1 << 0,
    PositiveY = 1 << 1,
    NegativeX = 1 << 2,
    NegativeY = 1 << 3,
  };

  struct SelectionNotifyEvent {
    static constexpr int type_id = 18;
    static constexpr uint8_t opcode = 0;
    bool send_event{};
    SelectionEvent subtype{};
    uint16_t sequence{};
    Window window{};
    Window owner{};
    Atom selection{};
    Time timestamp{};
    Time selection_timestamp{};

    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
  };

  struct CursorNotifyEvent {
    static constexpr int type_id = 19;
    static constexpr uint8_t opcode = 1;
    bool send_event{};
    CursorNotify subtype{};
    uint16_t sequence{};
    Window window{};
    uint32_t cursor_serial{};
    Time timestamp{};
    Atom name{};

    x11::Window* GetWindow() { return reinterpret_cast<x11::Window*>(&window); }
  };

  struct BadRegionError : public x11::Error {
    uint16_t sequence{};

    std::string ToString() const override;
  };

  struct QueryVersionRequest {
    uint32_t client_major_version{};
    uint32_t client_minor_version{};
  };

  struct QueryVersionReply {
    uint16_t sequence{};
    uint32_t major_version{};
    uint32_t minor_version{};
  };

  using QueryVersionResponse = Response<QueryVersionReply>;

  Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request);

  Future<QueryVersionReply> QueryVersion(
      const uint32_t& client_major_version = {},
      const uint32_t& client_minor_version = {});

  struct ChangeSaveSetRequest {
    SaveSetMode mode{};
    SaveSetTarget target{};
    SaveSetMapping map{};
    Window window{};
  };

  using ChangeSaveSetResponse = Response<void>;

  Future<void> ChangeSaveSet(const ChangeSaveSetRequest& request);

  Future<void> ChangeSaveSet(const SaveSetMode& mode = {},
                             const SaveSetTarget& target = {},
                             const SaveSetMapping& map = {},
                             const Window& window = {});

  struct SelectSelectionInputRequest {
    Window window{};
    Atom selection{};
    SelectionEventMask event_mask{};
  };

  using SelectSelectionInputResponse = Response<void>;

  Future<void> SelectSelectionInput(const SelectSelectionInputRequest& request);

  Future<void> SelectSelectionInput(const Window& window = {},
                                    const Atom& selection = {},
                                    const SelectionEventMask& event_mask = {});

  struct SelectCursorInputRequest {
    Window window{};
    CursorNotifyMask event_mask{};
  };

  using SelectCursorInputResponse = Response<void>;

  Future<void> SelectCursorInput(const SelectCursorInputRequest& request);

  Future<void> SelectCursorInput(const Window& window = {},
                                 const CursorNotifyMask& event_mask = {});

  struct GetCursorImageRequest {};

  struct GetCursorImageReply {
    uint16_t sequence{};
    int16_t x{};
    int16_t y{};
    uint16_t width{};
    uint16_t height{};
    uint16_t xhot{};
    uint16_t yhot{};
    uint32_t cursor_serial{};
    std::vector<uint32_t> cursor_image{};
  };

  using GetCursorImageResponse = Response<GetCursorImageReply>;

  Future<GetCursorImageReply> GetCursorImage(
      const GetCursorImageRequest& request);

  Future<GetCursorImageReply> GetCursorImage();

  struct CreateRegionRequest {
    Region region{};
    std::vector<Rectangle> rectangles{};
  };

  using CreateRegionResponse = Response<void>;

  Future<void> CreateRegion(const CreateRegionRequest& request);

  Future<void> CreateRegion(const Region& region = {},
                            const std::vector<Rectangle>& rectangles = {});

  struct CreateRegionFromBitmapRequest {
    Region region{};
    Pixmap bitmap{};
  };

  using CreateRegionFromBitmapResponse = Response<void>;

  Future<void> CreateRegionFromBitmap(
      const CreateRegionFromBitmapRequest& request);

  Future<void> CreateRegionFromBitmap(const Region& region = {},
                                      const Pixmap& bitmap = {});

  struct CreateRegionFromWindowRequest {
    Region region{};
    Window window{};
    Shape::Sk kind{};
  };

  using CreateRegionFromWindowResponse = Response<void>;

  Future<void> CreateRegionFromWindow(
      const CreateRegionFromWindowRequest& request);

  Future<void> CreateRegionFromWindow(const Region& region = {},
                                      const Window& window = {},
                                      const Shape::Sk& kind = {});

  struct CreateRegionFromGCRequest {
    Region region{};
    GraphicsContext gc{};
  };

  using CreateRegionFromGCResponse = Response<void>;

  Future<void> CreateRegionFromGC(const CreateRegionFromGCRequest& request);

  Future<void> CreateRegionFromGC(const Region& region = {},
                                  const GraphicsContext& gc = {});

  struct CreateRegionFromPictureRequest {
    Region region{};
    Render::Picture picture{};
  };

  using CreateRegionFromPictureResponse = Response<void>;

  Future<void> CreateRegionFromPicture(
      const CreateRegionFromPictureRequest& request);

  Future<void> CreateRegionFromPicture(const Region& region = {},
                                       const Render::Picture& picture = {});

  struct DestroyRegionRequest {
    Region region{};
  };

  using DestroyRegionResponse = Response<void>;

  Future<void> DestroyRegion(const DestroyRegionRequest& request);

  Future<void> DestroyRegion(const Region& region = {});

  struct SetRegionRequest {
    Region region{};
    std::vector<Rectangle> rectangles{};
  };

  using SetRegionResponse = Response<void>;

  Future<void> SetRegion(const SetRegionRequest& request);

  Future<void> SetRegion(const Region& region = {},
                         const std::vector<Rectangle>& rectangles = {});

  struct CopyRegionRequest {
    Region source{};
    Region destination{};
  };

  using CopyRegionResponse = Response<void>;

  Future<void> CopyRegion(const CopyRegionRequest& request);

  Future<void> CopyRegion(const Region& source = {},
                          const Region& destination = {});

  struct UnionRegionRequest {
    Region source1{};
    Region source2{};
    Region destination{};
  };

  using UnionRegionResponse = Response<void>;

  Future<void> UnionRegion(const UnionRegionRequest& request);

  Future<void> UnionRegion(const Region& source1 = {},
                           const Region& source2 = {},
                           const Region& destination = {});

  struct IntersectRegionRequest {
    Region source1{};
    Region source2{};
    Region destination{};
  };

  using IntersectRegionResponse = Response<void>;

  Future<void> IntersectRegion(const IntersectRegionRequest& request);

  Future<void> IntersectRegion(const Region& source1 = {},
                               const Region& source2 = {},
                               const Region& destination = {});

  struct SubtractRegionRequest {
    Region source1{};
    Region source2{};
    Region destination{};
  };

  using SubtractRegionResponse = Response<void>;

  Future<void> SubtractRegion(const SubtractRegionRequest& request);

  Future<void> SubtractRegion(const Region& source1 = {},
                              const Region& source2 = {},
                              const Region& destination = {});

  struct InvertRegionRequest {
    Region source{};
    Rectangle bounds{};
    Region destination{};
  };

  using InvertRegionResponse = Response<void>;

  Future<void> InvertRegion(const InvertRegionRequest& request);

  Future<void> InvertRegion(const Region& source = {},
                            const Rectangle& bounds = {{}, {}, {}, {}},
                            const Region& destination = {});

  struct TranslateRegionRequest {
    Region region{};
    int16_t dx{};
    int16_t dy{};
  };

  using TranslateRegionResponse = Response<void>;

  Future<void> TranslateRegion(const TranslateRegionRequest& request);

  Future<void> TranslateRegion(const Region& region = {},
                               const int16_t& dx = {},
                               const int16_t& dy = {});

  struct RegionExtentsRequest {
    Region source{};
    Region destination{};
  };

  using RegionExtentsResponse = Response<void>;

  Future<void> RegionExtents(const RegionExtentsRequest& request);

  Future<void> RegionExtents(const Region& source = {},
                             const Region& destination = {});

  struct FetchRegionRequest {
    Region region{};
  };

  struct FetchRegionReply {
    uint16_t sequence{};
    Rectangle extents{};
    std::vector<Rectangle> rectangles{};
  };

  using FetchRegionResponse = Response<FetchRegionReply>;

  Future<FetchRegionReply> FetchRegion(const FetchRegionRequest& request);

  Future<FetchRegionReply> FetchRegion(const Region& region = {});

  struct SetGCClipRegionRequest {
    GraphicsContext gc{};
    Region region{};
    int16_t x_origin{};
    int16_t y_origin{};
  };

  using SetGCClipRegionResponse = Response<void>;

  Future<void> SetGCClipRegion(const SetGCClipRegionRequest& request);

  Future<void> SetGCClipRegion(const GraphicsContext& gc = {},
                               const Region& region = {},
                               const int16_t& x_origin = {},
                               const int16_t& y_origin = {});

  struct SetWindowShapeRegionRequest {
    Window dest{};
    Shape::Sk dest_kind{};
    int16_t x_offset{};
    int16_t y_offset{};
    Region region{};
  };

  using SetWindowShapeRegionResponse = Response<void>;

  Future<void> SetWindowShapeRegion(const SetWindowShapeRegionRequest& request);

  Future<void> SetWindowShapeRegion(const Window& dest = {},
                                    const Shape::Sk& dest_kind = {},
                                    const int16_t& x_offset = {},
                                    const int16_t& y_offset = {},
                                    const Region& region = {});

  struct SetPictureClipRegionRequest {
    Render::Picture picture{};
    Region region{};
    int16_t x_origin{};
    int16_t y_origin{};
  };

  using SetPictureClipRegionResponse = Response<void>;

  Future<void> SetPictureClipRegion(const SetPictureClipRegionRequest& request);

  Future<void> SetPictureClipRegion(const Render::Picture& picture = {},
                                    const Region& region = {},
                                    const int16_t& x_origin = {},
                                    const int16_t& y_origin = {});

  struct SetCursorNameRequest {
    Cursor cursor{};
    std::string name{};
  };

  using SetCursorNameResponse = Response<void>;

  Future<void> SetCursorName(const SetCursorNameRequest& request);

  Future<void> SetCursorName(const Cursor& cursor = {},
                             const std::string& name = {});

  struct GetCursorNameRequest {
    Cursor cursor{};
  };

  struct GetCursorNameReply {
    uint16_t sequence{};
    Atom atom{};
    std::string name{};
  };

  using GetCursorNameResponse = Response<GetCursorNameReply>;

  Future<GetCursorNameReply> GetCursorName(const GetCursorNameRequest& request);

  Future<GetCursorNameReply> GetCursorName(const Cursor& cursor = {});

  struct GetCursorImageAndNameRequest {};

  struct GetCursorImageAndNameReply {
    uint16_t sequence{};
    int16_t x{};
    int16_t y{};
    uint16_t width{};
    uint16_t height{};
    uint16_t xhot{};
    uint16_t yhot{};
    uint32_t cursor_serial{};
    Atom cursor_atom{};
    std::vector<uint32_t> cursor_image{};
    std::string name{};
  };

  using GetCursorImageAndNameResponse = Response<GetCursorImageAndNameReply>;

  Future<GetCursorImageAndNameReply> GetCursorImageAndName(
      const GetCursorImageAndNameRequest& request);

  Future<GetCursorImageAndNameReply> GetCursorImageAndName();

  struct ChangeCursorRequest {
    Cursor source{};
    Cursor destination{};
  };

  using ChangeCursorResponse = Response<void>;

  Future<void> ChangeCursor(const ChangeCursorRequest& request);

  Future<void> ChangeCursor(const Cursor& source = {},
                            const Cursor& destination = {});

  struct ChangeCursorByNameRequest {
    Cursor src{};
    std::string name{};
  };

  using ChangeCursorByNameResponse = Response<void>;

  Future<void> ChangeCursorByName(const ChangeCursorByNameRequest& request);

  Future<void> ChangeCursorByName(const Cursor& src = {},
                                  const std::string& name = {});

  struct ExpandRegionRequest {
    Region source{};
    Region destination{};
    uint16_t left{};
    uint16_t right{};
    uint16_t top{};
    uint16_t bottom{};
  };

  using ExpandRegionResponse = Response<void>;

  Future<void> ExpandRegion(const ExpandRegionRequest& request);

  Future<void> ExpandRegion(const Region& source = {},
                            const Region& destination = {},
                            const uint16_t& left = {},
                            const uint16_t& right = {},
                            const uint16_t& top = {},
                            const uint16_t& bottom = {});

  struct HideCursorRequest {
    Window window{};
  };

  using HideCursorResponse = Response<void>;

  Future<void> HideCursor(const HideCursorRequest& request);

  Future<void> HideCursor(const Window& window = {});

  struct ShowCursorRequest {
    Window window{};
  };

  using ShowCursorResponse = Response<void>;

  Future<void> ShowCursor(const ShowCursorRequest& request);

  Future<void> ShowCursor(const Window& window = {});

  struct CreatePointerBarrierRequest {
    Barrier barrier{};
    Window window{};
    uint16_t x1{};
    uint16_t y1{};
    uint16_t x2{};
    uint16_t y2{};
    BarrierDirections directions{};
    std::vector<uint16_t> devices{};
  };

  using CreatePointerBarrierResponse = Response<void>;

  Future<void> CreatePointerBarrier(const CreatePointerBarrierRequest& request);

  Future<void> CreatePointerBarrier(const Barrier& barrier = {},
                                    const Window& window = {},
                                    const uint16_t& x1 = {},
                                    const uint16_t& y1 = {},
                                    const uint16_t& x2 = {},
                                    const uint16_t& y2 = {},
                                    const BarrierDirections& directions = {},
                                    const std::vector<uint16_t>& devices = {});

  struct DeletePointerBarrierRequest {
    Barrier barrier{};
  };

  using DeletePointerBarrierResponse = Response<void>;

  Future<void> DeletePointerBarrier(const DeletePointerBarrierRequest& request);

  Future<void> DeletePointerBarrier(const Barrier& barrier = {});

 private:
  Connection* const connection_;
  x11::QueryExtensionReply info_{};
};

}  // namespace x11

inline constexpr x11::XFixes::SaveSetMode operator|(
    x11::XFixes::SaveSetMode l,
    x11::XFixes::SaveSetMode r) {
  using T = std::underlying_type_t<x11::XFixes::SaveSetMode>;
  return static_cast<x11::XFixes::SaveSetMode>(static_cast<T>(l) |
                                               static_cast<T>(r));
}

inline constexpr x11::XFixes::SaveSetMode operator&(
    x11::XFixes::SaveSetMode l,
    x11::XFixes::SaveSetMode r) {
  using T = std::underlying_type_t<x11::XFixes::SaveSetMode>;
  return static_cast<x11::XFixes::SaveSetMode>(static_cast<T>(l) &
                                               static_cast<T>(r));
}

inline constexpr x11::XFixes::SaveSetTarget operator|(
    x11::XFixes::SaveSetTarget l,
    x11::XFixes::SaveSetTarget r) {
  using T = std::underlying_type_t<x11::XFixes::SaveSetTarget>;
  return static_cast<x11::XFixes::SaveSetTarget>(static_cast<T>(l) |
                                                 static_cast<T>(r));
}

inline constexpr x11::XFixes::SaveSetTarget operator&(
    x11::XFixes::SaveSetTarget l,
    x11::XFixes::SaveSetTarget r) {
  using T = std::underlying_type_t<x11::XFixes::SaveSetTarget>;
  return static_cast<x11::XFixes::SaveSetTarget>(static_cast<T>(l) &
                                                 static_cast<T>(r));
}

inline constexpr x11::XFixes::SaveSetMapping operator|(
    x11::XFixes::SaveSetMapping l,
    x11::XFixes::SaveSetMapping r) {
  using T = std::underlying_type_t<x11::XFixes::SaveSetMapping>;
  return static_cast<x11::XFixes::SaveSetMapping>(static_cast<T>(l) |
                                                  static_cast<T>(r));
}

inline constexpr x11::XFixes::SaveSetMapping operator&(
    x11::XFixes::SaveSetMapping l,
    x11::XFixes::SaveSetMapping r) {
  using T = std::underlying_type_t<x11::XFixes::SaveSetMapping>;
  return static_cast<x11::XFixes::SaveSetMapping>(static_cast<T>(l) &
                                                  static_cast<T>(r));
}

inline constexpr x11::XFixes::SelectionEvent operator|(
    x11::XFixes::SelectionEvent l,
    x11::XFixes::SelectionEvent r) {
  using T = std::underlying_type_t<x11::XFixes::SelectionEvent>;
  return static_cast<x11::XFixes::SelectionEvent>(static_cast<T>(l) |
                                                  static_cast<T>(r));
}

inline constexpr x11::XFixes::SelectionEvent operator&(
    x11::XFixes::SelectionEvent l,
    x11::XFixes::SelectionEvent r) {
  using T = std::underlying_type_t<x11::XFixes::SelectionEvent>;
  return static_cast<x11::XFixes::SelectionEvent>(static_cast<T>(l) &
                                                  static_cast<T>(r));
}

inline constexpr x11::XFixes::SelectionEventMask operator|(
    x11::XFixes::SelectionEventMask l,
    x11::XFixes::SelectionEventMask r) {
  using T = std::underlying_type_t<x11::XFixes::SelectionEventMask>;
  return static_cast<x11::XFixes::SelectionEventMask>(static_cast<T>(l) |
                                                      static_cast<T>(r));
}

inline constexpr x11::XFixes::SelectionEventMask operator&(
    x11::XFixes::SelectionEventMask l,
    x11::XFixes::SelectionEventMask r) {
  using T = std::underlying_type_t<x11::XFixes::SelectionEventMask>;
  return static_cast<x11::XFixes::SelectionEventMask>(static_cast<T>(l) &
                                                      static_cast<T>(r));
}

inline constexpr x11::XFixes::CursorNotify operator|(
    x11::XFixes::CursorNotify l,
    x11::XFixes::CursorNotify r) {
  using T = std::underlying_type_t<x11::XFixes::CursorNotify>;
  return static_cast<x11::XFixes::CursorNotify>(static_cast<T>(l) |
                                                static_cast<T>(r));
}

inline constexpr x11::XFixes::CursorNotify operator&(
    x11::XFixes::CursorNotify l,
    x11::XFixes::CursorNotify r) {
  using T = std::underlying_type_t<x11::XFixes::CursorNotify>;
  return static_cast<x11::XFixes::CursorNotify>(static_cast<T>(l) &
                                                static_cast<T>(r));
}

inline constexpr x11::XFixes::CursorNotifyMask operator|(
    x11::XFixes::CursorNotifyMask l,
    x11::XFixes::CursorNotifyMask r) {
  using T = std::underlying_type_t<x11::XFixes::CursorNotifyMask>;
  return static_cast<x11::XFixes::CursorNotifyMask>(static_cast<T>(l) |
                                                    static_cast<T>(r));
}

inline constexpr x11::XFixes::CursorNotifyMask operator&(
    x11::XFixes::CursorNotifyMask l,
    x11::XFixes::CursorNotifyMask r) {
  using T = std::underlying_type_t<x11::XFixes::CursorNotifyMask>;
  return static_cast<x11::XFixes::CursorNotifyMask>(static_cast<T>(l) &
                                                    static_cast<T>(r));
}

inline constexpr x11::XFixes::Region operator|(x11::XFixes::Region l,
                                               x11::XFixes::Region r) {
  using T = std::underlying_type_t<x11::XFixes::Region>;
  return static_cast<x11::XFixes::Region>(static_cast<T>(l) |
                                          static_cast<T>(r));
}

inline constexpr x11::XFixes::Region operator&(x11::XFixes::Region l,
                                               x11::XFixes::Region r) {
  using T = std::underlying_type_t<x11::XFixes::Region>;
  return static_cast<x11::XFixes::Region>(static_cast<T>(l) &
                                          static_cast<T>(r));
}

inline constexpr x11::XFixes::BarrierDirections operator|(
    x11::XFixes::BarrierDirections l,
    x11::XFixes::BarrierDirections r) {
  using T = std::underlying_type_t<x11::XFixes::BarrierDirections>;
  return static_cast<x11::XFixes::BarrierDirections>(static_cast<T>(l) |
                                                     static_cast<T>(r));
}

inline constexpr x11::XFixes::BarrierDirections operator&(
    x11::XFixes::BarrierDirections l,
    x11::XFixes::BarrierDirections r) {
  using T = std::underlying_type_t<x11::XFixes::BarrierDirections>;
  return static_cast<x11::XFixes::BarrierDirections>(static_cast<T>(l) &
                                                     static_cast<T>(r));
}

#endif  // UI_GFX_X_GENERATED_PROTOS_XFIXES_H_