// Copyright 2021 The Chromium Authors
// 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 \
// dri3 \
// glx \
// randr \
// render \
// screensaver \
// shape \
// shm \
// sync \
// xfixes \
// xinput \
// xkb \
// xproto \
// xtest
#ifndef UI_GFX_X_GENERATED_PROTOS_RENDER_H_
#define UI_GFX_X_GENERATED_PROTOS_RENDER_H_
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <optional>
#include <vector>
#include "base/component_export.h"
#include "base/files/scoped_file.h"
#include "base/memory/scoped_refptr.h"
#include "ui/gfx/x/error.h"
#include "ui/gfx/x/ref_counted_fd.h"
#include "ui/gfx/x/xproto_types.h"
#include "xproto.h"
namespace x11 {
class Connection;
template <typename Reply>
struct Response;
template <typename Reply>
class Future;
class COMPONENT_EXPORT(X11) Render {
public:
static constexpr unsigned major_version = 0;
static constexpr unsigned minor_version = 11;
Render(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 PictType : int {
Indexed = 0,
Direct = 1,
};
enum class Picture : uint32_t {
None = 0,
};
enum class PictOp : int {
Clear = 0,
Src = 1,
Dst = 2,
Over = 3,
OverReverse = 4,
In = 5,
InReverse = 6,
Out = 7,
OutReverse = 8,
Atop = 9,
AtopReverse = 10,
Xor = 11,
Add = 12,
Saturate = 13,
DisjointClear = 16,
DisjointSrc = 17,
DisjointDst = 18,
DisjointOver = 19,
DisjointOverReverse = 20,
DisjointIn = 21,
DisjointInReverse = 22,
DisjointOut = 23,
DisjointOutReverse = 24,
DisjointAtop = 25,
DisjointAtopReverse = 26,
DisjointXor = 27,
ConjointClear = 32,
ConjointSrc = 33,
ConjointDst = 34,
ConjointOver = 35,
ConjointOverReverse = 36,
ConjointIn = 37,
ConjointInReverse = 38,
ConjointOut = 39,
ConjointOutReverse = 40,
ConjointAtop = 41,
ConjointAtopReverse = 42,
ConjointXor = 43,
Multiply = 48,
Screen = 49,
Overlay = 50,
Darken = 51,
Lighten = 52,
ColorDodge = 53,
ColorBurn = 54,
HardLight = 55,
SoftLight = 56,
Difference = 57,
Exclusion = 58,
HSLHue = 59,
HSLSaturation = 60,
HSLColor = 61,
HSLLuminosity = 62,
};
enum class PolyEdge : int {
Sharp = 0,
Smooth = 1,
};
enum class PolyMode : int {
Precise = 0,
Imprecise = 1,
};
enum class CreatePictureAttribute : int {
Repeat = 1 << 0,
AlphaMap = 1 << 1,
AlphaXOrigin = 1 << 2,
AlphaYOrigin = 1 << 3,
ClipXOrigin = 1 << 4,
ClipYOrigin = 1 << 5,
ClipMask = 1 << 6,
GraphicsExposure = 1 << 7,
SubwindowMode = 1 << 8,
PolyEdge = 1 << 9,
PolyMode = 1 << 10,
Dither = 1 << 11,
ComponentAlpha = 1 << 12,
};
enum class SubPixel : int {
Unknown = 0,
HorizontalRGB = 1,
HorizontalBGR = 2,
VerticalRGB = 3,
VerticalBGR = 4,
None = 5,
};
enum class Repeat : int {
None = 0,
Normal = 1,
Pad = 2,
Reflect = 3,
};
enum class Glyph : uint32_t {};
enum class GlyphSet : uint32_t {};
enum class PictFormat : uint32_t {};
enum class Fixed : int32_t {};
struct PictFormatError : public x11::Error {
uint16_t sequence{};
uint32_t bad_value{};
uint16_t minor_opcode{};
uint8_t major_opcode{};
std::string ToString() const override;
};
struct PictureError : public x11::Error {
uint16_t sequence{};
uint32_t bad_value{};
uint16_t minor_opcode{};
uint8_t major_opcode{};
std::string ToString() const override;
};
struct PictOpError : public x11::Error {
uint16_t sequence{};
uint32_t bad_value{};
uint16_t minor_opcode{};
uint8_t major_opcode{};
std::string ToString() const override;
};
struct GlyphSetError : public x11::Error {
uint16_t sequence{};
uint32_t bad_value{};
uint16_t minor_opcode{};
uint8_t major_opcode{};
std::string ToString() const override;
};
struct GlyphError : public x11::Error {
uint16_t sequence{};
uint32_t bad_value{};
uint16_t minor_opcode{};
uint8_t major_opcode{};
std::string ToString() const override;
};
struct DirectFormat {
bool operator==(const DirectFormat& other) const {
return red_shift == other.red_shift && red_mask == other.red_mask &&
green_shift == other.green_shift &&
green_mask == other.green_mask && blue_shift == other.blue_shift &&
blue_mask == other.blue_mask && alpha_shift == other.alpha_shift &&
alpha_mask == other.alpha_mask;
}
uint16_t red_shift{};
uint16_t red_mask{};
uint16_t green_shift{};
uint16_t green_mask{};
uint16_t blue_shift{};
uint16_t blue_mask{};
uint16_t alpha_shift{};
uint16_t alpha_mask{};
};
struct PictFormInfo {
bool operator==(const PictFormInfo& other) const {
return id == other.id && type == other.type && depth == other.depth &&
direct == other.direct && colormap == other.colormap;
}
PictFormat id{};
PictType type{};
uint8_t depth{};
DirectFormat direct{};
ColorMap colormap{};
};
struct PictVisual {
bool operator==(const PictVisual& other) const {
return visual == other.visual && format == other.format;
}
VisualId visual{};
PictFormat format{};
};
struct PictDepth {
bool operator==(const PictDepth& other) const {
return depth == other.depth && visuals == other.visuals;
}
uint8_t depth{};
std::vector<PictVisual> visuals{};
};
struct PictScreen {
bool operator==(const PictScreen& other) const {
return fallback == other.fallback && depths == other.depths;
}
PictFormat fallback{};
std::vector<PictDepth> depths{};
};
struct IndexValue {
bool operator==(const IndexValue& other) const {
return pixel == other.pixel && red == other.red && green == other.green &&
blue == other.blue && alpha == other.alpha;
}
uint32_t pixel{};
uint16_t red{};
uint16_t green{};
uint16_t blue{};
uint16_t alpha{};
};
struct Color {
bool operator==(const Color& other) const {
return red == other.red && green == other.green && blue == other.blue &&
alpha == other.alpha;
}
uint16_t red{};
uint16_t green{};
uint16_t blue{};
uint16_t alpha{};
};
struct PointFix {
bool operator==(const PointFix& other) const {
return x == other.x && y == other.y;
}
Fixed x{};
Fixed y{};
};
struct LineFix {
bool operator==(const LineFix& other) const {
return p1 == other.p1 && p2 == other.p2;
}
PointFix p1{};
PointFix p2{};
};
struct Triangle {
bool operator==(const Triangle& other) const {
return p1 == other.p1 && p2 == other.p2 && p3 == other.p3;
}
PointFix p1{};
PointFix p2{};
PointFix p3{};
};
struct Trapezoid {
bool operator==(const Trapezoid& other) const {
return top == other.top && bottom == other.bottom && left == other.left &&
right == other.right;
}
Fixed top{};
Fixed bottom{};
LineFix left{};
LineFix right{};
};
struct GlyphInfo {
bool operator==(const GlyphInfo& other) const {
return width == other.width && height == other.height && x == other.x &&
y == other.y && x_off == other.x_off && y_off == other.y_off;
}
uint16_t width{};
uint16_t height{};
int16_t x{};
int16_t y{};
int16_t x_off{};
int16_t y_off{};
};
struct Transform {
bool operator==(const Transform& other) const {
return matrix11 == other.matrix11 && matrix12 == other.matrix12 &&
matrix13 == other.matrix13 && matrix21 == other.matrix21 &&
matrix22 == other.matrix22 && matrix23 == other.matrix23 &&
matrix31 == other.matrix31 && matrix32 == other.matrix32 &&
matrix33 == other.matrix33;
}
Fixed matrix11{};
Fixed matrix12{};
Fixed matrix13{};
Fixed matrix21{};
Fixed matrix22{};
Fixed matrix23{};
Fixed matrix31{};
Fixed matrix32{};
Fixed matrix33{};
};
struct AnimationCursorElement {
bool operator==(const AnimationCursorElement& other) const {
return cursor == other.cursor && delay == other.delay;
}
Cursor cursor{};
uint32_t delay{};
};
struct SpanFix {
bool operator==(const SpanFix& other) const {
return l == other.l && r == other.r && y == other.y;
}
Fixed l{};
Fixed r{};
Fixed y{};
};
struct Trap {
bool operator==(const Trap& other) const {
return top == other.top && bot == other.bot;
}
SpanFix top{};
SpanFix bot{};
};
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 QueryPictFormatsRequest {};
struct QueryPictFormatsReply {
uint16_t sequence{};
uint32_t num_depths{};
uint32_t num_visuals{};
std::vector<PictFormInfo> formats{};
std::vector<PictScreen> screens{};
std::vector<SubPixel> subpixels{};
};
using QueryPictFormatsResponse = Response<QueryPictFormatsReply>;
Future<QueryPictFormatsReply> QueryPictFormats(
const QueryPictFormatsRequest& request);
Future<QueryPictFormatsReply> QueryPictFormats();
struct QueryPictIndexValuesRequest {
PictFormat format{};
};
struct QueryPictIndexValuesReply {
uint16_t sequence{};
std::vector<IndexValue> values{};
};
using QueryPictIndexValuesResponse = Response<QueryPictIndexValuesReply>;
Future<QueryPictIndexValuesReply> QueryPictIndexValues(
const QueryPictIndexValuesRequest& request);
Future<QueryPictIndexValuesReply> QueryPictIndexValues(
const PictFormat& format = {});
struct CreatePictureRequest {
Picture pid{};
Drawable drawable{};
PictFormat format{};
std::optional<Repeat> repeat{};
std::optional<Picture> alphamap{};
std::optional<int32_t> alphaxorigin{};
std::optional<int32_t> alphayorigin{};
std::optional<int32_t> clipxorigin{};
std::optional<int32_t> clipyorigin{};
std::optional<Pixmap> clipmask{};
std::optional<uint32_t> graphicsexposure{};
std::optional<SubwindowMode> subwindowmode{};
std::optional<PolyEdge> polyedge{};
std::optional<PolyMode> polymode{};
std::optional<Atom> dither{};
std::optional<uint32_t> componentalpha{};
};
using CreatePictureResponse = Response<void>;
Future<void> CreatePicture(const CreatePictureRequest& request);
Future<void> CreatePicture(
const Picture& pid = {},
const Drawable& drawable = {},
const PictFormat& format = {},
const std::optional<Repeat>& repeat = std::nullopt,
const std::optional<Picture>& alphamap = std::nullopt,
const std::optional<int32_t>& alphaxorigin = std::nullopt,
const std::optional<int32_t>& alphayorigin = std::nullopt,
const std::optional<int32_t>& clipxorigin = std::nullopt,
const std::optional<int32_t>& clipyorigin = std::nullopt,
const std::optional<Pixmap>& clipmask = std::nullopt,
const std::optional<uint32_t>& graphicsexposure = std::nullopt,
const std::optional<SubwindowMode>& subwindowmode = std::nullopt,
const std::optional<PolyEdge>& polyedge = std::nullopt,
const std::optional<PolyMode>& polymode = std::nullopt,
const std::optional<Atom>& dither = std::nullopt,
const std::optional<uint32_t>& componentalpha = std::nullopt);
struct ChangePictureRequest {
Picture picture{};
std::optional<Repeat> repeat{};
std::optional<Picture> alphamap{};
std::optional<int32_t> alphaxorigin{};
std::optional<int32_t> alphayorigin{};
std::optional<int32_t> clipxorigin{};
std::optional<int32_t> clipyorigin{};
std::optional<Pixmap> clipmask{};
std::optional<uint32_t> graphicsexposure{};
std::optional<SubwindowMode> subwindowmode{};
std::optional<PolyEdge> polyedge{};
std::optional<PolyMode> polymode{};
std::optional<Atom> dither{};
std::optional<uint32_t> componentalpha{};
};
using ChangePictureResponse = Response<void>;
Future<void> ChangePicture(const ChangePictureRequest& request);
Future<void> ChangePicture(
const Picture& picture = {},
const std::optional<Repeat>& repeat = std::nullopt,
const std::optional<Picture>& alphamap = std::nullopt,
const std::optional<int32_t>& alphaxorigin = std::nullopt,
const std::optional<int32_t>& alphayorigin = std::nullopt,
const std::optional<int32_t>& clipxorigin = std::nullopt,
const std::optional<int32_t>& clipyorigin = std::nullopt,
const std::optional<Pixmap>& clipmask = std::nullopt,
const std::optional<uint32_t>& graphicsexposure = std::nullopt,
const std::optional<SubwindowMode>& subwindowmode = std::nullopt,
const std::optional<PolyEdge>& polyedge = std::nullopt,
const std::optional<PolyMode>& polymode = std::nullopt,
const std::optional<Atom>& dither = std::nullopt,
const std::optional<uint32_t>& componentalpha = std::nullopt);
struct SetPictureClipRectanglesRequest {
Picture picture{};
int16_t clip_x_origin{};
int16_t clip_y_origin{};
std::vector<Rectangle> rectangles{};
};
using SetPictureClipRectanglesResponse = Response<void>;
Future<void> SetPictureClipRectangles(
const SetPictureClipRectanglesRequest& request);
Future<void> SetPictureClipRectangles(
const Picture& picture = {},
const int16_t& clip_x_origin = {},
const int16_t& clip_y_origin = {},
const std::vector<Rectangle>& rectangles = {});
struct FreePictureRequest {
Picture picture{};
};
using FreePictureResponse = Response<void>;
Future<void> FreePicture(const FreePictureRequest& request);
Future<void> FreePicture(const Picture& picture = {});
struct CompositeRequest {
PictOp op{};
Picture src{};
Picture mask{};
Picture dst{};
int16_t src_x{};
int16_t src_y{};
int16_t mask_x{};
int16_t mask_y{};
int16_t dst_x{};
int16_t dst_y{};
uint16_t width{};
uint16_t height{};
};
using CompositeResponse = Response<void>;
Future<void> Composite(const CompositeRequest& request);
Future<void> Composite(const PictOp& op = {},
const Picture& src = {},
const Picture& mask = {},
const Picture& dst = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const int16_t& mask_x = {},
const int16_t& mask_y = {},
const int16_t& dst_x = {},
const int16_t& dst_y = {},
const uint16_t& width = {},
const uint16_t& height = {});
struct TrapezoidsRequest {
PictOp op{};
Picture src{};
Picture dst{};
PictFormat mask_format{};
int16_t src_x{};
int16_t src_y{};
std::vector<Trapezoid> traps{};
};
using TrapezoidsResponse = Response<void>;
Future<void> Trapezoids(const TrapezoidsRequest& request);
Future<void> Trapezoids(const PictOp& op = {},
const Picture& src = {},
const Picture& dst = {},
const PictFormat& mask_format = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const std::vector<Trapezoid>& traps = {});
struct TrianglesRequest {
PictOp op{};
Picture src{};
Picture dst{};
PictFormat mask_format{};
int16_t src_x{};
int16_t src_y{};
std::vector<Triangle> triangles{};
};
using TrianglesResponse = Response<void>;
Future<void> Triangles(const TrianglesRequest& request);
Future<void> Triangles(const PictOp& op = {},
const Picture& src = {},
const Picture& dst = {},
const PictFormat& mask_format = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const std::vector<Triangle>& triangles = {});
struct TriStripRequest {
PictOp op{};
Picture src{};
Picture dst{};
PictFormat mask_format{};
int16_t src_x{};
int16_t src_y{};
std::vector<PointFix> points{};
};
using TriStripResponse = Response<void>;
Future<void> TriStrip(const TriStripRequest& request);
Future<void> TriStrip(const PictOp& op = {},
const Picture& src = {},
const Picture& dst = {},
const PictFormat& mask_format = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const std::vector<PointFix>& points = {});
struct TriFanRequest {
PictOp op{};
Picture src{};
Picture dst{};
PictFormat mask_format{};
int16_t src_x{};
int16_t src_y{};
std::vector<PointFix> points{};
};
using TriFanResponse = Response<void>;
Future<void> TriFan(const TriFanRequest& request);
Future<void> TriFan(const PictOp& op = {},
const Picture& src = {},
const Picture& dst = {},
const PictFormat& mask_format = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const std::vector<PointFix>& points = {});
struct CreateGlyphSetRequest {
GlyphSet gsid{};
PictFormat format{};
};
using CreateGlyphSetResponse = Response<void>;
Future<void> CreateGlyphSet(const CreateGlyphSetRequest& request);
Future<void> CreateGlyphSet(const GlyphSet& gsid = {},
const PictFormat& format = {});
struct ReferenceGlyphSetRequest {
GlyphSet gsid{};
GlyphSet existing{};
};
using ReferenceGlyphSetResponse = Response<void>;
Future<void> ReferenceGlyphSet(const ReferenceGlyphSetRequest& request);
Future<void> ReferenceGlyphSet(const GlyphSet& gsid = {},
const GlyphSet& existing = {});
struct FreeGlyphSetRequest {
GlyphSet glyphset{};
};
using FreeGlyphSetResponse = Response<void>;
Future<void> FreeGlyphSet(const FreeGlyphSetRequest& request);
Future<void> FreeGlyphSet(const GlyphSet& glyphset = {});
struct AddGlyphsRequest {
GlyphSet glyphset{};
std::vector<uint32_t> glyphids{};
std::vector<GlyphInfo> glyphs{};
std::vector<uint8_t> data{};
};
using AddGlyphsResponse = Response<void>;
Future<void> AddGlyphs(const AddGlyphsRequest& request);
Future<void> AddGlyphs(const GlyphSet& glyphset = {},
const std::vector<uint32_t>& glyphids = {},
const std::vector<GlyphInfo>& glyphs = {},
const std::vector<uint8_t>& data = {});
struct FreeGlyphsRequest {
GlyphSet glyphset{};
std::vector<Glyph> glyphs{};
};
using FreeGlyphsResponse = Response<void>;
Future<void> FreeGlyphs(const FreeGlyphsRequest& request);
Future<void> FreeGlyphs(const GlyphSet& glyphset = {},
const std::vector<Glyph>& glyphs = {});
struct CompositeGlyphs8Request {
PictOp op{};
Picture src{};
Picture dst{};
PictFormat mask_format{};
GlyphSet glyphset{};
int16_t src_x{};
int16_t src_y{};
std::vector<uint8_t> glyphcmds{};
};
using CompositeGlyphs8Response = Response<void>;
Future<void> CompositeGlyphs8(const CompositeGlyphs8Request& request);
Future<void> CompositeGlyphs8(const PictOp& op = {},
const Picture& src = {},
const Picture& dst = {},
const PictFormat& mask_format = {},
const GlyphSet& glyphset = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const std::vector<uint8_t>& glyphcmds = {});
struct CompositeGlyphs16Request {
PictOp op{};
Picture src{};
Picture dst{};
PictFormat mask_format{};
GlyphSet glyphset{};
int16_t src_x{};
int16_t src_y{};
std::vector<uint8_t> glyphcmds{};
};
using CompositeGlyphs16Response = Response<void>;
Future<void> CompositeGlyphs16(const CompositeGlyphs16Request& request);
Future<void> CompositeGlyphs16(const PictOp& op = {},
const Picture& src = {},
const Picture& dst = {},
const PictFormat& mask_format = {},
const GlyphSet& glyphset = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const std::vector<uint8_t>& glyphcmds = {});
struct CompositeGlyphs32Request {
PictOp op{};
Picture src{};
Picture dst{};
PictFormat mask_format{};
GlyphSet glyphset{};
int16_t src_x{};
int16_t src_y{};
std::vector<uint8_t> glyphcmds{};
};
using CompositeGlyphs32Response = Response<void>;
Future<void> CompositeGlyphs32(const CompositeGlyphs32Request& request);
Future<void> CompositeGlyphs32(const PictOp& op = {},
const Picture& src = {},
const Picture& dst = {},
const PictFormat& mask_format = {},
const GlyphSet& glyphset = {},
const int16_t& src_x = {},
const int16_t& src_y = {},
const std::vector<uint8_t>& glyphcmds = {});
struct FillRectanglesRequest {
PictOp op{};
Picture dst{};
Color color{};
std::vector<Rectangle> rects{};
};
using FillRectanglesResponse = Response<void>;
Future<void> FillRectangles(const FillRectanglesRequest& request);
Future<void> FillRectangles(const PictOp& op = {},
const Picture& dst = {},
const Color& color = {{}, {}, {}, {}},
const std::vector<Rectangle>& rects = {});
struct CreateCursorRequest {
Cursor cid{};
Picture source{};
uint16_t x{};
uint16_t y{};
};
using CreateCursorResponse = Response<void>;
Future<void> CreateCursor(const CreateCursorRequest& request);
Future<void> CreateCursor(const Cursor& cid = {},
const Picture& source = {},
const uint16_t& x = {},
const uint16_t& y = {});
struct SetPictureTransformRequest {
Picture picture{};
Transform transform{};
};
using SetPictureTransformResponse = Response<void>;
Future<void> SetPictureTransform(const SetPictureTransformRequest& request);
Future<void> SetPictureTransform(
const Picture& picture = {},
const Transform& transform = {{}, {}, {}, {}, {}, {}, {}, {}, {}});
struct QueryFiltersRequest {
Drawable drawable{};
};
struct QueryFiltersReply {
uint16_t sequence{};
std::vector<uint16_t> aliases{};
std::vector<Str> filters{};
};
using QueryFiltersResponse = Response<QueryFiltersReply>;
Future<QueryFiltersReply> QueryFilters(const QueryFiltersRequest& request);
Future<QueryFiltersReply> QueryFilters(const Drawable& drawable = {});
struct SetPictureFilterRequest {
Picture picture{};
std::string filter{};
std::vector<Fixed> values{};
};
using SetPictureFilterResponse = Response<void>;
Future<void> SetPictureFilter(const SetPictureFilterRequest& request);
Future<void> SetPictureFilter(const Picture& picture = {},
const std::string& filter = {},
const std::vector<Fixed>& values = {});
struct CreateAnimCursorRequest {
Cursor cid{};
std::vector<AnimationCursorElement> cursors{};
};
using CreateAnimCursorResponse = Response<void>;
Future<void> CreateAnimCursor(const CreateAnimCursorRequest& request);
Future<void> CreateAnimCursor(
const Cursor& cid = {},
const std::vector<AnimationCursorElement>& cursors = {});
struct AddTrapsRequest {
Picture picture{};
int16_t x_off{};
int16_t y_off{};
std::vector<Trap> traps{};
};
using AddTrapsResponse = Response<void>;
Future<void> AddTraps(const AddTrapsRequest& request);
Future<void> AddTraps(const Picture& picture = {},
const int16_t& x_off = {},
const int16_t& y_off = {},
const std::vector<Trap>& traps = {});
struct CreateSolidFillRequest {
Picture picture{};
Color color{};
};
using CreateSolidFillResponse = Response<void>;
Future<void> CreateSolidFill(const CreateSolidFillRequest& request);
Future<void> CreateSolidFill(const Picture& picture = {},
const Color& color = {{}, {}, {}, {}});
struct CreateLinearGradientRequest {
Picture picture{};
PointFix p1{};
PointFix p2{};
std::vector<Fixed> stops{};
std::vector<Color> colors{};
};
using CreateLinearGradientResponse = Response<void>;
Future<void> CreateLinearGradient(const CreateLinearGradientRequest& request);
Future<void> CreateLinearGradient(const Picture& picture = {},
const PointFix& p1 = {{}, {}},
const PointFix& p2 = {{}, {}},
const std::vector<Fixed>& stops = {},
const std::vector<Color>& colors = {});
struct CreateRadialGradientRequest {
Picture picture{};
PointFix inner{};
PointFix outer{};
Fixed inner_radius{};
Fixed outer_radius{};
std::vector<Fixed> stops{};
std::vector<Color> colors{};
};
using CreateRadialGradientResponse = Response<void>;
Future<void> CreateRadialGradient(const CreateRadialGradientRequest& request);
Future<void> CreateRadialGradient(const Picture& picture = {},
const PointFix& inner = {{}, {}},
const PointFix& outer = {{}, {}},
const Fixed& inner_radius = {},
const Fixed& outer_radius = {},
const std::vector<Fixed>& stops = {},
const std::vector<Color>& colors = {});
struct CreateConicalGradientRequest {
Picture picture{};
PointFix center{};
Fixed angle{};
std::vector<Fixed> stops{};
std::vector<Color> colors{};
};
using CreateConicalGradientResponse = Response<void>;
Future<void> CreateConicalGradient(
const CreateConicalGradientRequest& request);
Future<void> CreateConicalGradient(const Picture& picture = {},
const PointFix& center = {{}, {}},
const Fixed& angle = {},
const std::vector<Fixed>& stops = {},
const std::vector<Color>& colors = {});
private:
Connection* const connection_;
x11::QueryExtensionReply info_{};
};
} // namespace x11
inline constexpr x11::Render::PictType operator|(x11::Render::PictType l,
x11::Render::PictType r) {
using T = std::underlying_type_t<x11::Render::PictType>;
return static_cast<x11::Render::PictType>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::PictType operator&(x11::Render::PictType l,
x11::Render::PictType r) {
using T = std::underlying_type_t<x11::Render::PictType>;
return static_cast<x11::Render::PictType>(static_cast<T>(l) &
static_cast<T>(r));
}
inline constexpr x11::Render::Picture operator|(x11::Render::Picture l,
x11::Render::Picture r) {
using T = std::underlying_type_t<x11::Render::Picture>;
return static_cast<x11::Render::Picture>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::Picture operator&(x11::Render::Picture l,
x11::Render::Picture r) {
using T = std::underlying_type_t<x11::Render::Picture>;
return static_cast<x11::Render::Picture>(static_cast<T>(l) &
static_cast<T>(r));
}
inline constexpr x11::Render::PictOp operator|(x11::Render::PictOp l,
x11::Render::PictOp r) {
using T = std::underlying_type_t<x11::Render::PictOp>;
return static_cast<x11::Render::PictOp>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::PictOp operator&(x11::Render::PictOp l,
x11::Render::PictOp r) {
using T = std::underlying_type_t<x11::Render::PictOp>;
return static_cast<x11::Render::PictOp>(static_cast<T>(l) &
static_cast<T>(r));
}
inline constexpr x11::Render::PolyEdge operator|(x11::Render::PolyEdge l,
x11::Render::PolyEdge r) {
using T = std::underlying_type_t<x11::Render::PolyEdge>;
return static_cast<x11::Render::PolyEdge>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::PolyEdge operator&(x11::Render::PolyEdge l,
x11::Render::PolyEdge r) {
using T = std::underlying_type_t<x11::Render::PolyEdge>;
return static_cast<x11::Render::PolyEdge>(static_cast<T>(l) &
static_cast<T>(r));
}
inline constexpr x11::Render::PolyMode operator|(x11::Render::PolyMode l,
x11::Render::PolyMode r) {
using T = std::underlying_type_t<x11::Render::PolyMode>;
return static_cast<x11::Render::PolyMode>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::PolyMode operator&(x11::Render::PolyMode l,
x11::Render::PolyMode r) {
using T = std::underlying_type_t<x11::Render::PolyMode>;
return static_cast<x11::Render::PolyMode>(static_cast<T>(l) &
static_cast<T>(r));
}
inline constexpr x11::Render::CreatePictureAttribute operator|(
x11::Render::CreatePictureAttribute l,
x11::Render::CreatePictureAttribute r) {
using T = std::underlying_type_t<x11::Render::CreatePictureAttribute>;
return static_cast<x11::Render::CreatePictureAttribute>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::CreatePictureAttribute operator&(
x11::Render::CreatePictureAttribute l,
x11::Render::CreatePictureAttribute r) {
using T = std::underlying_type_t<x11::Render::CreatePictureAttribute>;
return static_cast<x11::Render::CreatePictureAttribute>(static_cast<T>(l) &
static_cast<T>(r));
}
inline constexpr x11::Render::SubPixel operator|(x11::Render::SubPixel l,
x11::Render::SubPixel r) {
using T = std::underlying_type_t<x11::Render::SubPixel>;
return static_cast<x11::Render::SubPixel>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::SubPixel operator&(x11::Render::SubPixel l,
x11::Render::SubPixel r) {
using T = std::underlying_type_t<x11::Render::SubPixel>;
return static_cast<x11::Render::SubPixel>(static_cast<T>(l) &
static_cast<T>(r));
}
inline constexpr x11::Render::Repeat operator|(x11::Render::Repeat l,
x11::Render::Repeat r) {
using T = std::underlying_type_t<x11::Render::Repeat>;
return static_cast<x11::Render::Repeat>(static_cast<T>(l) |
static_cast<T>(r));
}
inline constexpr x11::Render::Repeat operator&(x11::Render::Repeat l,
x11::Render::Repeat r) {
using T = std::underlying_type_t<x11::Render::Repeat>;
return static_cast<x11::Render::Repeat>(static_cast<T>(l) &
static_cast<T>(r));
}
#endif // UI_GFX_X_GENERATED_PROTOS_RENDER_H_
Codebase Browser
chromium